|
0
|
1 /*
|
|
|
2 +--------------------------------------------------------------------+
|
|
|
3 | PROJECT: MMI-Framework (8417) $Workfile:: mfw_sat.c $|
|
|
|
4 | $Author:: Xsp $ CONDAT GmbH $Revision:: 12 $|
|
|
|
5 | CREATED: 07.05.99 $Modtime:: 23/02/00 20:23 $|
|
|
|
6 | STATE : code |
|
|
|
7 +--------------------------------------------------------------------+
|
|
|
8
|
|
|
9 MODULE : MFW_SAT
|
|
|
10
|
|
|
11 PURPOSE : SIM Application Toolkit Handling
|
|
|
12
|
|
|
13 EXPORT :
|
|
|
14
|
|
|
15 TO DO :
|
|
|
16
|
|
|
17 $History:: mfw_sat.c
|
|
|
18
|
|
|
19 Shashi Shekar B.S., a0876501, 16 Mar, 2006, OMAPS00061462
|
|
|
20 Icon support for SetupMenu & Select item.
|
|
|
21
|
|
|
22 Mar 11, 2006 REF:DR:OMAPS00061467 x0035544
|
|
|
23 Description: 27.22.4.13.3 SET UP CALL (display of icons) fails.
|
|
|
24 Solution: SAT icon is supported for the SAT CALL SETUP.
|
|
|
25
|
|
|
26 Jan 16, 2006 DR: OMAPS00061460 - Shashi Shekar B.S.
|
|
|
27 Description: SAT Icon support
|
|
|
28 Solution : SAT icon support added.
|
|
|
29
|
|
|
30 Aug 31, 2005 REF: CRR 33619 x0021334
|
|
|
31 Description: RE: Notification of SATK File Change
|
|
|
32 Solution: Added the stub function 'rAT_PercentSIMEF()'.
|
|
|
33
|
|
|
34 July 26, 2005 REF: SPR 29520 x0018858
|
|
|
35 Issue: 27.22.4.5 Proactive SIM Command: PLAY TONE fails
|
|
|
36 Solution: The window which used to come up "Please wait" was not getting destroyed.
|
|
|
37 Care has been taken to check this.
|
|
|
38
|
|
|
39 Jun 16, 2005 REF: CRR 31543 x0021334
|
|
|
40 Issue: SATK: cannot get TR for send ussd command
|
|
|
41 Solution: When the user presses "Hang up" key when the SAT USSD session is in progress,
|
|
|
42 a call is made to function 'sAT_end_ussd()' to end the USSD session.
|
|
|
43
|
|
|
44 Aug 16, 2004 REF: CRR 24323 Deepa M.D
|
|
|
45 Bug:Clenup of sprintf used for tracing
|
|
|
46 Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX $
|
|
|
47 *
|
|
|
48 * ***************** Version 12 *****************
|
|
|
49 * User: Xsp Date: 24/02/00 Time: 5:42
|
|
|
50 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
51 * Debugged MmiSimToolkit...
|
|
|
52 *
|
|
|
53 * ***************** Version 11 *****************
|
|
|
54 * User: Fk Date: 23.02.00 Time: 18:33
|
|
|
55 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
56 * Comprehension flags provided for default Terminal Response
|
|
|
57 *
|
|
|
58 * ***************** Version 10 *****************
|
|
|
59 * User: Xsp Date: 16/02/00 Time: 19:22
|
|
|
60 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
61 * Fixed double allocation in satCreate()...
|
|
|
62 *
|
|
|
63 * ***************** Version 9 *****************
|
|
|
64 * User: Xsp Date: 14/02/00 Time: 18:11
|
|
|
65 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
66 * Solved compiler errors...
|
|
|
67 *
|
|
|
68 * ***************** Version 8 *****************
|
|
|
69 * User: Xsp Date: 14/02/00 Time: 14:43
|
|
|
70 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
71 * Added window pointers to sat structure...
|
|
|
72 *
|
|
|
73 * ***************** Version 7 *****************
|
|
|
74 * User: Fk Date: 11.02.00 Time: 15:40
|
|
|
75 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
76 * New event 'SAT Session End' derived from empty command
|
|
|
77 *
|
|
|
78 * ***************** Version 6 *****************
|
|
|
79 * User: Fk Date: 10.02.00 Time: 16:43
|
|
|
80 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
81 * Filter for Terminal Profile
|
|
|
82 *
|
|
|
83 * ***************** Version 5 *****************
|
|
|
84 * User: Vo Date: 17.11.99 Time: 10:47
|
|
|
85 * Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
86 |
|
|
|
87 | ***************** Version 4 *****************
|
|
|
88 | User: Le Date: 1.10.99 Time: 15:28
|
|
|
89 | Updated in $/GSM/Condat/MS/SRC/MFW
|
|
|
90 *
|
|
|
91 * ***************** Version 3 *****************
|
|
|
92 * User: Es Date: 9.07.99 Time: 14:32
|
|
|
93 * Updated in $/GSM/DEV/MS/SRC/MFW
|
|
|
94 *
|
|
|
95 * ***************** Version 2 *****************
|
|
|
96 * User: Es Date: 8.07.99 Time: 12:04
|
|
|
97 * Updated in $/GSM/DEV/MS/SRC/MFW
|
|
|
98 *
|
|
|
99 * ***************** Version 1 *****************
|
|
|
100 * User: Es Date: 6.07.99 Time: 12:42
|
|
|
101 * Created in $/GSM/DEV/MS/SRC/MFW
|
|
|
102 * SIM application toolkit handler
|
|
|
103 * Initial
|
|
|
104 */
|
|
|
105 #define ENTITY_MFW
|
|
|
106
|
|
|
107 #include <stdio.h>
|
|
|
108 #include <string.h>
|
|
|
109
|
|
|
110 #if defined (NEW_FRAME)
|
|
|
111
|
|
|
112 #include "typedefs.h"
|
|
|
113 #include "vsi.h"
|
|
|
114 #include "custom.h"
|
|
|
115 #include "gsm.h"
|
|
|
116 #include "tok.h"
|
|
|
117
|
|
|
118 #else
|
|
|
119
|
|
|
120 #include "STDDEFS.H"
|
|
|
121 #include "custom.h"
|
|
|
122 #include "gsm.h"
|
|
|
123 #include "vsi.h"
|
|
|
124 #include "tok.h"
|
|
|
125
|
|
|
126 #endif
|
|
|
127
|
|
|
128 #include "message.h"
|
|
|
129 #include "prim.h"
|
|
|
130 #include "aci_cmh.h"
|
|
|
131 #include "ati_cmd.h"
|
|
|
132 //#include "aci_cmd.h"
|
|
|
133 #include "aci.h"
|
|
|
134 #include "prim.h"
|
|
|
135 #include "psa.h"
|
|
|
136 #include "psa_sim.h"
|
|
|
137 #include "psa_cc.h"
|
|
|
138 #include "psa_sat.h"
|
|
|
139
|
|
|
140 #include "mfw_mfw.h"
|
|
|
141 #include "mfw_sys.h"
|
|
|
142 #include "aci_cmh.h"
|
|
|
143 #include "mfw_win.h"
|
|
|
144 #include "mfw_sat.h"
|
|
|
145
|
|
|
146 #include "mfw_phb.h"
|
|
|
147 #include "mfw_nm.h"
|
|
|
148 #include "mfw_sima.h"
|
|
|
149 #include "mfw_nmi.h"
|
|
|
150 #include "mfw_sim.h"
|
|
|
151 #include "mfw_simi.h"
|
|
|
152 #include "mfw_cphs.h"
|
|
|
153 #include "mfw_cphsi.h"
|
|
|
154 #include "mfw_sms.h"
|
|
|
155 #include "mfw_smsi.h"
|
|
|
156
|
|
|
157 #include "cus_aci.h"
|
|
|
158
|
|
|
159 #ifndef PCM_2_FFS
|
|
|
160 #include "pcm.h"
|
|
|
161 #endif
|
|
|
162
|
|
|
163
|
|
|
164
|
|
|
165 extern char mfwSATLPRefresh;
|
|
|
166
|
|
|
167 #define TRM_RSP_LEN (256) /*SPR#2121 - DS - Length of Terminal Response buffer */
|
|
|
168 #define CMD_DETAILS_LEN (5) /*SPR#2121 - DS - Length of default command details buffer */
|
|
|
169
|
|
|
170 char mfwSatMoAccepted = 0;
|
|
|
171 static U8 lenResponse; /* len of terminal response */
|
|
|
172 const static U8 defResponse [] = /* default response values */
|
|
|
173 {
|
|
|
174 0x81, 0x03, 0x00, 0x00, 0x00, /* command details */
|
|
|
175 0x82, 0x02, 0x82, 0x81, /* device identities */
|
|
|
176 0x83, 0x01, 0x32 /* result */
|
|
|
177 };
|
|
|
178 static U8 defCmdDetails [CMD_DETAILS_LEN]; /*SPR#2121 - DS - Default SAT command details */
|
|
|
179 static U8 satNoResponse = 0; /* flag: no resp. from MFW */
|
|
|
180
|
|
|
181 static U8 curCR; /* current TLV CR flag */
|
|
|
182 static U8 curTag; /* current TLV tag */
|
|
|
183 static U8 curLen; /* current TLV length */
|
|
|
184 static U8 *curVal; /* current TLV value */
|
|
|
185
|
|
|
186 SHORT curSatCallId;
|
|
|
187
|
|
|
188 static U8 *curCmd; /* current command pointer */
|
|
|
189 static S16 curCmdLen; /* len of current command */
|
|
|
190 static U8 *curData; /* data storage /end buffer */
|
|
|
191 static SatCmd cmd; /* temp storage for command */
|
|
|
192 SatCmd* sat_cmd_saved; /* SPR#2321 - DS - Copy of SAT cmd details */
|
|
|
193
|
|
|
194 static U8 partialCompr; /* partial comprehension */
|
|
|
195
|
|
|
196 static U16 eventList;
|
|
|
197
|
|
|
198 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
199 #ifdef FF_MMI_SAT_ICON
|
|
|
200 static U32 curSATCmd = MfwSatCmdNone;
|
|
|
201 // Shashi Shekar B.S., a0876501, Feb 4, 2006, DR: OMAPS00061462
|
|
|
202 // Modified the below defn to accomodate changes for SetupMenu / Select Item.
|
|
|
203 static U8 isAlphaIdIconPresent = FALSE;
|
|
|
204 static U8 isItemIconPresent = FALSE;
|
|
|
205 static T_EF_IMG icon_image;
|
|
|
206 U8 read_image_instance_file = FALSE;
|
|
|
207 //x0035544 Mar 11, 2006. DR:OMAPS00061467
|
|
|
208 static U8 setupCall_Executed = FALSE;
|
|
|
209
|
|
|
210 #define BW_ICON 0x11
|
|
|
211 #define COLOR_ICON 0x21
|
|
|
212
|
|
|
213 #define MAX_SIM_EF_SIZE 0xFF
|
|
|
214
|
|
|
215 /* Assuming 8-bpp, RGB 332 format for destination */
|
|
|
216
|
|
|
217 #define RGB_TO_PIXEL(R, G, B, value) \
|
|
|
218 do \
|
|
|
219 { \
|
|
|
220 value = ((R) & 0xe0) | (((G) & 0xe0) >> 3) | (((B) & 0xc0) >> 6); \
|
|
|
221 } while(0)
|
|
|
222 #endif
|
|
|
223
|
|
|
224 typedef struct
|
|
|
225 {
|
|
|
226 U8 count;
|
|
|
227 USHORT fields[MFW_MAX_NT_SIZE];
|
|
|
228 } T_MFW_UPDATE_FIELDS;
|
|
|
229
|
|
|
230 static T_MFW_UPDATE_FIELDS udNotify; /* update fields */
|
|
|
231 static int fuRef;
|
|
|
232 static BOOL fu_aborted;
|
|
|
233 static int satCommand (U32 cmd, void *h);
|
|
|
234 static void satResponse (U8 res);
|
|
|
235
|
|
|
236 const static satMfWSuppTPrf[] = { /* Profile supported by MFW */
|
|
|
237 #ifdef SAT_TP1_PRF_DNL
|
|
|
238 SAT_TP1_PRF_DNL | SAT_TP1_MENU_SEL,
|
|
|
239 SAT_TP2_CMD_RES | SAT_TP2_CC | SAT_TP2_MOSMC | SAT_TP2_ALPHA_ID
|
|
|
240 | SAT_TP2_UCS2_ENTRY | SAT_TP2_UCS2_DSPL | SAT_TP2_DSPL_EXT,
|
|
|
241 SAT_TP3_DSPL_TXT | SAT_TP3_GET_INKEY | SAT_TP3_GET_INPUT
|
|
|
242 | SAT_TP3_PLAY_TONE | SAT_TP3_REFRESH,
|
|
|
243 SAT_TP4_SEL_ITEM | SAT_TP4_SETUP_MENU | SAT_TP4_SEND_SMS
|
|
|
244 | SAT_TP4_SEND_SS | SAT_TP4_SEND_USSD | SAT_TP4_SETUP_CALL,
|
|
|
245 SAT_TP5_EVENT_LIST | SAT_TP5_USER_ACT | SAT_TP5_SCR_AVAIL,
|
|
|
246 0x0, 0x0,
|
|
|
247 SAT_TP8_BIN_GET_INKEY | SAT_TP8_IDLE_TXT | SAT_TP8_AI2_SETUP_CALL,
|
|
|
248 #if defined(FF_WAP)
|
|
|
249 SAT_TP9_SUST_DSPL_TXT|SAT_TP9_LAUNCH_BROWSER,
|
|
|
250 #else
|
|
|
251 SAT_TP9_SUST_DSPL_TXT,
|
|
|
252 #endif /*FF_WAP*/
|
|
|
253 0x0, 0x0,
|
|
|
254 SAT_TP12_OPEN_CHANNEL | SAT_TP12_CLOSE_CHANNEL | SAT_TP12_RECEIVE_DATA |
|
|
|
255 SAT_TP12_SEND_DATA,
|
|
|
256 SAT_TP13_CSD_SUPP_BY_ME | SAT_TP13_GPRS_SUPP_BY_ME
|
|
|
257 #else
|
|
|
258 #ifdef FF_2TO1_PS
|
|
|
259 0x09, 0x73, 0x17, 0x37 /* c032 rsa */
|
|
|
260 #else
|
|
|
261 /*0x09, 0x73, 0x17, 0x37 */ /* c032 rsa */
|
|
|
262 #endif
|
|
|
263
|
|
|
264 #endif
|
|
|
265 };
|
|
|
266
|
|
|
267 extern MfwHdr *current_mfw_elem;
|
|
|
268 //x0035544 added fixes done for CQ33597 by x0021334 on 21-11-2005
|
|
|
269 // x0021334 : To test SAT session end - CQ33597
|
|
|
270 /* Handler for cancel event sent by the MMI sim toolkit */
|
|
|
271 void Mfw_SAT_DTMF_EndSession(void)
|
|
|
272 {
|
|
|
273 sAT_PercentSATT( CMD_SRC_LCL, SATT_CS_EndSession);
|
|
|
274 return;
|
|
|
275 }
|
|
|
276
|
|
|
277
|
|
|
278
|
|
|
279 /*
|
|
|
280 +--------------------------------------------------------------------+
|
|
|
281 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
282 | STATE : code ROUTINE : satInit |
|
|
|
283 +--------------------------------------------------------------------+
|
|
|
284
|
|
|
285 PURPOSE : initialize SAT handler
|
|
|
286
|
|
|
287 */
|
|
|
288
|
|
|
289 MfwRes satInit (U8 *profile, U8 plen)
|
|
|
290 {
|
|
|
291 int i;
|
|
|
292 #ifdef FF_2TO1_PS
|
|
|
293 U8 combProfile [SIM_MAX_STK_PRF];
|
|
|
294 #else
|
|
|
295 U8 combProfile [MAX_STK_PRF];
|
|
|
296 #endif
|
|
|
297
|
|
|
298 TRACE_FUNCTION("satInit()");
|
|
|
299
|
|
|
300 mfwCommand[MfwTypSat] = (MfwCb) satCommand;
|
|
|
301 satNoResponse = 0;
|
|
|
302 mfwSatMoAccepted = 0;
|
|
|
303 mfwSATLPRefresh = 0;
|
|
|
304 eventList= 0;
|
|
|
305 fu_aborted = FALSE;
|
|
|
306 #ifdef FF_2TO1_PS
|
|
|
307 plen = MINIMUM(plen, SIM_MAX_STK_PRF);
|
|
|
308 #else
|
|
|
309 plen = MINIMUM(plen, MAX_STK_PRF);
|
|
|
310 #endif
|
|
|
311 sat_cmd_saved = NULL; /* SPR#2321 - DS - Initialise ptr to saved cmd */
|
|
|
312 for (i = 0; i < (int)plen; i++) // check profile against
|
|
|
313 { // MFW capability
|
|
|
314 if (i < sizeof(satMfWSuppTPrf))
|
|
|
315 combProfile[i] = profile[i] & satMfWSuppTPrf[i];
|
|
|
316 else
|
|
|
317 combProfile[i] = 0;
|
|
|
318 }
|
|
|
319 sAT_PercentSATC(CMD_SRC_LCL,plen,combProfile);
|
|
|
320
|
|
|
321 /* install the call back for file change notification */
|
|
|
322 fuRef = -1;
|
|
|
323 psaSAT_FUNotifyRegister(satRefreshNotification);
|
|
|
324 psaSAT_FURegister (satChangeNotify);
|
|
|
325
|
|
|
326 return MfwResOk;
|
|
|
327 }
|
|
|
328
|
|
|
329
|
|
|
330 /*
|
|
|
331 +--------------------------------------------------------------------+
|
|
|
332 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
333 | STATE : code ROUTINE : satExit |
|
|
|
334 +--------------------------------------------------------------------+
|
|
|
335
|
|
|
336 PURPOSE : finalize SAT handler
|
|
|
337
|
|
|
338 */
|
|
|
339
|
|
|
340 MfwRes satExit (void)
|
|
|
341 {
|
|
|
342 mfwCommand[MfwTypSat] = 0;
|
|
|
343
|
|
|
344 return MfwResOk;
|
|
|
345 }
|
|
|
346
|
|
|
347
|
|
|
348 /*
|
|
|
349 +--------------------------------------------------------------------+
|
|
|
350 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
351 | STATE : code ROUTINE : satCreate |
|
|
|
352 +--------------------------------------------------------------------+
|
|
|
353
|
|
|
354 PURPOSE : create SAT control
|
|
|
355
|
|
|
356 */
|
|
|
357
|
|
|
358 MfwHnd satCreate (MfwHnd w, MfwEvt e, MfwCb f, SatCmd *c)
|
|
|
359 {
|
|
|
360 MfwSat *sat = (MfwSat*) mfwAlloc(sizeof(MfwSat));
|
|
|
361 MfwHdr *hdr = (MfwHdr *)mfwAlloc(sizeof(MfwHdr));
|
|
|
362 MfwHdr *insert_status =0;
|
|
|
363
|
|
|
364 if (!hdr || !sat)
|
|
|
365 {
|
|
|
366 TRACE_ERROR("ERROR: satCreate() Mem Alloc Failed.");
|
|
|
367
|
|
|
368 if(hdr)
|
|
|
369 mfwFree((U8*)hdr,sizeof(MfwHdr));
|
|
|
370 if(sat)
|
|
|
371 mfwFree((U8*)sat,sizeof(MfwSat));
|
|
|
372
|
|
|
373 return 0;
|
|
|
374 }
|
|
|
375
|
|
|
376 sat->map = e;
|
|
|
377 sat->evt = 0;
|
|
|
378 sat->handler = f;
|
|
|
379 sat->cmd = c;
|
|
|
380 sat->parentWindow = w;
|
|
|
381 sat->currentWindow = NULL;
|
|
|
382
|
|
|
383 hdr->data = sat;
|
|
|
384 hdr->type = MfwTypSat;
|
|
|
385
|
|
|
386 insert_status = mfwInsert(NULL,hdr);
|
|
|
387 if(!insert_status)
|
|
|
388 {
|
|
|
389 TRACE_ERROR("ERROR: satCreate() Failed to Install Handler. ");
|
|
|
390 mfwFree((U8*)hdr,sizeof(MfwHdr));
|
|
|
391 mfwFree((U8*)sat ,sizeof(MfwSat));
|
|
|
392 return 0;
|
|
|
393 }
|
|
|
394 return insert_status;
|
|
|
395 }
|
|
|
396
|
|
|
397
|
|
|
398 /*
|
|
|
399 +--------------------------------------------------------------------+
|
|
|
400 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
401 | STATE : code ROUTINE : satDelete |
|
|
|
402 +--------------------------------------------------------------------+
|
|
|
403
|
|
|
404 PURPOSE : delete SAT control
|
|
|
405
|
|
|
406 */
|
|
|
407
|
|
|
408 MfwRes satDelete (MfwHnd h)
|
|
|
409 {
|
|
|
410 MfwRes res;
|
|
|
411
|
|
|
412 if (!h)
|
|
|
413 return MfwResIllHnd;
|
|
|
414
|
|
|
415 res = (mfwRemove(h)) ? MfwResOk : MfwResIllHnd;
|
|
|
416
|
|
|
417 mfwFree(((MfwHdr *) h)->data,sizeof(MfwSat));
|
|
|
418 mfwFree(h,sizeof(MfwHdr));
|
|
|
419
|
|
|
420 return res;
|
|
|
421 }
|
|
|
422
|
|
|
423
|
|
|
424 /*
|
|
|
425 +--------------------------------------------------------------------+
|
|
|
426 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
427 | STATE : code ROUTINE : satString |
|
|
|
428 +--------------------------------------------------------------------+
|
|
|
429
|
|
|
430 PURPOSE : user string to SIM
|
|
|
431
|
|
|
432 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
433
|
|
|
434 */
|
|
|
435
|
|
|
436 MfwRes satString (SatCmd *cmd, SatTxt *txt, U8 *res, int rlen)
|
|
|
437 {
|
|
|
438 S16 ti;
|
|
|
439 U8* trmResponse = NULL;
|
|
|
440
|
|
|
441 TRACE_FUNCTION("satString()");
|
|
|
442
|
|
|
443 /* Allocate memory for Terminal Response buffer */
|
|
|
444 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
445
|
|
|
446 if (trmResponse == NULL)
|
|
|
447 {
|
|
|
448 /* Memory allocation failed */
|
|
|
449 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
450 return MfwResNoMem;
|
|
|
451 }
|
|
|
452
|
|
|
453 /*SPR#2121 - DS - Set up terminal response with default values */
|
|
|
454 lenResponse = sizeof(defResponse); /* prep. terminal response */
|
|
|
455 memcpy(trmResponse,defResponse,lenResponse);
|
|
|
456
|
|
|
457 trmResponse[2] = cmd->number; /* command number */
|
|
|
458 trmResponse[3] = cmd->type; /* command type */
|
|
|
459 trmResponse[4] = cmd->qual; /* command qualifier */
|
|
|
460
|
|
|
461 ti = sizeof(defResponse) - 2; /* result length */
|
|
|
462 if(res[1] != SatResAiNoCause) /* only attach additional information if existent*/
|
|
|
463 {
|
|
|
464 trmResponse[ti++] = rlen; /* dito */
|
|
|
465 while (rlen--)
|
|
|
466 trmResponse[ti++] = *res++; /* result data */
|
|
|
467 }
|
|
|
468 else /* result ok no additional resultcode attached*/
|
|
|
469 {
|
|
|
470 trmResponse[ti++] = 0x01;
|
|
|
471 trmResponse[ti++] = *res;
|
|
|
472 }
|
|
|
473 trmResponse[ti++] = 0x8D; /* text string tag + CR */
|
|
|
474 if (txt->len + 1 > 161) /* incl. coding scheme byte */
|
|
|
475 {
|
|
|
476 TRACE_ERROR("Text too long!!!");
|
|
|
477 return MfwResErr;
|
|
|
478 }
|
|
|
479 if (txt->len + 1 > 127)
|
|
|
480 trmResponse[ti++] = 0x81;
|
|
|
481 trmResponse[ti++] = txt->len + 1;
|
|
|
482 trmResponse[ti++] = txt->code; /* data coding scheme */
|
|
|
483 memcpy(trmResponse+ti,(U8*)txt+txt->text,txt->len);
|
|
|
484
|
|
|
485 sAT_PercentSATR(CMD_SRC_LCL,(S16)(ti+txt->len),trmResponse);
|
|
|
486
|
|
|
487 /* Deallocate memory used for Terminal Response buffer */
|
|
|
488 if (trmResponse != NULL)
|
|
|
489 {
|
|
|
490 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
491 trmResponse = NULL;
|
|
|
492 }
|
|
|
493
|
|
|
494 return MfwResOk;
|
|
|
495 }
|
|
|
496
|
|
|
497
|
|
|
498 /*
|
|
|
499 +--------------------------------------------------------------------+
|
|
|
500 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
501 | STATE : code ROUTINE : satItem |
|
|
|
502 +--------------------------------------------------------------------+
|
|
|
503
|
|
|
504 PURPOSE : user selected popup item to SIM
|
|
|
505
|
|
|
506 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
507
|
|
|
508 */
|
|
|
509
|
|
|
510 MfwRes satItem (SatCmd *cmd, U8 itemId, U8 *res, int rlen)
|
|
|
511 {
|
|
|
512 S16 ti;
|
|
|
513 U8* trmResponse;
|
|
|
514
|
|
|
515 TRACE_FUNCTION("satItem()");
|
|
|
516
|
|
|
517 /* Allocate memory for Terminal Response buffer */
|
|
|
518 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
519
|
|
|
520 if (trmResponse == NULL)
|
|
|
521 {
|
|
|
522 /* Memory allocation failed */
|
|
|
523 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
524 return MfwResNoMem;
|
|
|
525 }
|
|
|
526
|
|
|
527 /*SPR#2121 - DS - Set up terminal response with default values */
|
|
|
528 lenResponse = sizeof(defResponse); /* prep. terminal response */
|
|
|
529 memcpy(trmResponse,defResponse,lenResponse);
|
|
|
530
|
|
|
531 trmResponse[2] = cmd->number; /* command number */
|
|
|
532 trmResponse[3] = cmd->type; /* command type */
|
|
|
533 trmResponse[4] = cmd->qual; /* command qualifier */
|
|
|
534
|
|
|
535 ti = sizeof(defResponse) - 2; /* result length */
|
|
|
536 if(res[1] != SatResAiNoCause) /* only attach additional information if existent*/
|
|
|
537 {
|
|
|
538 trmResponse[ti++] = rlen; /* dito */
|
|
|
539 while (rlen--)
|
|
|
540 trmResponse[ti++] = *res++; /* result data */
|
|
|
541 }
|
|
|
542 else /* result ok no additional resultcode attached*/
|
|
|
543 {
|
|
|
544 trmResponse[ti++] = 0x01;
|
|
|
545 trmResponse[ti++] = *res;
|
|
|
546 }
|
|
|
547 trmResponse[ti++] = 0x90; /* item identifier tag + CR */
|
|
|
548 trmResponse[ti++] = 1; /* length */
|
|
|
549 trmResponse[ti++] = itemId; /* selected item id */
|
|
|
550 TRACE_EVENT("SATR:satItem");
|
|
|
551 sAT_PercentSATR(CMD_SRC_LCL,ti,trmResponse);
|
|
|
552
|
|
|
553 /* Deallocate memory used for Terminal Response buffer */
|
|
|
554 if (trmResponse != NULL)
|
|
|
555 {
|
|
|
556 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
557 trmResponse = NULL;
|
|
|
558 }
|
|
|
559
|
|
|
560 return MfwResOk;
|
|
|
561 }
|
|
|
562
|
|
|
563
|
|
|
564 /*
|
|
|
565 +--------------------------------------------------------------------+
|
|
|
566 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
567 | STATE : code ROUTINE : satMenuItem |
|
|
|
568 +--------------------------------------------------------------------+
|
|
|
569
|
|
|
570 PURPOSE : user selected menu item to SIM
|
|
|
571
|
|
|
572 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
573
|
|
|
574 */
|
|
|
575
|
|
|
576 MfwRes satMenuItem (U8 itemId, U8 help)
|
|
|
577 {
|
|
|
578 S16 ti = 0;
|
|
|
579 U8* trmResponse = NULL;
|
|
|
580
|
|
|
581 TRACE_FUNCTION("satMenuItem()");
|
|
|
582
|
|
|
583 /* Allocate memory for Terminal Response buffer */
|
|
|
584 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
585
|
|
|
586 if (trmResponse == NULL)
|
|
|
587 {
|
|
|
588 /* Memory allocation failed */
|
|
|
589 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
590 return MfwResNoMem;
|
|
|
591 }
|
|
|
592
|
|
|
593 trmResponse[ti++] = 0xD3; /* menu selection tag */
|
|
|
594 trmResponse[ti++] = 0; /* length (filled later) */
|
|
|
595 trmResponse[ti++] = 0x82; /* --device identities-- */
|
|
|
596 trmResponse[ti++] = 0x02; /* length */
|
|
|
597 trmResponse[ti++] = 0x01; /* source: Keypad */
|
|
|
598 trmResponse[ti++] = 0x81; /* destination: SIM */
|
|
|
599 trmResponse[ti++] = 0x90; /* --item identifier-- */
|
|
|
600 trmResponse[ti++] = 0x01; /* length */
|
|
|
601 trmResponse[ti++] = itemId; /* item id */
|
|
|
602 if (help)
|
|
|
603 {
|
|
|
604 trmResponse[ti++] = 0x95; /* --help request-- */
|
|
|
605 trmResponse[ti++] = 0x00; /* length */
|
|
|
606 }
|
|
|
607 trmResponse[1] = ti - 2; /* length of menu selection */
|
|
|
608
|
|
|
609 sAT_PercentSATE(CMD_SRC_LCL,ti,trmResponse);
|
|
|
610
|
|
|
611 /* Deallocate memory used for Terminal Response buffer */
|
|
|
612 if (trmResponse != NULL)
|
|
|
613 {
|
|
|
614 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
615 trmResponse = NULL;
|
|
|
616 }
|
|
|
617
|
|
|
618 return MfwResOk;
|
|
|
619 }
|
|
|
620
|
|
|
621
|
|
|
622 /*
|
|
|
623 +--------------------------------------------------------------------+
|
|
|
624 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
625 | STATE : code ROUTINE : satEvtDownload |
|
|
|
626 +--------------------------------------------------------------------+
|
|
|
627
|
|
|
628 PURPOSE : download actual event to SAT (User activity and Idle Screen available)
|
|
|
629
|
|
|
630 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
631
|
|
|
632 */
|
|
|
633
|
|
|
634 MfwRes satEvtDownload (U8 evt)
|
|
|
635 {
|
|
|
636 S16 ti = 0;
|
|
|
637 U8 src;
|
|
|
638 U8 evtFlags=0;
|
|
|
639 U8* trmResponse = NULL;
|
|
|
640
|
|
|
641 TRACE_FUNCTION("satEvtDownload()");
|
|
|
642
|
|
|
643 /* Allocate memory for Terminal Response buffer */
|
|
|
644 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
645
|
|
|
646 if (trmResponse == NULL)
|
|
|
647 {
|
|
|
648 /* Memory allocation failed */
|
|
|
649 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
650 return MfwResNoMem;
|
|
|
651 }
|
|
|
652
|
|
|
653 switch (evt)
|
|
|
654 {
|
|
|
655 case SatEvtUserAction: /* user activity */
|
|
|
656 evtFlags = SatEvtUserActionActivated; /* source of event */
|
|
|
657 break;
|
|
|
658 case SatEvtIdleScreen: /* idle screen available */
|
|
|
659 evtFlags = SatEvtIdleScreenActivated; /* source of event */
|
|
|
660 break;
|
|
|
661 default:
|
|
|
662 TRACE_ERROR("ERROR: Unrecognised evt");
|
|
|
663 /* Deallocate memory used for Terminal Response buffer */
|
|
|
664 if (trmResponse != NULL)
|
|
|
665 {
|
|
|
666 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
667 trmResponse = NULL;
|
|
|
668 }
|
|
|
669 return MfwResErr; /* illegal event */
|
|
|
670 }
|
|
|
671
|
|
|
672 if (!(eventList&evtFlags)) /*Only send registered events */
|
|
|
673 {
|
|
|
674 TRACE_ERROR("ERROR: evtFlags not registered in eventList");
|
|
|
675
|
|
|
676 /* Deallocate memory used for Terminal Response buffer */
|
|
|
677 if (trmResponse != NULL)
|
|
|
678 {
|
|
|
679 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
680 trmResponse = NULL;
|
|
|
681 }
|
|
|
682 return MfwResErr;
|
|
|
683 }
|
|
|
684
|
|
|
685 switch (evt)
|
|
|
686 {
|
|
|
687 case SatEvtUserAction: /* user activity */
|
|
|
688 src = SatDevME; /* source of event */
|
|
|
689 break;
|
|
|
690 case SatEvtIdleScreen: /* idle screen available */
|
|
|
691 src = SatDevDisplay; /* source of event */
|
|
|
692 break;
|
|
|
693 default:
|
|
|
694 TRACE_ERROR("ERROR: Unrecognised evt");
|
|
|
695 /* Deallocate memory used for Terminal Response buffer */
|
|
|
696 if (trmResponse != NULL)
|
|
|
697 {
|
|
|
698 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
699 trmResponse = NULL;
|
|
|
700 }
|
|
|
701 return MfwResErr; /* illegal event */
|
|
|
702 }
|
|
|
703
|
|
|
704 eventList&=(~evtFlags); /* Deregister event */
|
|
|
705
|
|
|
706
|
|
|
707
|
|
|
708 trmResponse[ti++] = 0xD6; /* event download tag */
|
|
|
709 trmResponse[ti++] = 0; /* length (filled later) */
|
|
|
710 trmResponse[ti++] = 0x99; /* --event list-- */
|
|
|
711 trmResponse[ti++] = 0x01; /* length */
|
|
|
712 trmResponse[ti++] = evt; /* actual event */
|
|
|
713 trmResponse[ti++] = 0x82; /* --device identities-- */
|
|
|
714 trmResponse[ti++] = 0x02; /* length */
|
|
|
715 trmResponse[ti++] = src; /* source */
|
|
|
716 trmResponse[ti++] = 0x81; /* destination: SIM */
|
|
|
717 trmResponse[1] = ti - 2; /* length of event download */
|
|
|
718
|
|
|
719 sAT_PercentSATE(CMD_SRC_LCL,ti,trmResponse);
|
|
|
720
|
|
|
721 /* Deallocate memory used for Terminal Response buffer */
|
|
|
722 if (trmResponse != NULL)
|
|
|
723 {
|
|
|
724 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
725 trmResponse = NULL;
|
|
|
726 }
|
|
|
727
|
|
|
728 return MfwResOk;
|
|
|
729 }
|
|
|
730
|
|
|
731
|
|
|
732 /*
|
|
|
733 +--------------------------------------------------------------------+
|
|
|
734 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
735 | STATE : code ROUTINE : satEvtRegistered |
|
|
|
736 +--------------------------------------------------------------------+
|
|
|
737
|
|
|
738 PURPOSE : Check if evt (User activity and Idle Screen available) has been
|
|
|
739 registered by previous SAT Setup Event List command.
|
|
|
740
|
|
|
741 SPR#2121 - DS - Created function.
|
|
|
742
|
|
|
743 */
|
|
|
744
|
|
|
745 int satEvtRegistered (int evt)
|
|
|
746 {
|
|
|
747 TRACE_FUNCTION("satEvtRegistered()");
|
|
|
748
|
|
|
749 if (eventList & evt)
|
|
|
750 {
|
|
|
751 return TRUE;
|
|
|
752 }
|
|
|
753 else
|
|
|
754 {
|
|
|
755 return FALSE;
|
|
|
756 }
|
|
|
757 }
|
|
|
758
|
|
|
759
|
|
|
760 /*
|
|
|
761 +--------------------------------------------------------------------+
|
|
|
762 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
763 | STATE : code ROUTINE : satDone |
|
|
|
764 +--------------------------------------------------------------------+
|
|
|
765
|
|
|
766 PURPOSE : SIM toolkit command confirmation
|
|
|
767
|
|
|
768 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
769
|
|
|
770 */
|
|
|
771
|
|
|
772 MfwRes satDone (SatCmd *cmd, U8 *res, int rlen)
|
|
|
773 {
|
|
|
774 S16 ti;
|
|
|
775 U8 response = *res;
|
|
|
776 U8* trmResponse = NULL;
|
|
|
777
|
|
|
778 if (satNoResponse) /* no response, if ... */
|
|
|
779 {
|
|
|
780 TRACE_EVENT("satDone: no response. Handled by ACI");
|
|
|
781 return MfwResOk; /* ... notified by ACI */
|
|
|
782 }
|
|
|
783
|
|
|
784 /* Allocate memory for Terminal Response buffer */
|
|
|
785 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
786
|
|
|
787 if (trmResponse == NULL)
|
|
|
788 {
|
|
|
789 /* Memory allocation failed */
|
|
|
790 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
791 return MfwResNoMem;
|
|
|
792 }
|
|
|
793
|
|
|
794 /*SPR#2121 - DS - Set up terminal response with default values */
|
|
|
795 lenResponse = sizeof(defResponse); /* prep. terminal response */
|
|
|
796 memcpy(trmResponse,defResponse,lenResponse);
|
|
|
797
|
|
|
798 trmResponse[2] = cmd->number; /* command number */
|
|
|
799 trmResponse[3] = cmd->type; /* command type */
|
|
|
800 trmResponse[4] = cmd->qual; /* command qualifier */
|
|
|
801
|
|
|
802 ti = sizeof(defResponse) - 2; /* result length */
|
|
|
803 if(res[1] != SatResAiNoCause) /* only attach additional information if existent*/
|
|
|
804 {
|
|
|
805 trmResponse[ti++] = rlen; /* dito */
|
|
|
806 while (rlen--)
|
|
|
807 trmResponse[ti++] = *res++; /* result data */
|
|
|
808 }
|
|
|
809 else /* result ok no additional resultcode attached*/
|
|
|
810 {
|
|
|
811 trmResponse[ti++] = 0x01;
|
|
|
812 trmResponse[ti++] = *res;
|
|
|
813 }
|
|
|
814
|
|
|
815 switch (response)
|
|
|
816 {
|
|
|
817 case SatResSuccess: /* performed successsfully */
|
|
|
818 case SatResPartial: /* ok,partial comprehension */
|
|
|
819 case SatResMissing: /* ok,missing information */
|
|
|
820 case SatResAdditional: /* ok,additional EFs read */
|
|
|
821 case SatResNoIcon: /* ok,no icon displayed */
|
|
|
822 case SatResModified: /* ok,modified by SIM */
|
|
|
823 case SatResUserAbort: /* terminated by user */
|
|
|
824 case SatResUserBack: /* backward move by user */
|
|
|
825 case SatResUserNoResp: /* no response from user */
|
|
|
826 case SatResUserHelp: /* help request from user */
|
|
|
827 case SatResUserAbortUSSD: /* USSD terminated by user */
|
|
|
828 case SatResBusyME: /* ME temporary failure */
|
|
|
829 case SatResBusyNet: /* Net temporary failure */
|
|
|
830 case SatResReject: /* user reject call setup */
|
|
|
831 case SatResCleared: /* call cleared (user/net) */
|
|
|
832 case SatResTimerConflict: /* conflict on timer state */
|
|
|
833 case SatResCCTemp: /* CC by SIM: temp failure */
|
|
|
834 case SatResImpossible: /* ME cannot do it */
|
|
|
835 case SatResUnknownType: /* type not understood */
|
|
|
836 case SatResUnknownData: /* data not understood */
|
|
|
837 case SatResUnknownNumber: /* number not understood */
|
|
|
838 case SatResSSerror: /* SS return error */
|
|
|
839 case SatResSMSerror: /* SMS-RP error */
|
|
|
840 case SatResNoValues: /* missing required values */
|
|
|
841 case SatResUSSDerror: /* USSD return error */
|
|
|
842 case SatResMultiCard: /* Multiple card error */
|
|
|
843 case SatResCCPermanent: /* CC by SIM: perm. failure */
|
|
|
844 break;
|
|
|
845 default:
|
|
|
846 TRACE_ERROR("ill response code");
|
|
|
847 break;
|
|
|
848 }
|
|
|
849
|
|
|
850 TRACE_EVENT_P1("SATR:satdone. Response: %x", response);
|
|
|
851
|
|
|
852 sAT_PercentSATR(CMD_SRC_LCL,ti,trmResponse);
|
|
|
853
|
|
|
854 /* Deallocate memory used for Terminal Response buffer */
|
|
|
855 if (trmResponse != NULL)
|
|
|
856 {
|
|
|
857 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
858 trmResponse = NULL;
|
|
|
859 }
|
|
|
860
|
|
|
861 return MfwResOk;
|
|
|
862 }
|
|
|
863
|
|
|
864
|
|
|
865 /*
|
|
|
866 +--------------------------------------------------------------------+
|
|
|
867 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
868 | STATE : code ROUTINE : sigExec |
|
|
|
869 +--------------------------------------------------------------------+
|
|
|
870
|
|
|
871 PURPOSE : execute SAT signal
|
|
|
872
|
|
|
873 */
|
|
|
874
|
|
|
875 static int sigExec (MfwHdr *curElem, U32 evt, void *data)
|
|
|
876 {
|
|
|
877 MfwSat *sc;
|
|
|
878
|
|
|
879 while (curElem)
|
|
|
880 {
|
|
|
881 if (curElem->type == MfwTypSat)
|
|
|
882 {
|
|
|
883 sc = curElem->data;
|
|
|
884 if (sc->map & evt)
|
|
|
885 { /* events match */
|
|
|
886 if (sc->handler) /* handler valid */
|
|
|
887 {
|
|
|
888 current_mfw_elem = curElem; /* LE 06.06.00 */
|
|
|
889 sc->evt = evt;
|
|
|
890 if (sc->cmd)
|
|
|
891 memcpy(sc->cmd,(U8 *)data,sizeof(SatCmd));
|
|
|
892 if ((*(sc->handler))(evt,sc))
|
|
|
893 return 1; /* event consumed */
|
|
|
894 }
|
|
|
895 }
|
|
|
896 }
|
|
|
897 curElem = curElem->next;
|
|
|
898 }
|
|
|
899
|
|
|
900 return 0;
|
|
|
901 }
|
|
|
902
|
|
|
903
|
|
|
904 /*
|
|
|
905 +--------------------------------------------------------------------+
|
|
|
906 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
907 | STATE : code ROUTINE : satSignal |
|
|
|
908 +--------------------------------------------------------------------+
|
|
|
909
|
|
|
910 PURPOSE : SAT event
|
|
|
911
|
|
|
912 */
|
|
|
913
|
|
|
914 void satSignal (U32 evt, void *data)
|
|
|
915 {
|
|
|
916 UBYTE temp = dspl_Enable(0);
|
|
|
917
|
|
|
918 TRACE_FUNCTION("satSignal event");
|
|
|
919 TRACE_EVENT_P1("satSignal event %d",evt);
|
|
|
920
|
|
|
921 if (mfwSignallingMethod EQ 0)
|
|
|
922 {
|
|
|
923 if (mfwFocus)
|
|
|
924 if (sigExec(mfwFocus,evt,data))
|
|
|
925 {
|
|
|
926 dspl_Enable(temp);
|
|
|
927 return;
|
|
|
928 }
|
|
|
929 if (mfwRoot)
|
|
|
930 sigExec(mfwRoot,evt,data);
|
|
|
931 }
|
|
|
932 else
|
|
|
933 {
|
|
|
934 MfwHdr* h = 0;
|
|
|
935
|
|
|
936 if (mfwFocus)
|
|
|
937 h = mfwFocus;
|
|
|
938 if (!h)
|
|
|
939 h = mfwRoot;
|
|
|
940 while (h)
|
|
|
941 {
|
|
|
942 if (sigExec(h,evt,data))
|
|
|
943 {
|
|
|
944 dspl_Enable(temp);
|
|
|
945 return;
|
|
|
946 }
|
|
|
947 if (h == mfwRoot)
|
|
|
948 {
|
|
|
949 dspl_Enable(temp);
|
|
|
950 return;
|
|
|
951 }
|
|
|
952 h = mfwParent(mfwParent(h));
|
|
|
953 if (h)
|
|
|
954 h = ((MfwWin *)(h->data))->elems;
|
|
|
955 }
|
|
|
956 sigExec (mfwRoot,evt,data);
|
|
|
957 }
|
|
|
958
|
|
|
959 dspl_Enable(temp);
|
|
|
960 return;
|
|
|
961 }
|
|
|
962
|
|
|
963
|
|
|
964 /*
|
|
|
965 +--------------------------------------------------------------------+
|
|
|
966 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
967 | STATE : code ROUTINE : satCommand |
|
|
|
968 +--------------------------------------------------------------------+
|
|
|
969
|
|
|
970 PURPOSE : handle mfw windows command
|
|
|
971
|
|
|
972 */
|
|
|
973
|
|
|
974 static int satCommand (U32 cmd, void *h)
|
|
|
975 {
|
|
|
976 switch (cmd)
|
|
|
977 {
|
|
|
978 case MfwCmdDelete: /* delete me */
|
|
|
979 if (!h)
|
|
|
980 return 0;
|
|
|
981 satDelete(h);
|
|
|
982 return 1;
|
|
|
983 default:
|
|
|
984 break;
|
|
|
985 }
|
|
|
986
|
|
|
987 return 0;
|
|
|
988 }
|
|
|
989
|
|
|
990
|
|
|
991 /*
|
|
|
992 +--------------------------------------------------------------------+
|
|
|
993 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
994 | STATE : code ROUTINE : satResponse |
|
|
|
995 +--------------------------------------------------------------------+
|
|
|
996
|
|
|
997 PURPOSE : setup Terminal Response for SIM
|
|
|
998
|
|
|
999 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
1000
|
|
|
1001 */
|
|
|
1002
|
|
|
1003 static void satResponse (U8 res)
|
|
|
1004 {
|
|
|
1005 U8* trmResponse = NULL;
|
|
|
1006
|
|
|
1007 TRACE_FUNCTION("satResponse()");
|
|
|
1008
|
|
|
1009 if (satNoResponse) /* no response, if ... */
|
|
|
1010 return; /* ... notified by ACI */
|
|
|
1011
|
|
|
1012 /* Allocate memory for Terminal Response buffer */
|
|
|
1013 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
1014
|
|
|
1015 if (trmResponse == NULL)
|
|
|
1016 {
|
|
|
1017 /* Memory allocation failed */
|
|
|
1018 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
1019 return;
|
|
|
1020 }
|
|
|
1021
|
|
|
1022 /*SPR#2121 - DS - Set up terminal response with default values */
|
|
|
1023 lenResponse = sizeof(defResponse); /* prep. terminal response */
|
|
|
1024 memcpy(trmResponse,defResponse,lenResponse);
|
|
|
1025
|
|
|
1026 /*SPR#2121 - DS - Set up command specific details. defCmdDetails set up in rAT_PercentSATI */
|
|
|
1027 memcpy(trmResponse, defCmdDetails, CMD_DETAILS_LEN);
|
|
|
1028
|
|
|
1029 trmResponse[10] = 1;
|
|
|
1030 trmResponse[11] = res;
|
|
|
1031 sAT_PercentSATR(CMD_SRC_LCL,sizeof(defResponse),trmResponse);
|
|
|
1032
|
|
|
1033 /* Deallocate memory used for Terminal Response buffer */
|
|
|
1034 if (trmResponse != NULL)
|
|
|
1035 {
|
|
|
1036 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
1037 trmResponse = NULL;
|
|
|
1038 }
|
|
|
1039
|
|
|
1040 return;
|
|
|
1041 }
|
|
|
1042
|
|
|
1043
|
|
|
1044 /*
|
|
|
1045 +--------------------------------------------------------------------+
|
|
|
1046 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1047 | STATE : code ROUTINE : getTLValue |
|
|
|
1048 +--------------------------------------------------------------------+
|
|
|
1049
|
|
|
1050 PURPOSE : check TLV:
|
|
|
1051 setup curCR, curTag, curLen
|
|
|
1052 return size of TL part
|
|
|
1053
|
|
|
1054 */
|
|
|
1055
|
|
|
1056 static U8 getTLValue (U8 *sc)
|
|
|
1057 {
|
|
|
1058 TRACE_FUNCTION("getTLValue()");
|
|
|
1059
|
|
|
1060 curCR = *(sc+0) & 0x80; /* comprehension required ? */
|
|
|
1061 curTag = *(sc+0) & 0x7f; /* TLV id */
|
|
|
1062 curLen = *(sc+1); /* length of TLV value part */
|
|
|
1063
|
|
|
1064 if (curLen < 0x80)
|
|
|
1065 return 2;
|
|
|
1066 if (curLen == 0x81)
|
|
|
1067 {
|
|
|
1068 curLen = *(sc+2); /* long length */
|
|
|
1069 return 3;
|
|
|
1070 }
|
|
|
1071 TRACE_ERROR("invalid length coding");
|
|
|
1072 satResponse(SatResUnknownData);
|
|
|
1073
|
|
|
1074 return 0; /* invalid TLV object */
|
|
|
1075 }
|
|
|
1076
|
|
|
1077
|
|
|
1078 /*
|
|
|
1079 +--------------------------------------------------------------------+
|
|
|
1080 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1081 | STATE : code ROUTINE : decTLV |
|
|
|
1082 +--------------------------------------------------------------------+
|
|
|
1083
|
|
|
1084 PURPOSE : decode TLV
|
|
|
1085
|
|
|
1086 */
|
|
|
1087
|
|
|
1088 static U8 decTLV (U8 tagWanted, U8 mandatory, char *id)
|
|
|
1089 {
|
|
|
1090 U8 *sc = curCmd;
|
|
|
1091 S16 len = curCmdLen;
|
|
|
1092 U8 tl, partial = 0;
|
|
|
1093
|
|
|
1094 TRACE_EVENT_P3("decTLV(%02x,%d,%s)",tagWanted,mandatory,id);
|
|
|
1095
|
|
|
1096 while (len > 0)
|
|
|
1097 {
|
|
|
1098 tl = getTLValue(sc);
|
|
|
1099 if (!tl)
|
|
|
1100 return 0;
|
|
|
1101 if (curTag == tagWanted)
|
|
|
1102 {
|
|
|
1103 sc += tl;
|
|
|
1104 curVal = sc;
|
|
|
1105 curCmd = sc + curLen;
|
|
|
1106 curCmdLen = len - (tl + curLen);
|
|
|
1107 partialCompr += partial;
|
|
|
1108 return 2;
|
|
|
1109 }
|
|
|
1110 TRACE_EVENT_P1("no %s TLV",id);
|
|
|
1111
|
|
|
1112 if (curCR)
|
|
|
1113 {
|
|
|
1114 if (mandatory)
|
|
|
1115 satResponse(SatResUnknownData);
|
|
|
1116 return !mandatory;
|
|
|
1117 }
|
|
|
1118 sc += tl + curLen;
|
|
|
1119 len -= tl + curLen;
|
|
|
1120 partial = 1;
|
|
|
1121 }
|
|
|
1122 if(!strcmp(id,"Tone"))
|
|
|
1123 {
|
|
|
1124 /*
|
|
|
1125 * according to GSM 11.14 if no tone is included play general beep
|
|
|
1126 */
|
|
|
1127 //July 26, 2005 REF: SPR 29520 x0018858
|
|
|
1128 //Value modified from integer to hex.
|
|
|
1129 *curVal = 0x10;
|
|
|
1130
|
|
|
1131 return 2;
|
|
|
1132 }
|
|
|
1133 if(!strcmp(id,"Duration"))
|
|
|
1134 {
|
|
|
1135 /*
|
|
|
1136 * according to GSM 11.14 if no duration is included set to a default value
|
|
|
1137 */
|
|
|
1138 *(curVal) = 1; /* Units = sec */
|
|
|
1139 *(curVal+1) = 5; /* play 5 seconds ??*/
|
|
|
1140 return 2;
|
|
|
1141 }
|
|
|
1142
|
|
|
1143 TRACE_EVENT_P1("not found: %s TLV",id);
|
|
|
1144
|
|
|
1145 if (mandatory)
|
|
|
1146 satResponse(SatResNoValues);
|
|
|
1147
|
|
|
1148 return !mandatory;
|
|
|
1149 }
|
|
|
1150
|
|
|
1151
|
|
|
1152 /*
|
|
|
1153 +--------------------------------------------------------------------+
|
|
|
1154 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1155 | STATE : code ROUTINE : decByte |
|
|
|
1156 +--------------------------------------------------------------------+
|
|
|
1157
|
|
|
1158 PURPOSE : decode TLV: miscelleaneous TLVs (single byte value)
|
|
|
1159
|
|
|
1160 */
|
|
|
1161
|
|
|
1162 static U8 decByte (U8 *t, U8 tagWanted, U8 mandatory)
|
|
|
1163 {
|
|
|
1164 U8 res;
|
|
|
1165
|
|
|
1166 TRACE_FUNCTION("decByte()");
|
|
|
1167
|
|
|
1168 res = decTLV(tagWanted,mandatory,"byte");
|
|
|
1169
|
|
|
1170 if (res > 1)
|
|
|
1171 {
|
|
|
1172 *t = *curVal;
|
|
|
1173 return 1;
|
|
|
1174 }
|
|
|
1175
|
|
|
1176 return res;
|
|
|
1177 }
|
|
|
1178
|
|
|
1179
|
|
|
1180 /*
|
|
|
1181 +--------------------------------------------------------------------+
|
|
|
1182 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1183 | STATE : code ROUTINE : decData |
|
|
|
1184 +--------------------------------------------------------------------+
|
|
|
1185
|
|
|
1186 PURPOSE : decode TLV: miscelleaneous TLVs (length, data)
|
|
|
1187
|
|
|
1188 */
|
|
|
1189
|
|
|
1190 static U8 decData (SatData *t, U8 tagWanted, U8 mandatory)
|
|
|
1191 {
|
|
|
1192 U8 res;
|
|
|
1193
|
|
|
1194 TRACE_FUNCTION("decData()");
|
|
|
1195
|
|
|
1196 res = decTLV(tagWanted,mandatory,"data");
|
|
|
1197
|
|
|
1198 if (res > 1)
|
|
|
1199 {
|
|
|
1200 t->len = curLen; /* data len */
|
|
|
1201 curData -= curLen;
|
|
|
1202 memcpy(curData,curVal,curLen); /* data itself */
|
|
|
1203 t->data = (U16) (curData - (U8*) t); /* save the offset */
|
|
|
1204 return 1;
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 return res;
|
|
|
1208 }
|
|
|
1209
|
|
|
1210
|
|
|
1211 /*
|
|
|
1212 +--------------------------------------------------------------------+
|
|
|
1213 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1214 | STATE : code ROUTINE : decText |
|
|
|
1215 +--------------------------------------------------------------------+
|
|
|
1216
|
|
|
1217 PURPOSE : decode TLV: text string
|
|
|
1218
|
|
|
1219 */
|
|
|
1220
|
|
|
1221 static U8 decText (SatTxt *t, U8 tagWanted, U8 mandatory)
|
|
|
1222 {
|
|
|
1223 U8 res;
|
|
|
1224
|
|
|
1225 TRACE_FUNCTION("decText()");
|
|
|
1226
|
|
|
1227 res = decTLV(tagWanted,mandatory,"text");
|
|
|
1228
|
|
|
1229 TRACE_EVENT_P1("res %d", res);
|
|
|
1230
|
|
|
1231 if (res > 1)
|
|
|
1232 {
|
|
|
1233 if (curLen == 0x00) /* SPR#2340 - DS - Text len zero */
|
|
|
1234 t->len = 0;
|
|
|
1235 else
|
|
|
1236 t->len = curLen - 1; /* text len (not dcs) */
|
|
|
1237
|
|
|
1238 if (t->len)
|
|
|
1239 t->code = *curVal; /* data coding scheme */
|
|
|
1240 else
|
|
|
1241 t->code = 0;
|
|
|
1242 curData -= t->len;
|
|
|
1243 memcpy(curData,curVal+1,t->len); /* text itself */
|
|
|
1244 t->text = (U16) (curData - (U8*) t); /* save the offset */
|
|
|
1245
|
|
|
1246 TRACE_EVENT_P2("len %d, code(dcs) %d", t->len, t->code);
|
|
|
1247
|
|
|
1248 return 1;
|
|
|
1249 }
|
|
|
1250
|
|
|
1251 return res;
|
|
|
1252 }
|
|
|
1253
|
|
|
1254
|
|
|
1255 /*
|
|
|
1256 +--------------------------------------------------------------------+
|
|
|
1257 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1258 | STATE : code ROUTINE : decAddrSS |
|
|
|
1259 +--------------------------------------------------------------------+
|
|
|
1260
|
|
|
1261 PURPOSE : decode TLV: address or SS string
|
|
|
1262
|
|
|
1263 */
|
|
|
1264
|
|
|
1265 static U8 decAddrSS (SatAddress *t, U8 tagWanted, U8 mandatory)
|
|
|
1266 {
|
|
|
1267 U8 res;
|
|
|
1268
|
|
|
1269 TRACE_FUNCTION("decAddr-SS()");
|
|
|
1270
|
|
|
1271 res = decTLV(tagWanted,mandatory,"Addr-SS");
|
|
|
1272
|
|
|
1273 if (res > 1) /* address or ss string */
|
|
|
1274 {
|
|
|
1275 t->len = curLen - 1; /* number len wo ton/npi */
|
|
|
1276 curData -= t->len;
|
|
|
1277 t->ton = *curVal; /* type of number, npi */
|
|
|
1278 memcpy(curData,curVal+1,t->len); /* number itself */
|
|
|
1279 t->number = (U16) (curData - (U8*) t); /* offset */
|
|
|
1280 return 1;
|
|
|
1281 }
|
|
|
1282
|
|
|
1283 return res;
|
|
|
1284 }
|
|
|
1285
|
|
|
1286
|
|
|
1287 /*
|
|
|
1288 +--------------------------------------------------------------------+
|
|
|
1289 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1290 | STATE : code ROUTINE : decAlpha |
|
|
|
1291 +--------------------------------------------------------------------+
|
|
|
1292
|
|
|
1293 PURPOSE : decode TLV: alpha identifier
|
|
|
1294
|
|
|
1295 */
|
|
|
1296
|
|
|
1297 static U8 decAlpha (SatTxt *t, U8 mandatory)
|
|
|
1298 {
|
|
|
1299 U8 res;
|
|
|
1300
|
|
|
1301 TRACE_FUNCTION("decAlpha()");
|
|
|
1302
|
|
|
1303 res = decTLV(0x05,mandatory,"Alpha");
|
|
|
1304
|
|
|
1305 /* SPR#2340 - DS - Added check of val returned from decTLV */
|
|
|
1306 if (res > 1)
|
|
|
1307 {
|
|
|
1308 t->len = curLen; /* text len */
|
|
|
1309 if (t->len)
|
|
|
1310 t->code = 0x04; /* data coding scheme */
|
|
|
1311 else
|
|
|
1312 t->code = 0;
|
|
|
1313 curData -= t->len;
|
|
|
1314 memcpy(curData,curVal,t->len); /* text itself */
|
|
|
1315 t->text = (U16) (curData - (U8*) t); /* save the offset */
|
|
|
1316 return 1;
|
|
|
1317 }
|
|
|
1318 else
|
|
|
1319 {
|
|
|
1320 /* Alpha tag not present */
|
|
|
1321 t->len = 0x00;
|
|
|
1322 t->code = 0x00;
|
|
|
1323 t->text = 0x00;
|
|
|
1324 }
|
|
|
1325
|
|
|
1326 return res;
|
|
|
1327 }
|
|
|
1328
|
|
|
1329
|
|
|
1330
|
|
|
1331 /*
|
|
|
1332 +--------------------------------------------------------------------+
|
|
|
1333 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1334 | STATE : code ROUTINE : decSMS |
|
|
|
1335 +--------------------------------------------------------------------+
|
|
|
1336
|
|
|
1337 PURPOSE : decode TLV: SMS TPDU
|
|
|
1338
|
|
|
1339 */
|
|
|
1340
|
|
|
1341 static U8 decSMS (SatSmsPdu *t, U8 mandatory)
|
|
|
1342 {
|
|
|
1343 U8 res;
|
|
|
1344
|
|
|
1345 TRACE_FUNCTION("decSMS()");
|
|
|
1346
|
|
|
1347 res = decTLV(0x0B,mandatory,"SMS TPDU");
|
|
|
1348
|
|
|
1349 if (res > 1)
|
|
|
1350 {
|
|
|
1351 t->len = curLen; /* SMS len */
|
|
|
1352 curData -= t->len;
|
|
|
1353 memcpy(curData,curVal,t->len); /* SMS itself */
|
|
|
1354 t->data = (U16) (curData - (U8*) t); /* save the offset */
|
|
|
1355 return 1;
|
|
|
1356 }
|
|
|
1357
|
|
|
1358 return res;
|
|
|
1359 }
|
|
|
1360
|
|
|
1361
|
|
|
1362 /*
|
|
|
1363 +--------------------------------------------------------------------+
|
|
|
1364 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1365 | STATE : code ROUTINE : decItem |
|
|
|
1366 +--------------------------------------------------------------------+
|
|
|
1367
|
|
|
1368 PURPOSE : decode TLV: item
|
|
|
1369
|
|
|
1370 */
|
|
|
1371
|
|
|
1372 static U8 decItem (SatItem *t, U8 mandatory)
|
|
|
1373 {
|
|
|
1374 U8 res;
|
|
|
1375
|
|
|
1376 TRACE_FUNCTION("decItem()");
|
|
|
1377
|
|
|
1378 res = decTLV(0x0F,mandatory,"Item");
|
|
|
1379
|
|
|
1380 if (res > 1)
|
|
|
1381 {
|
|
|
1382 if (!curLen) /* no item: remove menu */
|
|
|
1383 {
|
|
|
1384 t->id = 0; /* no id */
|
|
|
1385 t->len = 0; /* no length */
|
|
|
1386 }
|
|
|
1387 else
|
|
|
1388 {
|
|
|
1389 t->id = *curVal;
|
|
|
1390 t->len = curLen - 1; /* without item id */
|
|
|
1391 }
|
|
|
1392 t->action = 0; /* filled in later */
|
|
|
1393 t->icon = 0; /* filled in later */
|
|
|
1394 curData -= t->len;
|
|
|
1395 memcpy(curData,curVal+1,t->len); /* item data */
|
|
|
1396 t->text = (U16) (curData - (U8*) t); /* save the offset */
|
|
|
1397 return 1;
|
|
|
1398 }
|
|
|
1399
|
|
|
1400 return res;
|
|
|
1401 }
|
|
|
1402
|
|
|
1403
|
|
|
1404 /*
|
|
|
1405 +--------------------------------------------------------------------+
|
|
|
1406 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1407 | STATE : code ROUTINE : decNextAction |
|
|
|
1408 +--------------------------------------------------------------------+
|
|
|
1409
|
|
|
1410 PURPOSE : decode TLV: next action
|
|
|
1411
|
|
|
1412 */
|
|
|
1413
|
|
|
1414 static U8 decNextAction (SatItem *t, U8 nItems, U8 mandatory)
|
|
|
1415 {
|
|
|
1416 U8 res;
|
|
|
1417
|
|
|
1418 TRACE_FUNCTION("decNextAction()");
|
|
|
1419
|
|
|
1420 res = decTLV(0x18,mandatory,"Next Action");
|
|
|
1421
|
|
|
1422 if (res > 1)
|
|
|
1423 {
|
|
|
1424 if (nItems > curLen)
|
|
|
1425 nItems = curLen;
|
|
|
1426 while (nItems--)
|
|
|
1427 {
|
|
|
1428 t->action = *curVal++; /* next action identifier */
|
|
|
1429 t++;
|
|
|
1430 }
|
|
|
1431 return 1;
|
|
|
1432 }
|
|
|
1433
|
|
|
1434 return res;
|
|
|
1435 }
|
|
|
1436
|
|
|
1437
|
|
|
1438 /*
|
|
|
1439 +--------------------------------------------------------------------+
|
|
|
1440 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1441 | STATE : code ROUTINE : decItemIcons |
|
|
|
1442 +--------------------------------------------------------------------+
|
|
|
1443
|
|
|
1444 PURPOSE : decode TLV: icon identifier list
|
|
|
1445
|
|
|
1446 */
|
|
|
1447
|
|
|
1448 static U8 decItemIcons (SatMenu *m, SatItem *t, U8 nItems, U8 mandatory)
|
|
|
1449 {
|
|
|
1450 U8 res;
|
|
|
1451
|
|
|
1452 TRACE_FUNCTION("decItemIcons()");
|
|
|
1453
|
|
|
1454 res = decTLV(0x1F,mandatory,"Item Icon List");
|
|
|
1455
|
|
|
1456 m->itemIconQual = 0xFF; /* default: not present */
|
|
|
1457 if (res > 1)
|
|
|
1458 {
|
|
|
1459 m->itemIconQual = *curVal++;
|
|
|
1460 curLen--;
|
|
|
1461 if (nItems > curLen)
|
|
|
1462 nItems = curLen;
|
|
|
1463 while (nItems--)
|
|
|
1464 {
|
|
|
1465 t->icon = *curVal++; /* next action identifier */
|
|
|
1466 t++;
|
|
|
1467 }
|
|
|
1468 return 1;
|
|
|
1469 }
|
|
|
1470
|
|
|
1471 return res;
|
|
|
1472 }
|
|
|
1473
|
|
|
1474
|
|
|
1475 /*
|
|
|
1476 +--------------------------------------------------------------------+
|
|
|
1477 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1478 | STATE : code ROUTINE : decDefItem |
|
|
|
1479 +--------------------------------------------------------------------+
|
|
|
1480
|
|
|
1481 PURPOSE : decode TLV: default item
|
|
|
1482
|
|
|
1483 */
|
|
|
1484
|
|
|
1485 static U8 decDefItem (SatItem *t, U8 nItems, U8 mandatory)
|
|
|
1486 {
|
|
|
1487 U8 res;
|
|
|
1488
|
|
|
1489 TRACE_FUNCTION("decDefItem()");
|
|
|
1490
|
|
|
1491 res = decTLV(0x10,mandatory,"Default Item");
|
|
|
1492
|
|
|
1493 if (res > 1)
|
|
|
1494 {
|
|
|
1495 if (curLen != 1)
|
|
|
1496 return res; /* ES!! error */
|
|
|
1497 while (nItems--)
|
|
|
1498 {
|
|
|
1499 if (t->id == *curVal)
|
|
|
1500 t->action |= 0x40; /* flag as default */
|
|
|
1501 t++;
|
|
|
1502 }
|
|
|
1503 return 1;
|
|
|
1504 }
|
|
|
1505
|
|
|
1506 return res;
|
|
|
1507 }
|
|
|
1508
|
|
|
1509
|
|
|
1510 /*
|
|
|
1511 +--------------------------------------------------------------------+
|
|
|
1512 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1513 | STATE : code ROUTINE : decTone |
|
|
|
1514 +--------------------------------------------------------------------+
|
|
|
1515
|
|
|
1516 PURPOSE : decode TLV: tone
|
|
|
1517
|
|
|
1518 */
|
|
|
1519
|
|
|
1520 static U8 decTone (U8 mandatory)
|
|
|
1521 {
|
|
|
1522 U8 res;
|
|
|
1523
|
|
|
1524 TRACE_FUNCTION("decTone()");
|
|
|
1525
|
|
|
1526 res = decTLV(0x0E,mandatory,"Tone");
|
|
|
1527
|
|
|
1528 if (res > 1)
|
|
|
1529 {
|
|
|
1530 switch (*curVal)
|
|
|
1531 {
|
|
|
1532 case 0x01: /* Dial Tone */
|
|
|
1533 case 0x02: /* Called Subscriber Busy */
|
|
|
1534 case 0x03: /* Congestion */
|
|
|
1535 case 0x04: /* Radio Path Ack */
|
|
|
1536 case 0x05: /* Radio Path Not Avail */
|
|
|
1537 case 0x06: /* Error / Special Info */
|
|
|
1538 case 0x07: /* Call Waiting */
|
|
|
1539 case 0x08: /* Ringing */
|
|
|
1540 case 0x10: /* General Beep */
|
|
|
1541 case 0x11: /* Positive Ack */
|
|
|
1542 case 0x12: /* Negative Ack or Error */
|
|
|
1543 cmd.c.tone.tone = *curVal; /* tone type */
|
|
|
1544 return 1;
|
|
|
1545
|
|
|
1546 default :
|
|
|
1547 satResponse(SatResUnknownData);
|
|
|
1548 return 0;
|
|
|
1549 }
|
|
|
1550 }
|
|
|
1551
|
|
|
1552 return res;
|
|
|
1553 }
|
|
|
1554
|
|
|
1555
|
|
|
1556 /*
|
|
|
1557 +--------------------------------------------------------------------+
|
|
|
1558 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1559 | STATE : code ROUTINE : decDuration |
|
|
|
1560 +--------------------------------------------------------------------+
|
|
|
1561
|
|
|
1562 PURPOSE : decode TLV: duration
|
|
|
1563
|
|
|
1564 */
|
|
|
1565 //Sandip CQ-16299
|
|
|
1566 //Reason : This function does not take care of reserved Time Interval 0x00
|
|
|
1567 #if 0
|
|
|
1568 static U8 decDuration (U8 *dur, U8 mandatory)
|
|
|
1569 {
|
|
|
1570 U8 res;
|
|
|
1571
|
|
|
1572 TRACE_FUNCTION("decDuration()");
|
|
|
1573
|
|
|
1574 res = decTLV(0x04,mandatory,"Duration");
|
|
|
1575
|
|
|
1576 if (res > 1)
|
|
|
1577 {
|
|
|
1578 *dur++ = *curVal++; /* duration unit */
|
|
|
1579 *dur++ = *curVal; /* duration value */
|
|
|
1580 return 1;
|
|
|
1581 }
|
|
|
1582
|
|
|
1583 return res;
|
|
|
1584 }
|
|
|
1585
|
|
|
1586 #endif
|
|
|
1587
|
|
|
1588 static U8 decDuration (U8 *dur, U8 mandatory)
|
|
|
1589 {
|
|
|
1590 U8 res;
|
|
|
1591
|
|
|
1592 TRACE_FUNCTION("decDuration()");
|
|
|
1593
|
|
|
1594 res = decTLV(0x04,mandatory,"Duration");
|
|
|
1595
|
|
|
1596 if (res > 1)
|
|
|
1597 {
|
|
|
1598 *dur++ = *curVal++; /* duration unit */
|
|
|
1599
|
|
|
1600 *dur++ = *curVal; /* duration value */
|
|
|
1601 if(*curVal ==0x00)
|
|
|
1602 {
|
|
|
1603 TRACE_EVENT_P1("Duration value is %d",*curVal);
|
|
|
1604
|
|
|
1605 satResponse(SatResUnknownData);
|
|
|
1606 return 0;
|
|
|
1607 }
|
|
|
1608 return 1;
|
|
|
1609 }
|
|
|
1610 return res;
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 /*
|
|
|
1614 +--------------------------------------------------------------------+
|
|
|
1615 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1616 | STATE : code ROUTINE : decDevId |
|
|
|
1617 +--------------------------------------------------------------------+
|
|
|
1618
|
|
|
1619 PURPOSE : decode TLV: device identities
|
|
|
1620
|
|
|
1621 */
|
|
|
1622
|
|
|
1623 static U8 decDevId (U8 mandatory)
|
|
|
1624 {
|
|
|
1625 U8 res;
|
|
|
1626
|
|
|
1627 TRACE_FUNCTION("decDevId()");
|
|
|
1628
|
|
|
1629 res = decTLV(0x02,mandatory,"Devices");
|
|
|
1630
|
|
|
1631 if (res > 1)
|
|
|
1632 {
|
|
|
1633 cmd.source = *curVal++; /* source identifier */
|
|
|
1634 cmd.dest = *curVal; /* destination identifier */
|
|
|
1635 return 1;
|
|
|
1636 }
|
|
|
1637
|
|
|
1638 return res;
|
|
|
1639 }
|
|
|
1640
|
|
|
1641
|
|
|
1642 /*
|
|
|
1643 +--------------------------------------------------------------------+
|
|
|
1644 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1645 | STATE : code ROUTINE : decRespLen |
|
|
|
1646 +--------------------------------------------------------------------+
|
|
|
1647
|
|
|
1648 PURPOSE : decode TLV: response length
|
|
|
1649
|
|
|
1650 */
|
|
|
1651
|
|
|
1652 static U8 decRespLen (U8 mandatory)
|
|
|
1653 {
|
|
|
1654 U8 res;
|
|
|
1655
|
|
|
1656 TRACE_FUNCTION("decRespLen()");
|
|
|
1657
|
|
|
1658 res = decTLV(0x11,mandatory,"Response Length");
|
|
|
1659
|
|
|
1660 if (res > 1)
|
|
|
1661 {
|
|
|
1662 cmd.c.inp.rspMin = *curVal++; /* minimal length */
|
|
|
1663 cmd.c.inp.rspMax = *curVal; /* maximal length */
|
|
|
1664 /* MMI-SPR-16296: [mdf] verify the parameters as expected by GSM 11.14 */
|
|
|
1665 TRACE_EVENT_P2("decRespLen: Min=%d Max=%d",cmd.c.inp.rspMin,cmd.c.inp.rspMax);
|
|
|
1666 if ( cmd.c.inp.rspMin > cmd.c.inp.rspMax )
|
|
|
1667 {
|
|
|
1668 satResponse(SatResUnknownData); /* send TR(32), prms not understood */
|
|
|
1669 return 0;
|
|
|
1670 }
|
|
|
1671 /* end of MMI-SPR-16296: [mdf] verify the parameters as expected by GSM 11.14 */
|
|
|
1672
|
|
|
1673 return 1;
|
|
|
1674 }
|
|
|
1675
|
|
|
1676 return res;
|
|
|
1677 }
|
|
|
1678
|
|
|
1679
|
|
|
1680 /*
|
|
|
1681 +--------------------------------------------------------------------+
|
|
|
1682 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1683 | STATE : code ROUTINE : decIconId |
|
|
|
1684 +--------------------------------------------------------------------+
|
|
|
1685
|
|
|
1686 PURPOSE : decode TLV: icon identifier
|
|
|
1687
|
|
|
1688 */
|
|
|
1689
|
|
|
1690 static U8 decIconId (SatIconId *id, U8 mandatory)
|
|
|
1691 {
|
|
|
1692 U8 res;
|
|
|
1693
|
|
|
1694 TRACE_FUNCTION("decIconId()");
|
|
|
1695
|
|
|
1696 res = decTLV(0x1E,mandatory,"IconID");
|
|
|
1697
|
|
|
1698 if (res > 1)
|
|
|
1699 {
|
|
|
1700 id->qual = *curVal++; /* icon qualifier */
|
|
|
1701 id->id = *curVal; /* icon identifier */
|
|
|
1702 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
1703 #ifdef FF_MMI_SAT_ICON
|
|
|
1704 isAlphaIdIconPresent = TRUE;
|
|
|
1705 #endif
|
|
|
1706 return 1;
|
|
|
1707 }
|
|
|
1708 else
|
|
|
1709 {
|
|
|
1710 id->qual = 0xFF; /* not present */
|
|
|
1711 id->id = 0xFF;
|
|
|
1712 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
1713 #ifdef FF_MMI_SAT_ICON
|
|
|
1714 isAlphaIdIconPresent = FALSE;
|
|
|
1715 #endif
|
|
|
1716 }
|
|
|
1717
|
|
|
1718 return res;
|
|
|
1719 }
|
|
|
1720
|
|
|
1721 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
1722 #ifdef FF_MMI_SAT_ICON
|
|
|
1723 /*
|
|
|
1724 +--------------------------------------------------------------------+
|
|
|
1725 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1726 | STATE : code ROUTINE : simReadIconData |
|
|
|
1727 +--------------------------------------------------------------------+
|
|
|
1728
|
|
|
1729 PURPOSE : Read SIM EF(IMG).
|
|
|
1730
|
|
|
1731 */
|
|
|
1732 void simReadIconData (U8 record_number)
|
|
|
1733 {
|
|
|
1734 T_SIM_ACCESS_PARAM sim_read_param;
|
|
|
1735
|
|
|
1736 TRACE_FUNCTION("simReadIconData()");
|
|
|
1737
|
|
|
1738 /* Check if the SIM card supports EF(IMG) & read the contents.
|
|
|
1739 Ideally we should be using SRV_RFU3 which corresponds to number 39
|
|
|
1740 but, the calls from MMI are using the number directly */
|
|
|
1741 if (sim_serv_table_check(39)
|
|
|
1742 == ALLOCATED_AND_ACTIVATED)
|
|
|
1743 {
|
|
|
1744 sim_read_param.data_id = SIM_IMG;
|
|
|
1745 sim_read_param.offset = 0;
|
|
|
1746 sim_read_param.record_number = record_number;
|
|
|
1747 sim_read_param.len = MAX_SIM_EF_SIZE;
|
|
|
1748 sim_read_param.max_length = MAX_SIM_EF_SIZE;
|
|
|
1749
|
|
|
1750 sim_read_sim_icon(&sim_read_param);
|
|
|
1751 }
|
|
|
1752 }
|
|
|
1753
|
|
|
1754
|
|
|
1755 /*
|
|
|
1756 +--------------------------------------------------------------------+
|
|
|
1757 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1758 | STATE : code ROUTINE : sim_img_cnf |
|
|
|
1759 +--------------------------------------------------------------------+
|
|
|
1760
|
|
|
1761 PURPOSE : SIM EF(IMG) read confirm.
|
|
|
1762
|
|
|
1763 */
|
|
|
1764
|
|
|
1765 void sim_img_cnf (USHORT error, UBYTE record_number, UBYTE *efimg)
|
|
|
1766 {
|
|
|
1767 USHORT simErr, count;
|
|
|
1768 T_SIM_ACCESS_PARAM sim_read_param;
|
|
|
1769
|
|
|
1770
|
|
|
1771 TRACE_FUNCTION("sim_img_cnf()");
|
|
|
1772
|
|
|
1773 #ifdef FF_2TO1_PS
|
|
|
1774 simErr = CAUSE_SIM_NO_ERROR;
|
|
|
1775 #else
|
|
|
1776 simErr = SIM_NO_ERROR;
|
|
|
1777 #endif
|
|
|
1778
|
|
|
1779 if (error == simErr)
|
|
|
1780 {
|
|
|
1781 if (*efimg >= 1)
|
|
|
1782 {
|
|
|
1783 /* Read the contents of the image file. */
|
|
|
1784 icon_image.number_of_image_instance = *efimg;
|
|
|
1785 efimg++;
|
|
|
1786
|
|
|
1787 icon_image.image_instance.image_width = *efimg;
|
|
|
1788 efimg++;
|
|
|
1789 icon_image.image_instance.image_height = *efimg;
|
|
|
1790 efimg++;
|
|
|
1791 icon_image.image_instance.image_coding = *efimg;
|
|
|
1792 efimg++;
|
|
|
1793
|
|
|
1794 /* Image instance file identifier*/
|
|
|
1795 icon_image.image_instance.image_instance_file_id = *efimg << 8;
|
|
|
1796 efimg++;
|
|
|
1797 icon_image.image_instance.image_instance_file_id |= *efimg;
|
|
|
1798 efimg++;
|
|
|
1799
|
|
|
1800 /* Offset to Image instance file identifier*/
|
|
|
1801 icon_image.image_instance.image_offset = *efimg << 8;
|
|
|
1802 efimg++;
|
|
|
1803 icon_image.image_instance.image_offset |= *efimg;
|
|
|
1804 efimg++;
|
|
|
1805
|
|
|
1806 /* Lenght of the Image instance file identifier.
|
|
|
1807 Do not completely depend on this length as this doesn't include the Palette length,
|
|
|
1808 so Color image decoding goes wrong!!!*/
|
|
|
1809 icon_image.image_instance.image_instance_length = *efimg << 8;
|
|
|
1810 efimg++;
|
|
|
1811 icon_image.image_instance.image_instance_length |= *efimg;
|
|
|
1812 efimg++;
|
|
|
1813
|
|
|
1814 read_image_instance_file = TRUE;
|
|
|
1815
|
|
|
1816 sim_read_sim(icon_image.image_instance.image_instance_file_id, MAX_SIM_EF_SIZE, MAX_SIM_EF_SIZE);
|
|
|
1817
|
|
|
1818 }
|
|
|
1819
|
|
|
1820 }
|
|
|
1821 }
|
|
|
1822
|
|
|
1823 /*
|
|
|
1824 +-----------------------------------------------------------------------------+
|
|
|
1825 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1826 | STATE : code ROUTINE : sim_img_instance_data_cnf |
|
|
|
1827 +-----------------------------------------------------------------------------+
|
|
|
1828
|
|
|
1829 PURPOSE : SIM EF(ImageInst) read confirm & image converter.
|
|
|
1830
|
|
|
1831 */
|
|
|
1832
|
|
|
1833 void sim_img_instance_data_cnf (USHORT error, UBYTE *data_instance)
|
|
|
1834 {
|
|
|
1835 USHORT simErr, CLUT_offset;
|
|
|
1836 char *dst = NULL;
|
|
|
1837 char *palette;
|
|
|
1838 UBYTE n_CLUT_entries, depth, width, height;
|
|
|
1839 UBYTE *data = (UBYTE *)data_instance;
|
|
|
1840
|
|
|
1841 TRACE_FUNCTION("sim_img_instance_data_cnf()");
|
|
|
1842
|
|
|
1843 #ifdef FF_2TO1_PS
|
|
|
1844 simErr = CAUSE_SIM_NO_ERROR;
|
|
|
1845 #else
|
|
|
1846 simErr = SIM_NO_ERROR;
|
|
|
1847 #endif
|
|
|
1848
|
|
|
1849 if (error == simErr)
|
|
|
1850 {
|
|
|
1851 /* Decode the Black & white image*/
|
|
|
1852 if(icon_image.image_instance.image_coding == BW_ICON)
|
|
|
1853 {
|
|
|
1854 width = *data;
|
|
|
1855 data++;
|
|
|
1856 height = *data;
|
|
|
1857 data++;
|
|
|
1858 dst = (char*)mfwAlloc(width * height);
|
|
|
1859
|
|
|
1860 if (dst == NULL)
|
|
|
1861 {
|
|
|
1862 /* Memory allocation failed, clean up & return */
|
|
|
1863 TRACE_ERROR("ERROR: Failed to allocate memory for sim_img_instance_data_cnf");
|
|
|
1864 satResponse(SatResImpossible);
|
|
|
1865 read_image_instance_file = FALSE;
|
|
|
1866 isAlphaIdIconPresent = FALSE;
|
|
|
1867 return;
|
|
|
1868 }
|
|
|
1869 /* B&W Converter function*/
|
|
|
1870 convert_11_image(width, height, (char *)data, dst);
|
|
|
1871 }
|
|
|
1872 /* Decode the Color image*/
|
|
|
1873 else if(icon_image.image_instance.image_coding == COLOR_ICON)
|
|
|
1874 {
|
|
|
1875 width = *data;
|
|
|
1876 data++;
|
|
|
1877 height = *data;
|
|
|
1878 data++;
|
|
|
1879 depth = *data;
|
|
|
1880 data++;
|
|
|
1881 n_CLUT_entries = *data; /* number of entries in CLUT */
|
|
|
1882 data++;
|
|
|
1883 CLUT_offset = (*data) << 8; /* HIGH: offset of CLUT */
|
|
|
1884 data++;
|
|
|
1885 CLUT_offset |= (*data); /* LOW: offset of CLUT */
|
|
|
1886 data++;
|
|
|
1887 dst = (char*)mfwAlloc(width * height);
|
|
|
1888
|
|
|
1889 if (dst == NULL)
|
|
|
1890 {
|
|
|
1891 /* Memory allocation failed, clean up & return */
|
|
|
1892 TRACE_ERROR("ERROR: Failed to allocate memory for sim_img_instance_data_cnf");
|
|
|
1893 satResponse(SatResImpossible);
|
|
|
1894 read_image_instance_file = FALSE;
|
|
|
1895 isAlphaIdIconPresent = FALSE;
|
|
|
1896 return;
|
|
|
1897 }
|
|
|
1898
|
|
|
1899 palette = (char *)(data + CLUT_offset - 6);
|
|
|
1900 /* Color Converter function*/
|
|
|
1901 convert_21_image(width, height, depth, data, (UBYTE *)palette, (UBYTE *)dst);
|
|
|
1902 }
|
|
|
1903
|
|
|
1904 switch (cmd.type)
|
|
|
1905 {
|
|
|
1906 case SatCmdDispText: iconDataUpdate(&cmd.c.text, width, height, dst); break;
|
|
|
1907 case SatCmdGetKey: iconDataUpdate(&cmd.c.text, width, height, dst); break;
|
|
|
1908 case SatCmdGetString: iconDataUpdate(&cmd.c.inp.prompt, width, height, dst); break;
|
|
|
1909 case SatCmdSetMenu:
|
|
|
1910 case SatCmdSelItem:
|
|
|
1911 {
|
|
|
1912 if(isAlphaIdIconPresent)
|
|
|
1913 {
|
|
|
1914 /* copy the header icon data & set the isAlphaIdIconPresent flag FALSE temporarily*/
|
|
|
1915 iconDataUpdate(&cmd.c.menu.header, width, height, dst);
|
|
|
1916 isAlphaIdIconPresent = FALSE;
|
|
|
1917 }
|
|
|
1918
|
|
|
1919 /* We have to read the icons present for each menu item now.
|
|
|
1920 We safely assume that the icons for each menu item is the same.
|
|
|
1921 Since the SAT Icon display is only for demo, we are not checking
|
|
|
1922 if separate icons has to be read for each item.
|
|
|
1923 */
|
|
|
1924 if(isItemIconPresent)
|
|
|
1925 {
|
|
|
1926 /* Copy the data into the cmd structure to be passed to BMI. */
|
|
|
1927 cmd.c.menu.items[1].iconInfo.dst = (char *) dst;
|
|
|
1928 cmd.c.menu.items[1].iconInfo.height = height;
|
|
|
1929 cmd.c.menu.items[1].iconInfo.width = width;
|
|
|
1930 isAlphaIdIconPresent = TRUE;
|
|
|
1931 isItemIconPresent = FALSE;
|
|
|
1932 }
|
|
|
1933
|
|
|
1934 if (!isAlphaIdIconPresent)
|
|
|
1935 {
|
|
|
1936 /* If the icon is present for menu items also, go ahead & read it. */
|
|
|
1937 if(cmd.c.menu.itemIconQual != 0xFF)
|
|
|
1938 {
|
|
|
1939 isItemIconPresent = TRUE;
|
|
|
1940 /* Set the Image instance flag to FALSE, so that we read the icons for the menu items. */
|
|
|
1941 read_image_instance_file = FALSE;
|
|
|
1942 /* Read the icon data present for Item menu list*/
|
|
|
1943 simReadIconData(cmd.c.menu.items[1].icon);
|
|
|
1944 }
|
|
|
1945 else
|
|
|
1946 isAlphaIdIconPresent = TRUE;
|
|
|
1947 }
|
|
|
1948 }
|
|
|
1949 break;
|
|
|
1950 case SatCmdSndSMS: iconDataUpdate(&cmd.c.sms.info, width, height, dst); break;
|
|
|
1951 case SatCmdSndSS: iconDataUpdate(&cmd.c.ss.info, width, height, dst); break;
|
|
|
1952 case SatCmdSndUSSD: iconDataUpdate(&cmd.c.ss.info, width, height, dst); break;
|
|
|
1953 case SatCmdCall: //x0035544 Feb 06, 2006 DR:OMAPS00061467
|
|
|
1954 //check if icon data is present for the first alpha identifier then update it. also check if icon data is present for alpha id2
|
|
|
1955 if(cmd.c.call.info.icon.qual != 0xFF)
|
|
|
1956 {
|
|
|
1957 iconDataUpdate(&cmd.c.call.info, width, height, dst);
|
|
|
1958 }
|
|
|
1959 if(cmd.c.call.info2.icon.qual != 0xFF)
|
|
|
1960 {
|
|
|
1961 // check if icon id for both the alpha identifiers is same or not. if so then get the same icon data.
|
|
|
1962 if(cmd.c.call.info2.icon.id == cmd.c.call.info.icon.id)
|
|
|
1963 iconDataUpdate(&cmd.c.call.info2, width, height, dst);
|
|
|
1964 //else part is not implemented as it is just for demonstration
|
|
|
1965 }
|
|
|
1966 break;
|
|
|
1967 case SatCmdIdleText: iconDataUpdate(&cmd.c.text, width, height, dst); break;
|
|
|
1968 case SatCmdExecAT: break;
|
|
|
1969 case SatCmdSndDTMF: iconDataUpdate(&cmd.c.cmd.info, width, height, dst); break;
|
|
|
1970 default:
|
|
|
1971 TRACE_ERROR("unknown command");
|
|
|
1972 satResponse(SatResUnknownType);
|
|
|
1973 return;
|
|
|
1974 }
|
|
|
1975
|
|
|
1976 }
|
|
|
1977
|
|
|
1978 if (curSATCmd && isAlphaIdIconPresent)
|
|
|
1979 {
|
|
|
1980 satSignal(curSATCmd,&cmd);
|
|
|
1981 read_image_instance_file = FALSE;
|
|
|
1982 isAlphaIdIconPresent = FALSE;
|
|
|
1983
|
|
|
1984 }
|
|
|
1985 //x0035544 Mar 11, 2006 DR:OMAPS00061467
|
|
|
1986 //Aafter SAT_SETUP_CALL event is executed then only send MfwSatCcAlert event
|
|
|
1987 if(setupCall_Executed == TRUE)
|
|
|
1988 {
|
|
|
1989 satSignal(MfwSatCcAlert,&cmd);
|
|
|
1990 setupCall_Executed = FALSE;
|
|
|
1991 }
|
|
|
1992
|
|
|
1993 }
|
|
|
1994
|
|
|
1995 /*
|
|
|
1996 +-----------------------------------------------------------------------------+
|
|
|
1997 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
1998 | STATE : code ROUTINE : iconDataUpdate |
|
|
|
1999 +-----------------------------------------------------------------------------+
|
|
|
2000
|
|
|
2001 PURPOSE : To copy the image data details to be passed to BMI.
|
|
|
2002
|
|
|
2003 */
|
|
|
2004 void iconDataUpdate(SatTxt *t, UBYTE width, UBYTE height, char *dst)
|
|
|
2005 {
|
|
|
2006 TRACE_FUNCTION("iconDataUpdate()");
|
|
|
2007
|
|
|
2008 /* Copy the data into the cmd structure to be passed to BMI. */
|
|
|
2009 t->iconInfo.dst = (char *) dst;
|
|
|
2010 t->iconInfo.height = height;
|
|
|
2011 t->iconInfo.width = width;
|
|
|
2012
|
|
|
2013 }
|
|
|
2014
|
|
|
2015
|
|
|
2016 /*
|
|
|
2017 +-----------------------------------------------------------------------------+
|
|
|
2018 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2019 | STATE : code ROUTINE : convert_21_image |
|
|
|
2020 +-----------------------------------------------------------------------------+
|
|
|
2021
|
|
|
2022 PURPOSE : Image converter for Color icon.
|
|
|
2023
|
|
|
2024 */
|
|
|
2025 /* src = image data */
|
|
|
2026 /* dst = converted image data */
|
|
|
2027 void convert_21_image( UBYTE width, UBYTE height, UBYTE depth, UBYTE *src, UBYTE *palette, UBYTE *dst)
|
|
|
2028 {
|
|
|
2029 UBYTE i, j, k;
|
|
|
2030 USHORT src_offset, dst_offset;
|
|
|
2031 USHORT color_index;
|
|
|
2032 UBYTE src_mask = 0x80;
|
|
|
2033 UBYTE dst_mask;
|
|
|
2034 UBYTE value;
|
|
|
2035 USHORT R, G, B;
|
|
|
2036
|
|
|
2037 TRACE_FUNCTION("convert_21_image()");
|
|
|
2038
|
|
|
2039 src_offset = 0;
|
|
|
2040 dst_offset = 0;
|
|
|
2041
|
|
|
2042 for(j=0; j<height; j++)
|
|
|
2043 {
|
|
|
2044 for(i=0; i<width; i++)
|
|
|
2045 {
|
|
|
2046 color_index = 0;
|
|
|
2047 dst_mask = 1 << depth;
|
|
|
2048 for(k=0; k<depth; k++)
|
|
|
2049 {
|
|
|
2050 dst_mask = dst_mask >> 1;
|
|
|
2051 if(src[src_offset] & src_mask) color_index |= dst_mask;
|
|
|
2052
|
|
|
2053 if(src_mask == 0x01)
|
|
|
2054 {
|
|
|
2055 src_mask = 0x80;
|
|
|
2056 src_offset ++;
|
|
|
2057 }
|
|
|
2058 else src_mask = src_mask >> 1;
|
|
|
2059 }
|
|
|
2060 color_index *= 3;
|
|
|
2061 R = palette[color_index + 0];
|
|
|
2062 G = palette[color_index + 1];
|
|
|
2063 B = palette[color_index + 2];
|
|
|
2064 RGB_TO_PIXEL(R, G, B, value);
|
|
|
2065 dst[dst_offset] = value;
|
|
|
2066 dst_offset++;
|
|
|
2067 }
|
|
|
2068 }
|
|
|
2069
|
|
|
2070 }
|
|
|
2071
|
|
|
2072 /*
|
|
|
2073 +-----------------------------------------------------------------------------+
|
|
|
2074 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2075 | STATE : code ROUTINE : convert_11_image |
|
|
|
2076 +-----------------------------------------------------------------------------+
|
|
|
2077
|
|
|
2078 PURPOSE : Image converter for B/W icon.
|
|
|
2079
|
|
|
2080 */
|
|
|
2081 /* src = image data */
|
|
|
2082 /* dst = converted image data */
|
|
|
2083 void convert_11_image(UBYTE width, UBYTE height, char *src, char *dst)
|
|
|
2084 {
|
|
|
2085 UBYTE i, j;
|
|
|
2086 USHORT src_offset, dst_offset;
|
|
|
2087 USHORT mask = 0x80;
|
|
|
2088 UBYTE value;
|
|
|
2089
|
|
|
2090 TRACE_FUNCTION("convert_11_image()");
|
|
|
2091
|
|
|
2092 src_offset = 0;
|
|
|
2093 dst_offset = 0;
|
|
|
2094
|
|
|
2095 for(j=0; j<height; j++)
|
|
|
2096 {
|
|
|
2097 for(i=0; i<width; i++)
|
|
|
2098 {
|
|
|
2099 if(src[src_offset] & mask)
|
|
|
2100 value = 0x00;
|
|
|
2101 else
|
|
|
2102 value = 0xFF;
|
|
|
2103
|
|
|
2104 dst[dst_offset] = value;
|
|
|
2105 dst_offset++;
|
|
|
2106
|
|
|
2107 if(mask == 0x01)
|
|
|
2108 {
|
|
|
2109 mask = 0x80;
|
|
|
2110 src_offset ++;
|
|
|
2111 }
|
|
|
2112 else mask = mask >> 1;
|
|
|
2113 }
|
|
|
2114 }
|
|
|
2115 }
|
|
|
2116 #endif
|
|
|
2117
|
|
|
2118 /*
|
|
|
2119 +--------------------------------------------------------------------+
|
|
|
2120 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2121 | STATE : code ROUTINE : decRespFlag |
|
|
|
2122 +--------------------------------------------------------------------+
|
|
|
2123
|
|
|
2124 PURPOSE : decode TLV: immediate response
|
|
|
2125
|
|
|
2126 */
|
|
|
2127
|
|
|
2128 static U8 decRespFlag (U8 *flag, U8 mandatory)
|
|
|
2129 {
|
|
|
2130 U8 res;
|
|
|
2131
|
|
|
2132 TRACE_FUNCTION("decRespFlag()");
|
|
|
2133
|
|
|
2134 res = decTLV(0x2B,mandatory,"ResponseFlag");
|
|
|
2135
|
|
|
2136 if (res > 1)
|
|
|
2137 {
|
|
|
2138 *flag = 1; /* immediate response */
|
|
|
2139 return 1;
|
|
|
2140 }
|
|
|
2141 else
|
|
|
2142 {
|
|
|
2143 *flag = 0; /* no immediate response */
|
|
|
2144 }
|
|
|
2145
|
|
|
2146 return res;
|
|
|
2147 }
|
|
|
2148
|
|
|
2149
|
|
|
2150 /*
|
|
|
2151 +--------------------------------------------------------------------+
|
|
|
2152 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2153 | STATE : code ROUTINE : decDispText |
|
|
|
2154 +--------------------------------------------------------------------+
|
|
|
2155
|
|
|
2156 PURPOSE : decode command: display text
|
|
|
2157
|
|
|
2158 */
|
|
|
2159
|
|
|
2160 static U32 decDispText (void)
|
|
|
2161 {
|
|
|
2162 TRACE_FUNCTION("decDispText()");
|
|
|
2163
|
|
|
2164 while (curCmdLen > 0)
|
|
|
2165 {
|
|
|
2166 if (!decDevId(1))
|
|
|
2167 return 0;
|
|
|
2168
|
|
|
2169 if (cmd.source == SatDevSIM && cmd.dest == SatDevDisplay)
|
|
|
2170 break; /* success */
|
|
|
2171
|
|
|
2172 TRACE_ERROR("illegal device combination");
|
|
|
2173 if (curCR)
|
|
|
2174 {
|
|
|
2175 satResponse(SatResUnknownData);
|
|
|
2176 return 0;
|
|
|
2177 }
|
|
|
2178 partialCompr = 1;
|
|
|
2179 }
|
|
|
2180 if (!decText(&cmd.c.text,0x0D,1))
|
|
|
2181 return 0;
|
|
|
2182
|
|
|
2183 if (!decIconId(&cmd.c.text.icon,0))
|
|
|
2184 return 0; /* fatal error */
|
|
|
2185
|
|
|
2186 if (!decRespFlag(&cmd.c.text.responseFlag,0))
|
|
|
2187 return 0; /* fatal error */
|
|
|
2188
|
|
|
2189 /* SPR#2340 - DS - If len is zero, string is empty */
|
|
|
2190 if (cmd.c.text.len == 0x00)
|
|
|
2191 {
|
|
|
2192 /* If no text string is supplied send result "Command data not understood by ME" */
|
|
|
2193 satResponse(SatResUnknownData);
|
|
|
2194 }
|
|
|
2195
|
|
|
2196 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2197 #ifdef FF_MMI_SAT_ICON
|
|
|
2198 /* Check if the icon data is present & needs to be read*/
|
|
|
2199 if (cmd.c.text.icon.qual != 0xFF)
|
|
|
2200 {
|
|
|
2201 /* Initialise the icon data members*/
|
|
|
2202 cmd.c.text.iconInfo.width = 0;
|
|
|
2203 cmd.c.text.iconInfo.height = 0;
|
|
|
2204 cmd.c.text.iconInfo.dst = NULL;
|
|
|
2205 simReadIconData(cmd.c.text.icon.id);
|
|
|
2206 }
|
|
|
2207 #endif
|
|
|
2208 return MfwSatTextOut;
|
|
|
2209 }
|
|
|
2210
|
|
|
2211
|
|
|
2212 /*
|
|
|
2213 +--------------------------------------------------------------------+
|
|
|
2214 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2215 | STATE : code ROUTINE : decGetKey |
|
|
|
2216 +--------------------------------------------------------------------+
|
|
|
2217
|
|
|
2218 PURPOSE : decode command: get inkey
|
|
|
2219
|
|
|
2220 */
|
|
|
2221
|
|
|
2222 static U32 decGetKey (void)
|
|
|
2223 {
|
|
|
2224 TRACE_FUNCTION("decGetKey()");
|
|
|
2225
|
|
|
2226 while (curCmdLen > 0)
|
|
|
2227 {
|
|
|
2228 if (!decDevId(1))
|
|
|
2229 return 0;
|
|
|
2230
|
|
|
2231 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
2232 break; /* success */
|
|
|
2233
|
|
|
2234 TRACE_ERROR("illegal device combination");
|
|
|
2235 if (curCR)
|
|
|
2236 {
|
|
|
2237 satResponse(SatResUnknownData);
|
|
|
2238 return 0;
|
|
|
2239 }
|
|
|
2240 partialCompr = 1;
|
|
|
2241 }
|
|
|
2242 if (!decText(&cmd.c.text,0x0D,1))
|
|
|
2243 return 0;
|
|
|
2244
|
|
|
2245 if (!decIconId(&cmd.c.text.icon,0))
|
|
|
2246 return 0; /* fatal error */
|
|
|
2247
|
|
|
2248 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2249 #ifdef FF_MMI_SAT_ICON
|
|
|
2250 /* Check if the icon data is present & needs to be read*/
|
|
|
2251 if (cmd.c.text.icon.qual != 0xFF)
|
|
|
2252 {
|
|
|
2253 /* Initialise the icon data members*/
|
|
|
2254 cmd.c.text.iconInfo.width = 0;
|
|
|
2255 cmd.c.text.iconInfo.height = 0;
|
|
|
2256 cmd.c.text.iconInfo.dst = NULL;
|
|
|
2257 simReadIconData(cmd.c.text.icon.id);
|
|
|
2258 }
|
|
|
2259 #endif
|
|
|
2260 return MfwSatGetKey;
|
|
|
2261 }
|
|
|
2262
|
|
|
2263
|
|
|
2264 /*
|
|
|
2265 +--------------------------------------------------------------------+
|
|
|
2266 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2267 | STATE : code ROUTINE : decGetString |
|
|
|
2268 +--------------------------------------------------------------------+
|
|
|
2269
|
|
|
2270 PURPOSE : decode command: get input
|
|
|
2271
|
|
|
2272 */
|
|
|
2273
|
|
|
2274 static U32 decGetString (void)
|
|
|
2275 {
|
|
|
2276 TRACE_FUNCTION("decGetString()");
|
|
|
2277
|
|
|
2278 while (curCmdLen > 0)
|
|
|
2279 {
|
|
|
2280 if (!decDevId(1))
|
|
|
2281 return 0;
|
|
|
2282
|
|
|
2283 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
2284 break; /* success */
|
|
|
2285
|
|
|
2286 TRACE_ERROR("illegal device combination");
|
|
|
2287 if (curCR)
|
|
|
2288 {
|
|
|
2289 satResponse(SatResUnknownData);
|
|
|
2290 return 0;
|
|
|
2291 }
|
|
|
2292 partialCompr = 1;
|
|
|
2293 }
|
|
|
2294 if (!decText(&cmd.c.inp.prompt,0x0D,1))
|
|
|
2295 return 0;
|
|
|
2296 if (!decRespLen(1))
|
|
|
2297 return 0;
|
|
|
2298
|
|
|
2299 cmd.c.inp.defRsp.len = 0; /* default settings */
|
|
|
2300 cmd.c.inp.defRsp.code = 0;
|
|
|
2301 cmd.c.inp.defRsp.text = 0;
|
|
|
2302
|
|
|
2303 if (!decText(&cmd.c.inp.defRsp,0x17,0))
|
|
|
2304 return 0; /* fatal error */
|
|
|
2305
|
|
|
2306 if (!decIconId(&cmd.c.inp.prompt.icon,0))
|
|
|
2307 return 0; /* fatal error */
|
|
|
2308
|
|
|
2309 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2310 #ifdef FF_MMI_SAT_ICON
|
|
|
2311 /* Check if the icon data is present & needs to be read*/
|
|
|
2312 if (cmd.c.inp.prompt.icon.qual != 0xFF)
|
|
|
2313 {
|
|
|
2314 /* Initialise the icon data members*/
|
|
|
2315 cmd.c.inp.prompt.iconInfo.width = 0;
|
|
|
2316 cmd.c.inp.prompt.iconInfo.height = 0;
|
|
|
2317 cmd.c.inp.prompt.iconInfo.dst = NULL;
|
|
|
2318 simReadIconData(cmd.c.inp.prompt.icon.id);
|
|
|
2319 }
|
|
|
2320 #endif
|
|
|
2321 return MfwSatGetString;
|
|
|
2322 }
|
|
|
2323
|
|
|
2324
|
|
|
2325 /*
|
|
|
2326 +--------------------------------------------------------------------+
|
|
|
2327 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2328 | STATE : code ROUTINE : decPlayTone |
|
|
|
2329 +--------------------------------------------------------------------+
|
|
|
2330
|
|
|
2331 PURPOSE : decode command: play tone
|
|
|
2332
|
|
|
2333 */
|
|
|
2334
|
|
|
2335 static U32 decPlayTone (void)
|
|
|
2336 {
|
|
|
2337 TRACE_FUNCTION("decPlayTone()");
|
|
|
2338
|
|
|
2339 while (curCmdLen > 0)
|
|
|
2340 {
|
|
|
2341 if (!decDevId(1))
|
|
|
2342 return 0;
|
|
|
2343
|
|
|
2344 if (cmd.source == SatDevSIM && cmd.dest == SatDevSpeaker)
|
|
|
2345 break; /* success */
|
|
|
2346
|
|
|
2347 TRACE_ERROR("illegal device combination");
|
|
|
2348 if (curCR)
|
|
|
2349 {
|
|
|
2350 satResponse(SatResUnknownData);
|
|
|
2351 return 0;
|
|
|
2352 }
|
|
|
2353 partialCompr = 1;
|
|
|
2354 }
|
|
|
2355
|
|
|
2356 cmd.c.tone.alpha.len = 0; /* default settings */
|
|
|
2357 cmd.c.tone.alpha.code = 0;
|
|
|
2358 cmd.c.tone.alpha.text = 0;
|
|
|
2359 cmd.c.tone.tone = 0;
|
|
|
2360 cmd.c.tone.durUnit = 0;
|
|
|
2361 cmd.c.tone.durValue = 0;
|
|
|
2362
|
|
|
2363 if (!decAlpha(&cmd.c.tone.alpha,0))
|
|
|
2364 return 0;
|
|
|
2365 if (!decTone(0))
|
|
|
2366 return 0;
|
|
|
2367 if (!decDuration(&cmd.c.tone.durUnit,0))
|
|
|
2368 return 0;
|
|
|
2369
|
|
|
2370 return MfwSatPlayTone;
|
|
|
2371 }
|
|
|
2372
|
|
|
2373
|
|
|
2374 /*
|
|
|
2375 +--------------------------------------------------------------------+
|
|
|
2376 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2377 | STATE : code ROUTINE : decSetMenu |
|
|
|
2378 +--------------------------------------------------------------------+
|
|
|
2379
|
|
|
2380 PURPOSE : decode command: setup menu
|
|
|
2381
|
|
|
2382 */
|
|
|
2383
|
|
|
2384 static U32 decSetMenu (void)
|
|
|
2385 {
|
|
|
2386 SatItem *ip;
|
|
|
2387 S16 oldLen;
|
|
|
2388 U8 nItems;
|
|
|
2389
|
|
|
2390 TRACE_FUNCTION("decSetMenu()");
|
|
|
2391
|
|
|
2392 while (curCmdLen > 0)
|
|
|
2393 {
|
|
|
2394 if (!decDevId(1))
|
|
|
2395 return 0;
|
|
|
2396
|
|
|
2397 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
2398 break; /* success */
|
|
|
2399
|
|
|
2400 TRACE_ERROR("illegal device combination");
|
|
|
2401 if (curCR)
|
|
|
2402 {
|
|
|
2403 satResponse(SatResUnknownData);
|
|
|
2404 return 0;
|
|
|
2405 }
|
|
|
2406 partialCompr = 1;
|
|
|
2407 }
|
|
|
2408 cmd.c.menu.nItems = 0;
|
|
|
2409 if (!decAlpha(&cmd.c.menu.header,1))
|
|
|
2410 return 0;
|
|
|
2411
|
|
|
2412 oldLen = curCmdLen;
|
|
|
2413 ip = cmd.c.menu.items;
|
|
|
2414 if (!decItem(ip,1))
|
|
|
2415 return 0;
|
|
|
2416 nItems = 0; /* number of menu items */
|
|
|
2417
|
|
|
2418 while (oldLen != curCmdLen) /* really decoded something */
|
|
|
2419 {
|
|
|
2420 nItems++;
|
|
|
2421 oldLen = curCmdLen;
|
|
|
2422 ip++;
|
|
|
2423 if (!decItem(ip,0))
|
|
|
2424 return 0;
|
|
|
2425 }
|
|
|
2426
|
|
|
2427 if (!decNextAction(cmd.c.menu.items,nItems,0))
|
|
|
2428 return 0;
|
|
|
2429
|
|
|
2430 if (!decIconId(&cmd.c.menu.header.icon,0))
|
|
|
2431 return 0;
|
|
|
2432
|
|
|
2433 if (!decItemIcons(&cmd.c.menu,cmd.c.menu.items,nItems,0))
|
|
|
2434 return 0;
|
|
|
2435
|
|
|
2436 cmd.c.menu.nItems = nItems;
|
|
|
2437
|
|
|
2438 // Shashi Shekar B.S., a0876501, Feb 4, 2006, DR: OMAPS00061462
|
|
|
2439 #ifdef FF_MMI_SAT_ICON
|
|
|
2440 /* Check if the icon data is present in the Alpha id & needs to be read*/
|
|
|
2441 if (cmd.c.menu.header.icon.qual != 0xFF)
|
|
|
2442 {
|
|
|
2443 /* Initialise the icon data members*/
|
|
|
2444 cmd.c.menu.header.iconInfo.width = 0;
|
|
|
2445 cmd.c.menu.header.iconInfo.height = 0;
|
|
|
2446 cmd.c.menu.header.iconInfo.dst = NULL;
|
|
|
2447 simReadIconData(cmd.c.menu.header.icon.id);
|
|
|
2448 }
|
|
|
2449
|
|
|
2450 /* We have to read theicons present for each menu item now.
|
|
|
2451 We safely assume that the icons for each menu item is the same.
|
|
|
2452 Since the SAT Icon display is only for demo, we are not checking
|
|
|
2453 if separate icons has to be read for each item.
|
|
|
2454 */
|
|
|
2455 if (cmd.c.menu.itemIconQual != 0xFF)
|
|
|
2456 {
|
|
|
2457 /* Initialise the icon data members*/
|
|
|
2458 cmd.c.menu.items[1].iconInfo.width = 0;
|
|
|
2459 cmd.c.menu.items[1].iconInfo.height = 0;
|
|
|
2460 cmd.c.menu.items[1].iconInfo.dst = NULL;
|
|
|
2461 }
|
|
|
2462 #endif
|
|
|
2463
|
|
|
2464 return MfwSatSetupMenu;
|
|
|
2465 }
|
|
|
2466
|
|
|
2467
|
|
|
2468 /*
|
|
|
2469 +--------------------------------------------------------------------+
|
|
|
2470 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2471 | STATE : code ROUTINE : decSelItem |
|
|
|
2472 +--------------------------------------------------------------------+
|
|
|
2473
|
|
|
2474 PURPOSE : decode command: select item
|
|
|
2475
|
|
|
2476 */
|
|
|
2477
|
|
|
2478 static U32 decSelItem (void)
|
|
|
2479 {
|
|
|
2480 SatItem *ip;
|
|
|
2481 S16 oldLen;
|
|
|
2482 U8 nItems;
|
|
|
2483
|
|
|
2484 TRACE_FUNCTION("decSelItem()");
|
|
|
2485
|
|
|
2486 while (curCmdLen > 0)
|
|
|
2487 {
|
|
|
2488 if (!decDevId(1))
|
|
|
2489 return 0;
|
|
|
2490
|
|
|
2491 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
2492 break; /* success */
|
|
|
2493
|
|
|
2494 TRACE_ERROR("illegal device combination");
|
|
|
2495 if (curCR)
|
|
|
2496 {
|
|
|
2497 satResponse(SatResUnknownData);
|
|
|
2498 return 0;
|
|
|
2499 }
|
|
|
2500 partialCompr = 1;
|
|
|
2501 }
|
|
|
2502 cmd.c.menu.nItems = 0;
|
|
|
2503
|
|
|
2504 cmd.c.menu.header.code = 0; /* set default values */
|
|
|
2505 cmd.c.menu.header.len = 0;
|
|
|
2506 cmd.c.menu.header.text = 0;
|
|
|
2507 if (!decAlpha(&cmd.c.menu.header,0))
|
|
|
2508 return 0;
|
|
|
2509
|
|
|
2510 oldLen = curCmdLen;
|
|
|
2511 ip = cmd.c.menu.items;
|
|
|
2512 if (!decItem(ip,1))
|
|
|
2513 return 0;
|
|
|
2514 nItems = 0; /* number of menu items */
|
|
|
2515
|
|
|
2516 while (oldLen != curCmdLen) /* really decoded something */
|
|
|
2517 {
|
|
|
2518 nItems++;
|
|
|
2519 oldLen = curCmdLen;
|
|
|
2520 ip++;
|
|
|
2521 if (!decItem(ip,0))
|
|
|
2522 return 0;
|
|
|
2523 }
|
|
|
2524
|
|
|
2525 if (!decNextAction(cmd.c.menu.items,nItems,0))
|
|
|
2526 return 0;
|
|
|
2527
|
|
|
2528 if (!decDefItem(cmd.c.menu.items,nItems,0))
|
|
|
2529 return 0;
|
|
|
2530
|
|
|
2531 if (!decIconId(&cmd.c.menu.header.icon,0))
|
|
|
2532 return 0;
|
|
|
2533
|
|
|
2534 if (!decItemIcons(&cmd.c.menu,cmd.c.menu.items,nItems,0))
|
|
|
2535 return 0;
|
|
|
2536
|
|
|
2537 cmd.c.menu.nItems = nItems;
|
|
|
2538
|
|
|
2539 // Shashi Shekar B.S., a0876501, Feb 4, 2006, DR: OMAPS00061462
|
|
|
2540 #ifdef FF_MMI_SAT_ICON
|
|
|
2541 /* Check if the icon data is present in the Alpha id & needs to be read*/
|
|
|
2542 if (cmd.c.menu.header.icon.qual != 0xFF)
|
|
|
2543 {
|
|
|
2544 /* Initialise the icon data members*/
|
|
|
2545 cmd.c.menu.header.iconInfo.width = 0;
|
|
|
2546 cmd.c.menu.header.iconInfo.height = 0;
|
|
|
2547 cmd.c.menu.header.iconInfo.dst = NULL;
|
|
|
2548 simReadIconData(cmd.c.menu.header.icon.id);
|
|
|
2549 }
|
|
|
2550
|
|
|
2551 /* We have to read theicons present for each menu item now.
|
|
|
2552 We safely assume that the icons for each menu item is the same.
|
|
|
2553 Since the SAT Icon display is only for demo, we are not checking
|
|
|
2554 if separate icons has to be read for each item.
|
|
|
2555 */
|
|
|
2556 if (cmd.c.menu.itemIconQual != 0xFF)
|
|
|
2557 {
|
|
|
2558 /* Initialise the icon data members*/
|
|
|
2559 cmd.c.menu.items[1].iconInfo.width = 0;
|
|
|
2560 cmd.c.menu.items[1].iconInfo.height = 0;
|
|
|
2561 cmd.c.menu.items[1].iconInfo.dst = NULL;
|
|
|
2562 }
|
|
|
2563 #endif
|
|
|
2564
|
|
|
2565 return MfwSatSelectItem;
|
|
|
2566 }
|
|
|
2567
|
|
|
2568
|
|
|
2569 /*
|
|
|
2570 +--------------------------------------------------------------------+
|
|
|
2571 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2572 | STATE : code ROUTINE : decSndSMS |
|
|
|
2573 +--------------------------------------------------------------------+
|
|
|
2574
|
|
|
2575 PURPOSE : decode command: send SMS
|
|
|
2576
|
|
|
2577 */
|
|
|
2578
|
|
|
2579 static U32 decSndSMS (void)
|
|
|
2580 {
|
|
|
2581 TRACE_FUNCTION("decSndSMS()");
|
|
|
2582
|
|
|
2583 while (curCmdLen > 0)
|
|
|
2584 {
|
|
|
2585 if (!decDevId(1))
|
|
|
2586 return 0;
|
|
|
2587
|
|
|
2588 if (cmd.source == SatDevSIM && cmd.dest == SatDevNet)
|
|
|
2589 break; /* success */
|
|
|
2590
|
|
|
2591 TRACE_ERROR("illegal device combination");
|
|
|
2592 if (curCR)
|
|
|
2593 {
|
|
|
2594 satResponse(SatResUnknownData);
|
|
|
2595 return 0;
|
|
|
2596 }
|
|
|
2597 partialCompr = 1;
|
|
|
2598 }
|
|
|
2599
|
|
|
2600 cmd.c.sms.info.code = 0; /* set default values */
|
|
|
2601 cmd.c.sms.info.len = -1; /* optional info if absent */
|
|
|
2602 cmd.c.sms.info.text = 0;
|
|
|
2603 if (!decAlpha(&cmd.c.sms.info,0))
|
|
|
2604 return 0;
|
|
|
2605
|
|
|
2606 cmd.c.sms.addr.ton = 0; /* set default values */
|
|
|
2607 cmd.c.sms.addr.len = 0;
|
|
|
2608 cmd.c.sms.addr.number = 0;
|
|
|
2609 if (!decAddrSS(&cmd.c.sms.addr,0x06,0)) /* address (SS string) */
|
|
|
2610 return 0;
|
|
|
2611
|
|
|
2612 if (!decSMS(&cmd.c.sms.sms,1))
|
|
|
2613 return 0;
|
|
|
2614
|
|
|
2615 if (!decIconId(&cmd.c.sms.info.icon,0))
|
|
|
2616 return 0;
|
|
|
2617
|
|
|
2618 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2619 #ifdef FF_MMI_SAT_ICON
|
|
|
2620 /* Check if the icon data is present & needs to be read*/
|
|
|
2621 if (cmd.c.sms.info.icon.qual != 0xFF)
|
|
|
2622 {
|
|
|
2623 /* Initialise the icon data members*/
|
|
|
2624 cmd.c.sms.info.iconInfo.width = 0;
|
|
|
2625 cmd.c.sms.info.iconInfo.height = 0;
|
|
|
2626 cmd.c.sms.info.iconInfo.dst = NULL;
|
|
|
2627 simReadIconData(cmd.c.sms.info.icon.id);
|
|
|
2628 }
|
|
|
2629 #endif
|
|
|
2630 return MfwSatSendSMS;
|
|
|
2631 }
|
|
|
2632
|
|
|
2633
|
|
|
2634 /*
|
|
|
2635 +--------------------------------------------------------------------+
|
|
|
2636 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2637 | STATE : code ROUTINE : decSndSS |
|
|
|
2638 +--------------------------------------------------------------------+
|
|
|
2639
|
|
|
2640 PURPOSE : decode command: send SS
|
|
|
2641
|
|
|
2642 */
|
|
|
2643
|
|
|
2644 static U32 decSndSS (void)
|
|
|
2645 {
|
|
|
2646 TRACE_FUNCTION("decSndSS()");
|
|
|
2647
|
|
|
2648 while (curCmdLen > 0)
|
|
|
2649 {
|
|
|
2650 if (!decDevId(1))
|
|
|
2651 return 0;
|
|
|
2652
|
|
|
2653 if (cmd.source == SatDevSIM && cmd.dest == SatDevNet)
|
|
|
2654 break; /* success */
|
|
|
2655
|
|
|
2656 TRACE_ERROR("illegal device combination");
|
|
|
2657 if (curCR)
|
|
|
2658 {
|
|
|
2659 satResponse(SatResUnknownData);
|
|
|
2660 return 0;
|
|
|
2661 }
|
|
|
2662 partialCompr = 1;
|
|
|
2663 }
|
|
|
2664
|
|
|
2665 cmd.c.ss.info.code = 0; /* set default values */
|
|
|
2666 cmd.c.ss.info.len = -1; /* optional info if absent */
|
|
|
2667 cmd.c.ss.info.text = 0;
|
|
|
2668 if (!decAlpha(&cmd.c.ss.info,0))
|
|
|
2669 return 0;
|
|
|
2670
|
|
|
2671 if (!decAddrSS(&cmd.c.ss.ss,0x09,1)) /* SS string (== address) */
|
|
|
2672 return 0;
|
|
|
2673
|
|
|
2674 if (!decIconId(&cmd.c.ss.info.icon,0))
|
|
|
2675 return 0;
|
|
|
2676
|
|
|
2677 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2678 #ifdef FF_MMI_SAT_ICON
|
|
|
2679 /* Check if the icon data is present & needs to be read*/
|
|
|
2680 if (cmd.c.ss.info.icon.qual != 0xFF)
|
|
|
2681 {
|
|
|
2682 /* Initialise the icon data members*/
|
|
|
2683 cmd.c.ss.info.iconInfo.width = 0;
|
|
|
2684 cmd.c.ss.info.iconInfo.height = 0;
|
|
|
2685 cmd.c.ss.info.iconInfo.dst = NULL;
|
|
|
2686 simReadIconData(cmd.c.ss.info.icon.id);
|
|
|
2687 }
|
|
|
2688 #endif
|
|
|
2689 return MfwSatSendSS;
|
|
|
2690 }
|
|
|
2691
|
|
|
2692
|
|
|
2693 /*
|
|
|
2694 +--------------------------------------------------------------------+
|
|
|
2695 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2696 | STATE : code ROUTINE : decSndUSSD |
|
|
|
2697 +--------------------------------------------------------------------+
|
|
|
2698
|
|
|
2699 PURPOSE : decode command: send USSD
|
|
|
2700
|
|
|
2701 */
|
|
|
2702
|
|
|
2703 static U32 decSndUSSD (void)
|
|
|
2704 {
|
|
|
2705 TRACE_FUNCTION("decSndUSSD()");
|
|
|
2706
|
|
|
2707 while (curCmdLen > 0)
|
|
|
2708 {
|
|
|
2709 if (!decDevId(1))
|
|
|
2710 return 0;
|
|
|
2711
|
|
|
2712 if (cmd.source == SatDevSIM && cmd.dest == SatDevNet)
|
|
|
2713 break; /* success */
|
|
|
2714
|
|
|
2715 TRACE_ERROR("illegal device combination");
|
|
|
2716 if (curCR)
|
|
|
2717 {
|
|
|
2718 satResponse(SatResUnknownData);
|
|
|
2719 return 0;
|
|
|
2720 }
|
|
|
2721 partialCompr = 1;
|
|
|
2722 }
|
|
|
2723
|
|
|
2724 cmd.c.ss.info.code = 0; /* set default values */
|
|
|
2725 cmd.c.ss.info.len = -1; /* optional info if absent */
|
|
|
2726 cmd.c.ss.info.text = 0;
|
|
|
2727 if (!decAlpha(&cmd.c.ss.info,0))
|
|
|
2728 return 0;
|
|
|
2729
|
|
|
2730 if (!decAddrSS(&cmd.c.ss.ss,0x0A,1)) /* USSD string */
|
|
|
2731 return 0;
|
|
|
2732
|
|
|
2733 if (!decIconId(&cmd.c.ss.info.icon,0))
|
|
|
2734 return 0;
|
|
|
2735
|
|
|
2736 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2737 #ifdef FF_MMI_SAT_ICON
|
|
|
2738 /* Check if the icon data is present & needs to be read*/
|
|
|
2739 if (cmd.c.ss.info.icon.qual != 0xFF)
|
|
|
2740 {
|
|
|
2741 /* Initialise the icon data members*/
|
|
|
2742 cmd.c.ss.info.iconInfo.width = 0;
|
|
|
2743 cmd.c.ss.info.iconInfo.height = 0;
|
|
|
2744 cmd.c.ss.info.iconInfo.dst = NULL;
|
|
|
2745 simReadIconData(cmd.c.ss.info.icon.id);
|
|
|
2746 }
|
|
|
2747 #endif
|
|
|
2748 return MfwSatSendUSSD;
|
|
|
2749 }
|
|
|
2750
|
|
|
2751
|
|
|
2752 /*
|
|
|
2753 +--------------------------------------------------------------------+
|
|
|
2754 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2755 | STATE : code ROUTINE : decCall |
|
|
|
2756 +--------------------------------------------------------------------+
|
|
|
2757
|
|
|
2758 PURPOSE : decode command: setup call
|
|
|
2759
|
|
|
2760 */
|
|
|
2761
|
|
|
2762 static U32 decCall (void)
|
|
|
2763 {
|
|
|
2764 TRACE_FUNCTION("decCall()");
|
|
|
2765
|
|
|
2766 while (curCmdLen > 0)
|
|
|
2767 {
|
|
|
2768 if (!decDevId(1))
|
|
|
2769 return 0;
|
|
|
2770
|
|
|
2771 if (cmd.source == SatDevSIM && cmd.dest == SatDevNet)
|
|
|
2772 break; /* success */
|
|
|
2773
|
|
|
2774 TRACE_ERROR("illegal device combination");
|
|
|
2775 if (curCR)
|
|
|
2776 {
|
|
|
2777 satResponse(SatResUnknownData);
|
|
|
2778 return 0;
|
|
|
2779 }
|
|
|
2780 partialCompr = 1;
|
|
|
2781 }
|
|
|
2782
|
|
|
2783 cmd.c.call.info.code = 0; /* set default values */
|
|
|
2784 cmd.c.call.info.len = -1; /* optional info if absent */
|
|
|
2785 cmd.c.call.info.text = 0;
|
|
|
2786
|
|
|
2787 cmd.c.call.info2.code = 0; /* set default values */
|
|
|
2788 cmd.c.call.info2.len = -1; /* optional info if absent */
|
|
|
2789 cmd.c.call.info2.text = 0;
|
|
|
2790
|
|
|
2791 if (!decAlpha(&cmd.c.call.info,0))
|
|
|
2792 return 0;
|
|
|
2793
|
|
|
2794 if (!decAddrSS(&cmd.c.call.addr,0x06,1)) /* address (SS string) */
|
|
|
2795 return 0;
|
|
|
2796
|
|
|
2797 cmd.c.call.bc.len = 0; /* set default values */
|
|
|
2798 cmd.c.call.bc.data = 0;
|
|
|
2799 if (!decData(&cmd.c.call.bc,0x07,0)) /* bearer capabilities */
|
|
|
2800 return 0;
|
|
|
2801
|
|
|
2802 cmd.c.call.sa.len = 0; /* set default values */
|
|
|
2803 cmd.c.call.sa.data = 0;
|
|
|
2804 if (!decData(&cmd.c.call.sa,0x08,0)) /* subaddress */
|
|
|
2805 return 0;
|
|
|
2806
|
|
|
2807 cmd.c.call.durUnit = 0; /* set default values */
|
|
|
2808 cmd.c.call.durValue = 0;
|
|
|
2809 if (!decDuration(&cmd.c.call.durUnit,0)) /* redial timing */
|
|
|
2810 return 0;
|
|
|
2811
|
|
|
2812 if (!decIconId(&cmd.c.call.info.icon,0)) /* icon for info 1 */
|
|
|
2813 return 0;
|
|
|
2814
|
|
|
2815 if (!decAlpha(&cmd.c.call.info2,0)) /* call setup info (2) */
|
|
|
2816 return 0;
|
|
|
2817
|
|
|
2818 if (!decIconId(&cmd.c.call.info2.icon,0)) /* icon for info 2 */
|
|
|
2819 return 0;
|
|
|
2820 //Sudha.V x0035544, feb 06, 2006 DR:OMAPS00061467
|
|
|
2821 #ifdef FF_MMI_SAT_ICON
|
|
|
2822 /* Check if the icon data is present for alpha identifier 1 & needs to be read*/
|
|
|
2823 if (cmd.c.call.info.icon.qual != 0xFF)
|
|
|
2824 {
|
|
|
2825 /* Since we have two icons present, if second Alpha id is present,
|
|
|
2826 set the isAlphaIdIconPresent to TRUE explicitly since the second Alpha icon will
|
|
|
2827 reset this flag if not present & we wont enter the icon decoder*/
|
|
|
2828 isAlphaIdIconPresent = TRUE;
|
|
|
2829 /* Initialise the icon data members*/
|
|
|
2830 cmd.c.call.info.iconInfo.width = 0;
|
|
|
2831 cmd.c.call.info.iconInfo.height = 0;
|
|
|
2832 cmd.c.call.info.iconInfo.dst = NULL;
|
|
|
2833 simReadIconData(cmd.c.call.info.icon.id);
|
|
|
2834 }
|
|
|
2835 /* Check if the icon data is present for alpha identifier 2 & needs to be read*/
|
|
|
2836 //No need to read icon data for alpha id2 from sim again as it is same as that of alpha id1
|
|
|
2837 if (cmd.c.call.info2.icon.qual != 0xFF)
|
|
|
2838 {
|
|
|
2839 // Initialise the icon data members
|
|
|
2840 cmd.c.call.info2.iconInfo.width = 0;
|
|
|
2841 cmd.c.call.info2.iconInfo.height = 0;
|
|
|
2842 cmd.c.call.info2.iconInfo.dst = NULL;
|
|
|
2843 }
|
|
|
2844 #endif
|
|
|
2845
|
|
|
2846 return MfwSatCall;
|
|
|
2847 }
|
|
|
2848
|
|
|
2849
|
|
|
2850 /*
|
|
|
2851 +--------------------------------------------------------------------+
|
|
|
2852 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2853 | STATE : code ROUTINE : decExecAT |
|
|
|
2854 +--------------------------------------------------------------------+
|
|
|
2855
|
|
|
2856 PURPOSE : decode command: run AT command
|
|
|
2857
|
|
|
2858 */
|
|
|
2859
|
|
|
2860 static U32 decExecAT (void)
|
|
|
2861 {
|
|
|
2862 TRACE_FUNCTION("decExecAT()");
|
|
|
2863
|
|
|
2864 while (curCmdLen > 0)
|
|
|
2865 {
|
|
|
2866 if (!decDevId(1))
|
|
|
2867 return 0;
|
|
|
2868
|
|
|
2869 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
2870 break; /* success */
|
|
|
2871
|
|
|
2872 TRACE_ERROR("illegal device combination");
|
|
|
2873 if (curCR)
|
|
|
2874 {
|
|
|
2875 satResponse(SatResUnknownData);
|
|
|
2876 return 0;
|
|
|
2877 }
|
|
|
2878 partialCompr = 1;
|
|
|
2879 }
|
|
|
2880
|
|
|
2881 cmd.c.cmd.info.code = 0; /* set default values */
|
|
|
2882 cmd.c.cmd.info.len = -1; /* optional info if absent */
|
|
|
2883 cmd.c.cmd.info.text = 0;
|
|
|
2884 if (!decAlpha(&cmd.c.cmd.info,0))
|
|
|
2885 return 0;
|
|
|
2886
|
|
|
2887 cmd.c.cmd.cmd.len = 0; /* set default values */
|
|
|
2888 cmd.c.cmd.cmd.data = 0;
|
|
|
2889 if (!decData(&cmd.c.cmd.cmd,0x28,1)) /* AT command string */
|
|
|
2890 return 0;
|
|
|
2891
|
|
|
2892 if (!decIconId(&cmd.c.cmd.info.icon,0)) /* icon for info */
|
|
|
2893 return 0;
|
|
|
2894
|
|
|
2895 return MfwSatExecAT;
|
|
|
2896 }
|
|
|
2897
|
|
|
2898
|
|
|
2899 /*
|
|
|
2900 +--------------------------------------------------------------------+
|
|
|
2901 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2902 | STATE : code ROUTINE : decSndDTMF |
|
|
|
2903 +--------------------------------------------------------------------+
|
|
|
2904
|
|
|
2905 PURPOSE : decode command: send DTMF
|
|
|
2906
|
|
|
2907 */
|
|
|
2908
|
|
|
2909 static U32 decSndDTMF (void)
|
|
|
2910 {
|
|
|
2911 TRACE_FUNCTION("decSndDTMF()");
|
|
|
2912
|
|
|
2913 while (curCmdLen > 0)
|
|
|
2914 {
|
|
|
2915 if (!decDevId(1))
|
|
|
2916 return 0;
|
|
|
2917
|
|
|
2918 if (cmd.source == SatDevSIM && cmd.dest == SatDevNet)
|
|
|
2919 break; /* success */
|
|
|
2920
|
|
|
2921 TRACE_ERROR("illegal device combination");
|
|
|
2922 if (curCR)
|
|
|
2923 {
|
|
|
2924 satResponse(SatResUnknownData);
|
|
|
2925 return 0;
|
|
|
2926 }
|
|
|
2927 partialCompr = 1;
|
|
|
2928 }
|
|
|
2929
|
|
|
2930 cmd.c.cmd.info.code = 0; /* set default values */
|
|
|
2931 cmd.c.cmd.info.len = -1; /* optional info if absent */
|
|
|
2932 cmd.c.cmd.info.text = 0;
|
|
|
2933 if (!decAlpha(&cmd.c.cmd.info,0))
|
|
|
2934 return 0;
|
|
|
2935
|
|
|
2936 cmd.c.cmd.cmd.len = 0; /* set default values */
|
|
|
2937 cmd.c.cmd.cmd.data = 0;
|
|
|
2938 if (!decData(&cmd.c.cmd.cmd,0x2C,1)) /* DTMF string */
|
|
|
2939 return 0;
|
|
|
2940
|
|
|
2941 if (!decIconId(&cmd.c.cmd.info.icon,0)) /* icon for info */
|
|
|
2942 return 0;
|
|
|
2943
|
|
|
2944 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
2945 #ifdef FF_MMI_SAT_ICON
|
|
|
2946 /* Check if the icon data is present & needs to be read*/
|
|
|
2947 if (cmd.c.cmd.info.icon.qual != 0xFF)
|
|
|
2948 {
|
|
|
2949 /* Initialise the icon data members*/
|
|
|
2950 cmd.c.cmd.info.iconInfo.width = 0;
|
|
|
2951 cmd.c.cmd.info.iconInfo.height = 0;
|
|
|
2952 cmd.c.cmd.info.iconInfo.dst = NULL;
|
|
|
2953 simReadIconData(cmd.c.cmd.info.icon.id);
|
|
|
2954 }
|
|
|
2955 #endif
|
|
|
2956 return MfwSatSendDTMF;
|
|
|
2957 }
|
|
|
2958
|
|
|
2959
|
|
|
2960 /*
|
|
|
2961 +--------------------------------------------------------------------+
|
|
|
2962 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
2963 | STATE : code ROUTINE : decCcRes |
|
|
|
2964 +--------------------------------------------------------------------+
|
|
|
2965
|
|
|
2966 PURPOSE : decode Call Control result
|
|
|
2967
|
|
|
2968 */
|
|
|
2969
|
|
|
2970 static U32 decCcRes (void)
|
|
|
2971 {
|
|
|
2972 TRACE_FUNCTION("decCcRes()");
|
|
|
2973
|
|
|
2974 cmd.c.ccres.addr.ton = -1; /* set default values */
|
|
|
2975 cmd.c.ccres.addr.len = -1;
|
|
|
2976 cmd.c.ccres.addr.number = -1;
|
|
|
2977 cmd.c.ccres.addr2.ton = -1; /* set on SMS result */
|
|
|
2978 cmd.c.ccres.addr2.len = -1;
|
|
|
2979 cmd.c.ccres.addr2.number = -1;
|
|
|
2980
|
|
|
2981 if (!decAddrSS(&cmd.c.ccres.addr,0x06,0)) /* address */
|
|
|
2982 return 0;
|
|
|
2983
|
|
|
2984 if (curTag == 0x06) /* was an address */
|
|
|
2985 {
|
|
|
2986 if (!decAddrSS(&cmd.c.ccres.addr2,0x06,0)) /* try another */
|
|
|
2987 return 0;
|
|
|
2988 if (curTag == 0x06) /* hit: have SMS result */
|
|
|
2989 {
|
|
|
2990 cmd.c.ccres.info.code = -1; /* get alpha id */
|
|
|
2991 cmd.c.ccres.info.len = -1;
|
|
|
2992 cmd.c.ccres.info.text = -1;
|
|
|
2993 if (!decAlpha(&cmd.c.ccres.info,0))
|
|
|
2994 return 0;
|
|
|
2995
|
|
|
2996 return MfwSatCcRes;
|
|
|
2997 }
|
|
|
2998 }
|
|
|
2999 else
|
|
|
3000 {
|
|
|
3001 if (curTag == 0x09) /* not an address */
|
|
|
3002 if (!decAddrSS(&cmd.c.ccres.addr,0x09,0)) /* try SS */
|
|
|
3003 return 0;
|
|
|
3004 if (curTag == 0x0a) /* not an SS string */
|
|
|
3005 if (!decAddrSS(&cmd.c.ccres.addr,0x0a,0)) /* try USSD */
|
|
|
3006 return 0;
|
|
|
3007 }
|
|
|
3008
|
|
|
3009 cmd.c.ccres.bc.len = -1; /* set default values */
|
|
|
3010 cmd.c.ccres.bc.data = -1;
|
|
|
3011 if (!decData(&cmd.c.ccres.bc,0x07,0)) /* bearer capabilities */
|
|
|
3012 return 0;
|
|
|
3013
|
|
|
3014 cmd.c.ccres.sa.len = -1; /* set default values */
|
|
|
3015 cmd.c.ccres.sa.data = -1;
|
|
|
3016 if (!decData(&cmd.c.ccres.sa,0x08,0)) /* subaddress */
|
|
|
3017 return 0;
|
|
|
3018
|
|
|
3019 cmd.c.ccres.info.code = -1; /* set default values */
|
|
|
3020 cmd.c.ccres.info.len = -1;
|
|
|
3021 cmd.c.ccres.info.text = -1;
|
|
|
3022 if (!decAlpha(&cmd.c.ccres.info,0)) /* alpha information */
|
|
|
3023 return 0;
|
|
|
3024
|
|
|
3025 cmd.c.ccres.bcRepInd = 0; /* set default values */
|
|
|
3026 if (decByte(&cmd.c.ccres.bcRepInd,0x2a,0)<2) /* BC repeat ind. */
|
|
|
3027 return MfwSatCcRes;
|
|
|
3028
|
|
|
3029 cmd.c.ccres.bc2.len = -1; /* set default values */
|
|
|
3030 cmd.c.ccres.bc2.data = -1;
|
|
|
3031 if (!decData(&cmd.c.ccres.bc2,0x07,0)) /* bearer 2 capabilities */
|
|
|
3032 return 0;
|
|
|
3033
|
|
|
3034 return MfwSatCcRes;
|
|
|
3035 }
|
|
|
3036
|
|
|
3037
|
|
|
3038 /*
|
|
|
3039 +--------------------------------------------------------------------+
|
|
|
3040 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3041 | STATE : code ROUTINE : decRefresh |
|
|
|
3042 +--------------------------------------------------------------------+
|
|
|
3043
|
|
|
3044 PURPOSE : decode command: refresh
|
|
|
3045
|
|
|
3046 */
|
|
|
3047
|
|
|
3048 static U32 decRefresh (void)
|
|
|
3049 {
|
|
|
3050 TRACE_FUNCTION("decRefresh()");
|
|
|
3051
|
|
|
3052 while (curCmdLen > 0)
|
|
|
3053 {
|
|
|
3054 if (!decDevId(1))
|
|
|
3055 return 0;
|
|
|
3056
|
|
|
3057 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
3058 break; /* success */
|
|
|
3059
|
|
|
3060 TRACE_ERROR("illegal device combination");
|
|
|
3061 if (curCR)
|
|
|
3062 {
|
|
|
3063 satResponse(SatResUnknownData);
|
|
|
3064 return 0;
|
|
|
3065 }
|
|
|
3066 partialCompr = 1;
|
|
|
3067 }
|
|
|
3068
|
|
|
3069 cmd.c.files.len = 0; /* set default values */
|
|
|
3070 cmd.c.files.data = 0;
|
|
|
3071 if (!decData(&cmd.c.files,0x12,0)) /* refresh file list */
|
|
|
3072 return 0;
|
|
|
3073
|
|
|
3074 //ES!! do real refresh here...
|
|
|
3075
|
|
|
3076 return MfwSatRefresh;
|
|
|
3077 }
|
|
|
3078
|
|
|
3079
|
|
|
3080 /*
|
|
|
3081 +--------------------------------------------------------------------+
|
|
|
3082 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3083 | STATE : code ROUTINE : decSetEvents |
|
|
|
3084 +--------------------------------------------------------------------+
|
|
|
3085
|
|
|
3086 PURPOSE : decode command: setup event list
|
|
|
3087
|
|
|
3088 */
|
|
|
3089
|
|
|
3090 static U32 decSetEvents (void)
|
|
|
3091 {
|
|
|
3092 U8 *ep;
|
|
|
3093 U8 res;
|
|
|
3094 U8 sat_res[2];
|
|
|
3095
|
|
|
3096 TRACE_FUNCTION("decSetEvents()");
|
|
|
3097
|
|
|
3098 while (curCmdLen > 0)
|
|
|
3099 {
|
|
|
3100 if (!decDevId(1))
|
|
|
3101 return 0;
|
|
|
3102
|
|
|
3103 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
3104 break; /* success */
|
|
|
3105
|
|
|
3106 TRACE_ERROR("illegal device combination");
|
|
|
3107 if (curCR)
|
|
|
3108 {
|
|
|
3109 satResponse(SatResUnknownData);
|
|
|
3110 return 0;
|
|
|
3111 }
|
|
|
3112 partialCompr = 1;
|
|
|
3113 }
|
|
|
3114
|
|
|
3115 cmd.c.events.len = 0; /* default: remove list */
|
|
|
3116 cmd.c.events.elem[0] = 0;
|
|
|
3117 eventList =0;
|
|
|
3118 res = decTLV(0x19,1,"Event List");
|
|
|
3119
|
|
|
3120 if (res > 1)
|
|
|
3121 {
|
|
|
3122 ep = &cmd.c.events.elem[0];
|
|
|
3123 while (curLen--)
|
|
|
3124 {
|
|
|
3125 switch (*curVal)
|
|
|
3126 {
|
|
|
3127 case SatEvtUserAction:
|
|
|
3128 if (eventList & SatEvtUserActionActivated)
|
|
|
3129 {
|
|
|
3130 /*
|
|
|
3131 ** CQ 16435 : This can only have happend if this event is listed more than one
|
|
|
3132 ** which is invalid and causes a reject!
|
|
|
3133 */
|
|
|
3134 eventList = 0;
|
|
|
3135 satResponse(SatResImpossible);
|
|
|
3136 return 0;
|
|
|
3137 }
|
|
|
3138 else
|
|
|
3139 {
|
|
|
3140 eventList|= SatEvtUserActionActivated;
|
|
|
3141 *ep |= *curVal; /* event list element */
|
|
|
3142 cmd.c.events.len++; /* number of events */
|
|
|
3143 }
|
|
|
3144 break;
|
|
|
3145
|
|
|
3146 case SatEvtIdleScreen:
|
|
|
3147 if (eventList & SatEvtIdleScreenActivated)
|
|
|
3148 {
|
|
|
3149 /*
|
|
|
3150 ** CQ 16435 : This can only have happend if this event is listed more than one
|
|
|
3151 ** which is invalid and causes a reject!
|
|
|
3152 */
|
|
|
3153 eventList = 0;
|
|
|
3154 satResponse(SatResImpossible);
|
|
|
3155 return 0;
|
|
|
3156 }
|
|
|
3157 else
|
|
|
3158 {
|
|
|
3159 eventList|= SatEvtIdleScreenActivated;
|
|
|
3160 *ep |= *curVal; /* event list element */
|
|
|
3161 cmd.c.events.len++; /* number of events */
|
|
|
3162 }
|
|
|
3163 break;
|
|
|
3164
|
|
|
3165 /* ACI-SPR-18200: - this event is not completely implemented
|
|
|
3166 "Not supported" stated in TERMINAL PROFILE */
|
|
|
3167 #if 0
|
|
|
3168 case SatEvtBrowserTermination:
|
|
|
3169 if (eventList & SatEvtBrowserTerminateActivated)
|
|
|
3170 {
|
|
|
3171 /*
|
|
|
3172 ** CQ 16435 : This can only have happend if this event is listed more than one
|
|
|
3173 ** which is invalid and causes a reject!
|
|
|
3174 */
|
|
|
3175 eventList = 0;
|
|
|
3176 satResponse(SatResImpossible);
|
|
|
3177 return 0;
|
|
|
3178 }
|
|
|
3179 else
|
|
|
3180 {
|
|
|
3181 eventList|= SatEvtBrowserTerminateActivated;
|
|
|
3182 *ep |= *curVal; /* event list element */
|
|
|
3183 cmd.c.events.len++; /* number of events */
|
|
|
3184 }
|
|
|
3185 break;
|
|
|
3186 #endif
|
|
|
3187 default:
|
|
|
3188 /* CQ16435 : If there is an unsupported event, then the entire list fails,
|
|
|
3189 ** reset the eventList to zero and return the response "Beyond ME Capabilities"
|
|
|
3190 */
|
|
|
3191 eventList = 0;
|
|
|
3192 satResponse(SatResImpossible);
|
|
|
3193 return 0;
|
|
|
3194 }
|
|
|
3195 curVal++;
|
|
|
3196 }
|
|
|
3197
|
|
|
3198 sat_res[0] = SatResSuccess; /*Terminal response always sent if there are elements */
|
|
|
3199 sat_res[1] = SatResAiNoCause; /* even if they are not MMI */
|
|
|
3200 TRACE_EVENT_P1("MFW event list %x",eventList);
|
|
|
3201 satDone(&cmd, (U8*)&sat_res, sizeof(sat_res));
|
|
|
3202 }
|
|
|
3203 else
|
|
|
3204 {
|
|
|
3205 satResponse(SatResUnknownData);
|
|
|
3206 return 0; /* no event list found */
|
|
|
3207 }
|
|
|
3208 return MfwSatSetEvents;
|
|
|
3209 }
|
|
|
3210
|
|
|
3211
|
|
|
3212 /*
|
|
|
3213 +--------------------------------------------------------------------+
|
|
|
3214 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3215 | STATE : code ROUTINE : decIdleText |
|
|
|
3216 +--------------------------------------------------------------------+
|
|
|
3217
|
|
|
3218 PURPOSE : decode command: setup idle mode text
|
|
|
3219
|
|
|
3220 */
|
|
|
3221
|
|
|
3222 static U32 decIdleText (void)
|
|
|
3223 {
|
|
|
3224 TRACE_FUNCTION("decIdleText()");
|
|
|
3225
|
|
|
3226 while (curCmdLen > 0)
|
|
|
3227 {
|
|
|
3228 if (!decDevId(1))
|
|
|
3229 return 0;
|
|
|
3230
|
|
|
3231 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
3232 break; /* success */
|
|
|
3233
|
|
|
3234 TRACE_ERROR("illegal device combination");
|
|
|
3235 if (curCR)
|
|
|
3236 {
|
|
|
3237 satResponse(SatResUnknownData);
|
|
|
3238 return 0;
|
|
|
3239 }
|
|
|
3240 partialCompr = 1;
|
|
|
3241 }
|
|
|
3242 if (!decText(&cmd.c.text,0x0D,1))
|
|
|
3243 return 0;
|
|
|
3244
|
|
|
3245 if (!decIconId(&cmd.c.text.icon,0))
|
|
|
3246 return 0;
|
|
|
3247
|
|
|
3248 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
3249 #ifdef FF_MMI_SAT_ICON
|
|
|
3250 /* Check if the icon data is present & needs to be read*/
|
|
|
3251 if (cmd.c.text.icon.qual != 0xFF)
|
|
|
3252 {
|
|
|
3253 /* Initialise the icon data members*/
|
|
|
3254 cmd.c.text.iconInfo.width = 0;
|
|
|
3255 cmd.c.text.iconInfo.height = 0;
|
|
|
3256 cmd.c.text.iconInfo.dst = NULL;
|
|
|
3257 simReadIconData(cmd.c.text.icon.id);
|
|
|
3258 }
|
|
|
3259 #endif
|
|
|
3260 return MfwSatIdleText;
|
|
|
3261 }
|
|
|
3262
|
|
|
3263 /*
|
|
|
3264 +--------------------------------------------------------------------+
|
|
|
3265 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3266 | STATE : code ROUTINE : decOpenChannel |
|
|
|
3267 +--------------------------------------------------------------------+
|
|
|
3268
|
|
|
3269 PURPOSE : decode command: open channel
|
|
|
3270
|
|
|
3271 */
|
|
|
3272
|
|
|
3273 static U32 decOpenChannel (void)
|
|
|
3274 {
|
|
|
3275 SatAddress addr;
|
|
|
3276 SatData subaddr;
|
|
|
3277
|
|
|
3278 TRACE_FUNCTION("decOpenChannel()");
|
|
|
3279
|
|
|
3280 while (curCmdLen > 0)
|
|
|
3281 {
|
|
|
3282 if (!decDevId(1))
|
|
|
3283 return 0;
|
|
|
3284
|
|
|
3285 if (cmd.source == SatDevSIM && cmd.dest == SatDevME)
|
|
|
3286 break; /* success */
|
|
|
3287
|
|
|
3288 TRACE_ERROR("illegal device combination");
|
|
|
3289 if (curCR)
|
|
|
3290 {
|
|
|
3291 satResponse(SatResUnknownData);
|
|
|
3292 return 0;
|
|
|
3293 }
|
|
|
3294 partialCompr = 1;
|
|
|
3295 }
|
|
|
3296
|
|
|
3297 /* Decode alpha idenitifier if present */
|
|
|
3298 cmd.c.open.alpha_id.code = 0; /* set default values */
|
|
|
3299 cmd.c.open.alpha_id.len = -1; /* optional info if absent */
|
|
|
3300 cmd.c.open.alpha_id.text = 0;
|
|
|
3301 if (!decAlpha(&cmd.c.open.alpha_id,0))
|
|
|
3302 return 0;
|
|
|
3303
|
|
|
3304 /* Decode icon identifier if present */
|
|
|
3305 if (!decIconId(&cmd.c.open.alpha_id.icon,0))
|
|
|
3306 return 0;
|
|
|
3307
|
|
|
3308 /* Decode address if present */
|
|
|
3309 /* If address is present then channel type is CSD */
|
|
|
3310 addr.ton = 0; /* set default values */
|
|
|
3311 addr.len = 0;
|
|
|
3312 addr.number = 0;
|
|
|
3313 if (!decAddrSS(&addr,0x06,0))
|
|
|
3314 return 0;
|
|
|
3315
|
|
|
3316 /* Decode subaddress if present */
|
|
|
3317 subaddr.len = 0;
|
|
|
3318 subaddr.data = 0;
|
|
|
3319 if (!decData(&subaddr,0x08,0))
|
|
|
3320 return 0;
|
|
|
3321
|
|
|
3322 /* Decode duration 1 if present */
|
|
|
3323 cmd.c.open.dur1Unit = 0; /* set default values */
|
|
|
3324 cmd.c.open.dur1Value = 0;
|
|
|
3325 if (!decDuration(&cmd.c.open.dur1Unit,0)) /* redial timing */
|
|
|
3326 return 0;
|
|
|
3327
|
|
|
3328 /* Decode duration 2 if present */
|
|
|
3329 cmd.c.open.dur2Unit = 0; /* set default values */
|
|
|
3330 cmd.c.open.dur2Value = 0;
|
|
|
3331 if (!decDuration(&cmd.c.open.dur2Unit,0)) /* redial timing */
|
|
|
3332 return 0;
|
|
|
3333
|
|
|
3334 return MfwSatOpenChannel;
|
|
|
3335
|
|
|
3336 }
|
|
|
3337
|
|
|
3338 /*
|
|
|
3339 +--------------------------------------------------------------------+
|
|
|
3340 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3341 | STATE : code ROUTINE : decCloseChannel |
|
|
|
3342 +--------------------------------------------------------------------+
|
|
|
3343
|
|
|
3344 PURPOSE : decode command: close channel
|
|
|
3345
|
|
|
3346 */
|
|
|
3347
|
|
|
3348 static U32 decCloseChannel (void)
|
|
|
3349 {
|
|
|
3350
|
|
|
3351 U8 alpha_res;
|
|
|
3352
|
|
|
3353 TRACE_FUNCTION("decCloseChannel()");
|
|
|
3354
|
|
|
3355 while (curCmdLen > 0)
|
|
|
3356 {
|
|
|
3357 if (!decDevId(1))
|
|
|
3358 return 0;
|
|
|
3359
|
|
|
3360 /* SPR#2321 - DS - Compare with correct SAT Class E device identities */
|
|
|
3361 if ( (cmd.source == SatDevSIM && cmd.dest == SatDevCh1) ||
|
|
|
3362 (cmd.source == SatDevSIM && cmd.dest == SatDevCh2) ||
|
|
|
3363 (cmd.source == SatDevSIM && cmd.dest == SatDevCh3) ||
|
|
|
3364 (cmd.source == SatDevSIM && cmd.dest == SatDevCh4) ||
|
|
|
3365 (cmd.source == SatDevSIM && cmd.dest == SatDevCh5) ||
|
|
|
3366 (cmd.source == SatDevSIM && cmd.dest == SatDevCh6) ||
|
|
|
3367 (cmd.source == SatDevSIM && cmd.dest == SatDevCh7) )
|
|
|
3368 break; /* success */
|
|
|
3369
|
|
|
3370 TRACE_ERROR("illegal device combination");
|
|
|
3371 if (curCR)
|
|
|
3372 {
|
|
|
3373 satResponse(SatResUnknownData);
|
|
|
3374 return 0;
|
|
|
3375 }
|
|
|
3376 partialCompr = 1;
|
|
|
3377 }
|
|
|
3378
|
|
|
3379 /* Decode alpha identifier if present */
|
|
|
3380 cmd.c.close.alpha_id.code = 0; /* set default values */
|
|
|
3381 cmd.c.close.alpha_id.len = -1; /* optional info if absent */
|
|
|
3382 cmd.c.close.alpha_id.text = 0;
|
|
|
3383
|
|
|
3384 if (!decAlpha(&cmd.c.close.alpha_id,0))
|
|
|
3385 return 0;
|
|
|
3386
|
|
|
3387 /* Decode icon identifier if present */
|
|
|
3388 if (!decIconId(&cmd.c.close.alpha_id.icon,0))
|
|
|
3389 return 0;
|
|
|
3390
|
|
|
3391 return MfwSatCloseChannel;
|
|
|
3392
|
|
|
3393 }
|
|
|
3394
|
|
|
3395 /*
|
|
|
3396 +--------------------------------------------------------------------+
|
|
|
3397 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3398 | STATE : code ROUTINE : decSendData |
|
|
|
3399 +--------------------------------------------------------------------+
|
|
|
3400
|
|
|
3401 PURPOSE : decode command: send data
|
|
|
3402
|
|
|
3403 */
|
|
|
3404
|
|
|
3405 static U32 decSendData (void)
|
|
|
3406 {
|
|
|
3407 TRACE_FUNCTION("decSendData()");
|
|
|
3408
|
|
|
3409 while (curCmdLen > 0)
|
|
|
3410 {
|
|
|
3411 if (!decDevId(1))
|
|
|
3412 return 0;
|
|
|
3413
|
|
|
3414 /* SPR#2321 - DS - Compare with correct SAT Class E device identities */
|
|
|
3415 if ( (cmd.source == SatDevSIM && cmd.dest == SatDevCh1) ||
|
|
|
3416 (cmd.source == SatDevSIM && cmd.dest == SatDevCh2) ||
|
|
|
3417 (cmd.source == SatDevSIM && cmd.dest == SatDevCh3) ||
|
|
|
3418 (cmd.source == SatDevSIM && cmd.dest == SatDevCh4) ||
|
|
|
3419 (cmd.source == SatDevSIM && cmd.dest == SatDevCh5) ||
|
|
|
3420 (cmd.source == SatDevSIM && cmd.dest == SatDevCh6) ||
|
|
|
3421 (cmd.source == SatDevSIM && cmd.dest == SatDevCh7) )
|
|
|
3422 break; /* success */
|
|
|
3423
|
|
|
3424 TRACE_ERROR("illegal device combination");
|
|
|
3425 if (curCR)
|
|
|
3426 {
|
|
|
3427 satResponse(SatResUnknownData);
|
|
|
3428 return 0;
|
|
|
3429 }
|
|
|
3430 partialCompr = 1;
|
|
|
3431 }
|
|
|
3432
|
|
|
3433 /* Decode alpha identifier if present */
|
|
|
3434 cmd.c.send.alpha_id.code = 0; /* set default values */
|
|
|
3435 cmd.c.send.alpha_id.len = -1; /* optional info if absent */
|
|
|
3436 cmd.c.send.alpha_id.text = 0;
|
|
|
3437
|
|
|
3438 if (!decAlpha(&cmd.c.send.alpha_id,0))
|
|
|
3439 return 0;
|
|
|
3440
|
|
|
3441 /* Decode icon identifier if present */
|
|
|
3442 if (!decIconId(&cmd.c.send.alpha_id.icon,0))
|
|
|
3443 return 0;
|
|
|
3444
|
|
|
3445 return MfwSatSendData;
|
|
|
3446
|
|
|
3447 }
|
|
|
3448
|
|
|
3449 /*
|
|
|
3450 +--------------------------------------------------------------------+
|
|
|
3451 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3452 | STATE : code ROUTINE : decRecvData |
|
|
|
3453 +--------------------------------------------------------------------+
|
|
|
3454
|
|
|
3455 PURPOSE : decode command: receive data
|
|
|
3456
|
|
|
3457 */
|
|
|
3458
|
|
|
3459 static U32 decRecvData (void)
|
|
|
3460 {
|
|
|
3461 TRACE_FUNCTION("decRecvData()");
|
|
|
3462
|
|
|
3463 while (curCmdLen > 0)
|
|
|
3464 {
|
|
|
3465 if (!decDevId(1))
|
|
|
3466 return 0;
|
|
|
3467
|
|
|
3468 /* SPR#2321 - DS - Compare with correct SAT Class E device identities */
|
|
|
3469 if ( (cmd.source == SatDevSIM && cmd.dest == SatDevCh1) ||
|
|
|
3470 (cmd.source == SatDevSIM && cmd.dest == SatDevCh2) ||
|
|
|
3471 (cmd.source == SatDevSIM && cmd.dest == SatDevCh3) ||
|
|
|
3472 (cmd.source == SatDevSIM && cmd.dest == SatDevCh4) ||
|
|
|
3473 (cmd.source == SatDevSIM && cmd.dest == SatDevCh5) ||
|
|
|
3474 (cmd.source == SatDevSIM && cmd.dest == SatDevCh6) ||
|
|
|
3475 (cmd.source == SatDevSIM && cmd.dest == SatDevCh7) )
|
|
|
3476 break; /* success */
|
|
|
3477
|
|
|
3478 TRACE_ERROR("illegal device combination");
|
|
|
3479 if (curCR)
|
|
|
3480 {
|
|
|
3481 satResponse(SatResUnknownData);
|
|
|
3482 return 0;
|
|
|
3483 }
|
|
|
3484 partialCompr = 1;
|
|
|
3485 }
|
|
|
3486
|
|
|
3487 /* Decode alpha identifier if present */
|
|
|
3488 cmd.c.receive.alpha_id.code = 0; /* set default values */
|
|
|
3489 cmd.c.receive.alpha_id.len = -1; /* optional info if absent */
|
|
|
3490 cmd.c.receive.alpha_id.text = 0;
|
|
|
3491
|
|
|
3492 if (!decAlpha(&cmd.c.send.alpha_id,0))
|
|
|
3493 return 0;
|
|
|
3494
|
|
|
3495 /* Decode icon identifier if present */
|
|
|
3496 if (!decIconId(&cmd.c.receive.alpha_id.icon,0))
|
|
|
3497 return 0;
|
|
|
3498
|
|
|
3499 return MfwSatReceiveData;
|
|
|
3500
|
|
|
3501 }
|
|
|
3502
|
|
|
3503
|
|
|
3504 /*
|
|
|
3505 +--------------------------------------------------------------------+
|
|
|
3506 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3507 | STATE : code ROUTINE : cmdDecode |
|
|
|
3508 +--------------------------------------------------------------------+
|
|
|
3509
|
|
|
3510 PURPOSE : command specific decoding
|
|
|
3511
|
|
|
3512 */
|
|
|
3513
|
|
|
3514 static void cmdDecode (void)
|
|
|
3515 {
|
|
|
3516 U32 evt = 0;
|
|
|
3517 // T_SIM_ACCESS_PARAM sim_read_param;
|
|
|
3518
|
|
|
3519 TRACE_FUNCTION("cmdDecode()");
|
|
|
3520
|
|
|
3521 switch (cmd.type)
|
|
|
3522 {
|
|
|
3523 case SatCmdDispText: evt = decDispText(); break;
|
|
|
3524 case SatCmdGetKey: evt = decGetKey(); break;
|
|
|
3525 case SatCmdGetString: evt = decGetString(); break;
|
|
|
3526 case SatCmdPlayTone: evt = decPlayTone(); break;
|
|
|
3527 case SatCmdSetMenu: evt = decSetMenu(); break;
|
|
|
3528 case SatCmdSelItem: evt = decSelItem(); break;
|
|
|
3529 case SatCmdSndSMS: evt = decSndSMS(); break;
|
|
|
3530 case SatCmdSndSS: evt = decSndSS(); break;
|
|
|
3531 case SatCmdSndUSSD: evt = decSndUSSD(); break;
|
|
|
3532 case SatCmdCall: evt = decCall(); break;
|
|
|
3533 case SatCmdRefresh: evt = decRefresh(); break;
|
|
|
3534 case SatCmdEvtList: evt = decSetEvents(); break;
|
|
|
3535 case SatCmdIdleText: evt = decIdleText(); break;
|
|
|
3536 case SatCmdExecAT: evt = decExecAT(); break;
|
|
|
3537 case SatCmdSndDTMF: evt = decSndDTMF(); break;
|
|
|
3538 #if defined(FF_WAP)
|
|
|
3539 case SatCmdLaunchBrowser: break;
|
|
|
3540 #endif
|
|
|
3541
|
|
|
3542 /* SPR#1786 - DS - SAT Class E */
|
|
|
3543 case SatCmdOpenChannel: evt = decOpenChannel(); break;
|
|
|
3544 case SatCmdCloseChannel: evt = decCloseChannel(); break;
|
|
|
3545 case SatCmdSendData: evt = decSendData(); break;
|
|
|
3546 case SatCmdReceiveData: evt = decRecvData(); break;
|
|
|
3547
|
|
|
3548 case SatCmdEOS: evt = MfwSatSessionEnd; break;
|
|
|
3549 default:
|
|
|
3550 TRACE_ERROR("unknown command");
|
|
|
3551 satResponse(SatResUnknownType);
|
|
|
3552 return;
|
|
|
3553 }
|
|
|
3554
|
|
|
3555 if (evt == MfwSatOpenChannel)
|
|
|
3556 {
|
|
|
3557 /* SPR#2321 - DS - Store command details so rAT_PercentSATA
|
|
|
3558 * can send the correct command details for Open Channel.
|
|
|
3559 */
|
|
|
3560 sat_cmd_saved = (SatCmd*)mfwAlloc(sizeof(SatCmd));
|
|
|
3561
|
|
|
3562 if (sat_cmd_saved != NULL)
|
|
|
3563 {
|
|
|
3564 TRACE_EVENT("Save Open Channel command details");
|
|
|
3565 memcpy(sat_cmd_saved, &cmd, sizeof(cmd));
|
|
|
3566 }
|
|
|
3567
|
|
|
3568 /* Event is sent from rAT_PercentSATA */
|
|
|
3569
|
|
|
3570 return;
|
|
|
3571 }
|
|
|
3572 // Shashi Shekar B.S., a0876501, Jan 16, 2006, DR: OMAPS00061460
|
|
|
3573 #ifdef FF_MMI_SAT_ICON
|
|
|
3574 curSATCmd = evt; /* Keep a current copy of the command */
|
|
|
3575
|
|
|
3576 if (evt && !isAlphaIdIconPresent)
|
|
|
3577 satSignal(evt,&cmd);
|
|
|
3578 #else
|
|
|
3579 if (evt)
|
|
|
3580 satSignal(evt,&cmd);
|
|
|
3581 #endif
|
|
|
3582
|
|
|
3583 return;
|
|
|
3584 }
|
|
|
3585
|
|
|
3586
|
|
|
3587 /*
|
|
|
3588 +--------------------------------------------------------------------+
|
|
|
3589 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3590 | STATE : code ROUTINE : rAT_PercentSATI |
|
|
|
3591 +--------------------------------------------------------------------+
|
|
|
3592
|
|
|
3593 PURPOSE : called by ACI for SIM Toolkit command
|
|
|
3594
|
|
|
3595 */
|
|
|
3596
|
|
|
3597 void rAT_PercentSATI (S16 len, U8 *sc)
|
|
|
3598 {
|
|
|
3599 U8 tl;
|
|
|
3600
|
|
|
3601 TRACE_FUNCTION("rAT_PercentSATI()");
|
|
|
3602
|
|
|
3603 if (len <= 0) /* empty command? */
|
|
|
3604 {
|
|
|
3605 cmd.number = 0; /* virtual command */
|
|
|
3606 cmd.type = SatCmdEOS; /* terminate session */
|
|
|
3607 cmd.qual = 0;
|
|
|
3608 cmd.source = SatDevSIM;
|
|
|
3609 cmd.dest = SatDevME;
|
|
|
3610 cmdDecode();
|
|
|
3611 return;
|
|
|
3612 }
|
|
|
3613
|
|
|
3614 if (!sc || *sc != 0xD0)
|
|
|
3615 { /* no proactive SIM command */
|
|
|
3616 TRACE_ERROR("no SAT command"); /* ignore message */
|
|
|
3617 return;
|
|
|
3618 }
|
|
|
3619
|
|
|
3620 curCmd = sc;
|
|
|
3621 curCmdLen = len;
|
|
|
3622 curData = (U8 *) &cmd + sizeof(SatCmd);/* end of command buffer */
|
|
|
3623 *(curData - 1) = 0x07;
|
|
|
3624 tl = getTLValue(sc);
|
|
|
3625 if (!tl) /* length error */
|
|
|
3626 return; /* ignore message */
|
|
|
3627
|
|
|
3628 curCmd += tl;
|
|
|
3629 curCmdLen -= tl;
|
|
|
3630 if (curCmdLen < curLen) /* not enough data */
|
|
|
3631 {
|
|
|
3632 TRACE_ERROR("not enough data");
|
|
|
3633 satResponse(SatResUnknownData); /* not understood by ME */
|
|
|
3634 return;
|
|
|
3635 }
|
|
|
3636 if (curCmdLen > curLen) /* more data than needed: */
|
|
|
3637 curCmdLen = curLen; /* ignore the rest */
|
|
|
3638
|
|
|
3639 partialCompr = 0; /* partial comprehen. flag */
|
|
|
3640 while (curCmdLen > 0)
|
|
|
3641 {
|
|
|
3642 tl = getTLValue(curCmd);
|
|
|
3643 if (!tl)
|
|
|
3644 return;
|
|
|
3645 curCmd += tl;
|
|
|
3646 curCmdLen -= tl;
|
|
|
3647 if (curTag == 0x01) /* command details */
|
|
|
3648 {
|
|
|
3649 cmd.number = *(curCmd+0); /* transaction number */
|
|
|
3650 cmd.type = *(curCmd+1); /* command ID */
|
|
|
3651 cmd.qual = *(curCmd+2); /* command qualifier */
|
|
|
3652 if (cmd.number == 0x00 || cmd.number == 0xFF)
|
|
|
3653 {
|
|
|
3654 TRACE_ERROR("invalid command number");
|
|
|
3655 satResponse(SatResUnknownData);
|
|
|
3656 }
|
|
|
3657 /*SPR#2121 - DS - Copy command specific details into global buffer defCmdDetails */
|
|
|
3658 memcpy(defCmdDetails, curCmd-2, 5);
|
|
|
3659
|
|
|
3660 curCmd += curLen;
|
|
|
3661 curCmdLen -= curLen; /* length of value bytes */
|
|
|
3662 cmdDecode(); /* do specific decoding */
|
|
|
3663 return;
|
|
|
3664 }
|
|
|
3665 TRACE_ERROR("no command details");
|
|
|
3666 if (curCR)
|
|
|
3667 {
|
|
|
3668 satResponse(SatResUnknownData);
|
|
|
3669 return;
|
|
|
3670 }
|
|
|
3671 curCmd += curLen;
|
|
|
3672 curCmdLen -= curLen;
|
|
|
3673 partialCompr = 1;
|
|
|
3674 }
|
|
|
3675 satResponse(SatResNoValues);
|
|
|
3676 }
|
|
|
3677
|
|
|
3678
|
|
|
3679 /*
|
|
|
3680 +--------------------------------------------------------------------+
|
|
|
3681 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3682 | STATE : code ROUTINE : rAT_PercentSATN |
|
|
|
3683 +--------------------------------------------------------------------+
|
|
|
3684
|
|
|
3685 PURPOSE : Notification by ACI on notifications for SAT commands
|
|
|
3686
|
|
|
3687 */
|
|
|
3688
|
|
|
3689 /* BEGIN ADD: Sumit : Req ID: : 31-Mar-2005*/
|
|
|
3690 #ifndef NEPTUNE_BOARD
|
|
|
3691 /* END ADD: Sumit : Req ID: : 31-Mar-2005*/
|
|
|
3692 void rAT_PercentSATN (S16 len, U8 *sc, T_ACI_SATN_CNTRL_TYPE cntrl_type)
|
|
|
3693 /* BEGIN ADD: Sumit : Req ID: : 31-Mar-2005*/
|
|
|
3694 #else
|
|
|
3695 void rAT_PercentSATN ( SHORT len,UBYTE *sc)
|
|
|
3696 #endif
|
|
|
3697 /* END ADD: Sumit : Req ID: : 31-Mar-2005*/
|
|
|
3698 {
|
|
|
3699 U8 tl;
|
|
|
3700 U32 evt = 0;
|
|
|
3701
|
|
|
3702 TRACE_FUNCTION("rAT_PercentSATN()");
|
|
|
3703
|
|
|
3704 if (len <= 0 || !sc) /* empty command? */
|
|
|
3705 {
|
|
|
3706 TRACE_ERROR("empty SATN!");
|
|
|
3707 #if 0
|
|
|
3708 // ES!! simulate CC result: not modified ??
|
|
|
3709 sc = (U8*) &evt; /* temporary misuse... */
|
|
|
3710 len = 2;
|
|
|
3711 #else
|
|
|
3712 // ES!! or ignore it ??
|
|
|
3713 return;
|
|
|
3714 #endif
|
|
|
3715 }
|
|
|
3716 if (*sc == 0xD0)
|
|
|
3717 {
|
|
|
3718 satNoResponse = 1;
|
|
|
3719 rAT_PercentSATI(len,sc); /* normal processing */
|
|
|
3720 satNoResponse = 0;
|
|
|
3721 return;
|
|
|
3722 }
|
|
|
3723
|
|
|
3724 curCmd = sc;
|
|
|
3725 curCmdLen = len;
|
|
|
3726 curData = (U8 *) &cmd + sizeof(SatCmd);/* end of command buffer */
|
|
|
3727
|
|
|
3728 switch (*sc)
|
|
|
3729 {
|
|
|
3730 case 0x00: /* CC: allowed, not mod. */
|
|
|
3731 case 0x01: /* CC: not allowed */
|
|
|
3732 case 0x02: /* CC: allowed, modified */
|
|
|
3733 partialCompr = 0; /* partial comprehen. flag */
|
|
|
3734 cmd.c.ccres.result = *sc;
|
|
|
3735 tl = getTLValue(sc);
|
|
|
3736 if (!tl) /* length error */
|
|
|
3737 return; /* ignore message */
|
|
|
3738 curCmd += tl;
|
|
|
3739 curCmdLen -= tl;
|
|
|
3740 if (curCmdLen < curLen) /* not enough data */
|
|
|
3741 {
|
|
|
3742 TRACE_ERROR("SATN: not enough data (ignored).");
|
|
|
3743 return;
|
|
|
3744 }
|
|
|
3745 if (curCmdLen > curLen) /* more data than needed: */
|
|
|
3746 curCmdLen = curLen; /* ignore the rest */
|
|
|
3747 evt = decCcRes();
|
|
|
3748 if (evt)
|
|
|
3749 satSignal(evt,&cmd);
|
|
|
3750 break;
|
|
|
3751 case 0x81:
|
|
|
3752 TRACE_EVENT("SATN: ACI terminal response (ignored).");
|
|
|
3753 break;
|
|
|
3754 default:
|
|
|
3755 TRACE_EVENT("SATN: unknown header (ignored).");
|
|
|
3756 break;
|
|
|
3757 }
|
|
|
3758 }
|
|
|
3759
|
|
|
3760
|
|
|
3761 /*
|
|
|
3762 +--------------------------------------------------------------------+
|
|
|
3763 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3764 | STATE : code ROUTINE : rAT_PercentSATA |
|
|
|
3765 +--------------------------------------------------------------------+
|
|
|
3766
|
|
|
3767 PURPOSE : Alert indication by ACI for SAT commands
|
|
|
3768
|
|
|
3769 */
|
|
|
3770 #ifdef FF_SAT_E
|
|
|
3771 void rAT_PercentSATA (S16 cId, S32 rdlTimeout_ms,T_ACI_SATA_ADD *addParm)
|
|
|
3772 #else
|
|
|
3773 void rAT_PercentSATA (S16 cId, S32 rdlTimeout_ms)
|
|
|
3774 #endif /* FF_SAT_E */
|
|
|
3775 {
|
|
|
3776 TRACE_FUNCTION("rAT_PercentSATA()");
|
|
|
3777
|
|
|
3778 TRACE_EVENT_P1("Redial Time %d",rdlTimeout_ms);
|
|
|
3779
|
|
|
3780 /* Store call details */
|
|
|
3781 cmd.c.ccres.redialTime = rdlTimeout_ms;
|
|
|
3782 cmd.c.ccres.callId = cId;
|
|
|
3783
|
|
|
3784 if (rdlTimeout_ms > 0) /* Check timeout value is valid */
|
|
|
3785 {
|
|
|
3786 cm_set_redial(CM_REDIAL_AUTO);
|
|
|
3787 }
|
|
|
3788 #ifdef FF_SAT_E
|
|
|
3789 /* No Channel information available, therefore treat as normal Voice call */
|
|
|
3790 if (addParm == NULL)
|
|
|
3791 {
|
|
|
3792 #endif /* FF_SAT_E */
|
|
|
3793 //x0035544 Mar 11, 2006. DR:OMAPS00061467
|
|
|
3794 //unless SAT_SETUP_CALL event is executed, dont send MfwSatCcAlert event to BMI
|
|
|
3795 #ifdef FF_MMI_SAT_ICON
|
|
|
3796 if(isAlphaIdIconPresent )
|
|
|
3797 {
|
|
|
3798 setupCall_Executed = TRUE;
|
|
|
3799 }
|
|
|
3800 else
|
|
|
3801 satSignal(MfwSatCcAlert,&cmd);
|
|
|
3802 #else
|
|
|
3803 satSignal(MfwSatCcAlert,&cmd);
|
|
|
3804 #endif
|
|
|
3805 return;
|
|
|
3806
|
|
|
3807 #ifdef FF_SAT_E
|
|
|
3808 }
|
|
|
3809 else /* Store channel information in command structure */
|
|
|
3810 {
|
|
|
3811 cmd.c.open.channel_type = (T_MFW_SAT_CHN)addParm->chnType;
|
|
|
3812 cmd.c.open.establishment_type = (T_MFW_SAT_EST)addParm->chnEst;
|
|
|
3813 }
|
|
|
3814
|
|
|
3815 /* Determine Channel type and send approriate event to BMI */
|
|
|
3816 switch (addParm->chnType)
|
|
|
3817 {
|
|
|
3818 case MFW_SAT_CHN_NONE:
|
|
|
3819 case MFW_SAT_CHN_VOICE:
|
|
|
3820 satSignal(MfwSatCcAlert,&cmd);
|
|
|
3821 break;
|
|
|
3822 case MFW_SAT_CHN_CSD:
|
|
|
3823 case MFW_SAT_CHN_GPRS:
|
|
|
3824
|
|
|
3825 /* SPR#2321 - DS - Copy the saved Open Channel details to cmd in case a Call
|
|
|
3826 * Control result command was received (therefore overwriting the Open Channel
|
|
|
3827 * data) between the original MfwSatOpenChannel command and this alert indication
|
|
|
3828 */
|
|
|
3829 if (sat_cmd_saved != NULL)
|
|
|
3830 {
|
|
|
3831 TRACE_EVENT("Copy the saved Open Channel details to the cmd structure");
|
|
|
3832 memcpy(&cmd, sat_cmd_saved, sizeof(SatCmd)); /* SPR#2340 - DS - Copy full structure */
|
|
|
3833
|
|
|
3834 /* Deallocate saved Open Channel command details */
|
|
|
3835 if (sat_cmd_saved)
|
|
|
3836 {
|
|
|
3837 TRACE_EVENT("Deallocate sat_cmd_saved");
|
|
|
3838 mfwFree((U8*)sat_cmd_saved, sizeof(SatCmd));
|
|
|
3839 sat_cmd_saved = NULL;
|
|
|
3840 }
|
|
|
3841 }
|
|
|
3842 TRACE_EVENT("satSignal(MfwSatOpenChannel, &cmd)");
|
|
|
3843 satSignal(MfwSatOpenChannel, &cmd);
|
|
|
3844 break;
|
|
|
3845 default:
|
|
|
3846 TRACE_ERROR("Error with SATA channle type!");
|
|
|
3847 break;
|
|
|
3848 }
|
|
|
3849 #endif /* FF_SAT_E */
|
|
|
3850 }
|
|
|
3851
|
|
|
3852
|
|
|
3853 /*
|
|
|
3854 +--------------------------------------------------------------------+
|
|
|
3855 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3856 | STATE : code ROUTINE : rAT_PercentSATE |
|
|
|
3857 +--------------------------------------------------------------------+
|
|
|
3858
|
|
|
3859 PURPOSE : called by ACI on response for Envelope commands
|
|
|
3860
|
|
|
3861 */
|
|
|
3862
|
|
|
3863 void rAT_PercentSATE (S16 len, U8 *res)
|
|
|
3864 {
|
|
|
3865 TRACE_FUNCTION("rAT_PercentSATE()"); //ES!! FOR WHAT ??
|
|
|
3866 }
|
|
|
3867
|
|
|
3868
|
|
|
3869 /*
|
|
|
3870 +--------------------------------------------------------------------+
|
|
|
3871 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3872 | STATE : code ROUTINE : rAT_PercentSATBROW |
|
|
|
3873 +--------------------------------------------------------------------+
|
|
|
3874
|
|
|
3875 PURPOSE : called by ACI when the SAT Browser command arrives.
|
|
|
3876
|
|
|
3877 */
|
|
|
3878
|
|
|
3879 #if defined(FF_WAP)
|
|
|
3880
|
|
|
3881 void rAT_PercentSATBROW (T_LAUNCH_BROWSER *browser_command) //To be change to T_LAUNCH_BROWSER
|
|
|
3882 {
|
|
|
3883 int i;
|
|
|
3884 T_prov_file_ref* current_prov_file;
|
|
|
3885
|
|
|
3886 TRACE_FUNCTION("rAT_PercentSATBROW()");
|
|
|
3887
|
|
|
3888 cmd.c.browser.identity = browser_command->browser_id.browser;
|
|
|
3889 cmd.c.browser.url = (U8*) browser_command->url.url_value;
|
|
|
3890 cmd.c.browser.n_bearer = browser_command->c_bearer;
|
|
|
3891 cmd.c.browser.bearer = (U8*)browser_command->bearer;
|
|
|
3892 cmd.c.browser.n_prov_file_ref = browser_command->c_prov_file_ref;
|
|
|
3893 for (i=0;(i<browser_command->c_prov_file_ref) && (i<MFW_MAX_PFP_ELEM);i++)
|
|
|
3894 {
|
|
|
3895 current_prov_file = browser_command->prov_file_ref;
|
|
|
3896 cmd.c.browser.prov_file_ref[i].prov_file_id_len = current_prov_file->c_prov_file_id;
|
|
|
3897 cmd.c.browser.prov_file_ref[i].prov_file_id = (U8*)current_prov_file->prov_file_id;
|
|
|
3898 current_prov_file++;
|
|
|
3899 }
|
|
|
3900 cmd.c.browser.text_string.icon.qual = browser_command->icon.icon_qu;
|
|
|
3901 cmd.c.browser.text_string.icon.id = browser_command->icon.icon_id;
|
|
|
3902 /* Copy the text string into the cmd buffer */
|
|
|
3903 {
|
|
|
3904 U8 *provPointer;
|
|
|
3905 provPointer = (U8 *) &cmd + sizeof(SatCmd);/* end of command buffer */
|
|
|
3906 provPointer -= browser_command->text.c_text_str; /*Substract length of the text */
|
|
|
3907 memcpy(provPointer,browser_command->text.text_str,browser_command->text.c_text_str);/*Copies text*/
|
|
|
3908 cmd.c.browser.text_string.text = (U16) (provPointer - (U8*)&cmd.c.browser.text_string);/*Stores the offset */
|
|
|
3909 cmd.c.browser.text_string.len = browser_command->text.c_text_str;
|
|
|
3910 cmd.c.browser.text_string.code = browser_command->text.dcs;
|
|
|
3911 }
|
|
|
3912 /* Copy the alpha id */
|
|
|
3913 cmd.c.browser.alpha_len = browser_command->c_alpha_id;
|
|
|
3914 cmd.c.browser.alpha_id = (U8*)browser_command->alpha_id;
|
|
|
3915
|
|
|
3916
|
|
|
3917 satSignal(MfwSatLaunchBrowser, &cmd); /*Send the event to MMI */
|
|
|
3918
|
|
|
3919
|
|
|
3920 }
|
|
|
3921
|
|
|
3922 #endif
|
|
|
3923
|
|
|
3924 // Aug 31, 2005 REF: CRR 33619 x0021334
|
|
|
3925 // Description: RE: Notification of SATK File Change
|
|
|
3926 // Solution: Added stub function 'rAT_PercentSIMEF()'
|
|
|
3927 /*
|
|
|
3928 +--------------------------------------------------------------------+
|
|
|
3929 | PROJECT : MMI-Framework MODULE : MFW_SAT |
|
|
|
3930 | STATE : code ROUTINE : rAT_PercentSIMEF |
|
|
|
3931 +--------------------------------------------------------------------+
|
|
|
3932
|
|
|
3933 PURPOSE : handles rAT_PercentSIMEF call back
|
|
|
3934 */
|
|
|
3935 void rAT_PercentSIMEF (SHORT *ef, UBYTE count)
|
|
|
3936 {
|
|
|
3937 TRACE_FUNCTION ("rAT_PercentSIMEF()");
|
|
|
3938 }
|
|
|
3939
|
|
|
3940 /*
|
|
|
3941 +--------------------------------------------------------------------+
|
|
|
3942 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3943 | STATE : code ROUTINE : satAccept |
|
|
|
3944 +--------------------------------------------------------------------+
|
|
|
3945
|
|
|
3946 PURPOSE : accept SIM initiated connection
|
|
|
3947
|
|
|
3948 */
|
|
|
3949
|
|
|
3950 void satAccept (void)
|
|
|
3951 {
|
|
|
3952 T_ACI_RETURN res;
|
|
|
3953
|
|
|
3954 TRACE_FUNCTION("satAccept()");
|
|
|
3955
|
|
|
3956 mfwSatMoAccepted = 1;
|
|
|
3957 res = sAT_A(CMD_SRC_LCL);
|
|
|
3958 if (res != AT_EXCT && res != AT_CMPL)
|
|
|
3959 {
|
|
|
3960 TRACE_ERROR("satAccept() error");
|
|
|
3961 mfwSatMoAccepted = 0;
|
|
|
3962 }
|
|
|
3963
|
|
|
3964 return;
|
|
|
3965 }
|
|
|
3966
|
|
|
3967
|
|
|
3968 /*
|
|
|
3969 +--------------------------------------------------------------------+
|
|
|
3970 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3971 | STATE : code ROUTINE : satReject |
|
|
|
3972 +--------------------------------------------------------------------+
|
|
|
3973
|
|
|
3974 PURPOSE : reject SIM initiated connection
|
|
|
3975
|
|
|
3976 */
|
|
|
3977
|
|
|
3978 void satReject (void)
|
|
|
3979 {
|
|
|
3980 T_ACI_RETURN res;
|
|
|
3981
|
|
|
3982 TRACE_FUNCTION("satReject()");
|
|
|
3983
|
|
|
3984 res = sAT_H(CMD_SRC_LCL);
|
|
|
3985 if (res != AT_EXCT && res != AT_CMPL)
|
|
|
3986 TRACE_ERROR("satReject() error");
|
|
|
3987
|
|
|
3988 return;
|
|
|
3989 }
|
|
|
3990
|
|
|
3991
|
|
|
3992 /*
|
|
|
3993 +--------------------------------------------------------------------+
|
|
|
3994 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
3995 | STATE : code ROUTINE : satDisc |
|
|
|
3996 +--------------------------------------------------------------------+
|
|
|
3997
|
|
|
3998 PURPOSE : disconnect SIM initiated connection
|
|
|
3999
|
|
|
4000 */
|
|
|
4001
|
|
|
4002 void satDisc (void)
|
|
|
4003 {
|
|
|
4004 T_ACI_RETURN res;
|
|
|
4005
|
|
|
4006 TRACE_FUNCTION("satDisc()");
|
|
|
4007
|
|
|
4008 res = sAT_Abort(CMD_SRC_LCL,AT_CMD_A);
|
|
|
4009 if (res != AT_EXCT && res != AT_CMPL)
|
|
|
4010 TRACE_ERROR("satDisc() error");
|
|
|
4011
|
|
|
4012 return;
|
|
|
4013 }
|
|
|
4014
|
|
|
4015 /*
|
|
|
4016 +--------------------------------------------------------------------+
|
|
|
4017 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
4018 | STATE : code ROUTINE : satChangeNotify |
|
|
|
4019 +--------------------------------------------------------------------+
|
|
|
4020
|
|
|
4021 PURPOSE : File change notification
|
|
|
4022
|
|
|
4023 */
|
|
|
4024 #ifdef FF_2TO1_PS
|
|
|
4025 BOOL satChangeNotify ( int ref, T_SIM_FILE_UPDATE_IND *updateInd)
|
|
|
4026 {
|
|
|
4027 int i;
|
|
|
4028 int cnt;
|
|
|
4029 UBYTE f = 0;
|
|
|
4030 U32 evt = 0;
|
|
|
4031
|
|
|
4032 TRACE_FUNCTION ("satChangeNotify ()");
|
|
|
4033
|
|
|
4034
|
|
|
4035 //send a notification to the MMI as well
|
|
|
4036 #ifdef OLD_MFW_SAT_REFRESH
|
|
|
4037 evt = decRefresh(); /* JVJ. This is not sending the proper information!!!!*/
|
|
|
4038 satSignal(evt, &cmd);
|
|
|
4039 #endif
|
|
|
4040
|
|
|
4041
|
|
|
4042
|
|
|
4043 memset ( &udNotify, 0, sizeof(udNotify));
|
|
|
4044 /***************************Go-lite Optimization changes Start***********************/
|
|
|
4045 //Aug 16, 2004 REF: CRR 24323 Deepa M.D
|
|
|
4046 TRACE_EVENT_P5("file_num: %d, files: %x %x %x %x", updateInd->val_nr,
|
|
|
4047 updateInd->file_info[0].datafield, updateInd->file_info[1].datafield,
|
|
|
4048 updateInd->file_info[2].datafield, updateInd->file_info[3].datafield);
|
|
|
4049 /***************************Go-lite Optimization changes END***********************/
|
|
|
4050 fuRef = ref;
|
|
|
4051 cnt = 0;
|
|
|
4052 for (i = 0; i < (int)updateInd->val_nr; i++)
|
|
|
4053 {
|
|
|
4054 if (updateInd->file_info[i].datafield EQ SIM_GID1 OR
|
|
|
4055 updateInd->file_info[i].datafield EQ SIM_GID2 OR
|
|
|
4056 updateInd->file_info[i].datafield EQ SIM_CPHS_CINF OR
|
|
|
4057 updateInd->file_info[i].datafield EQ SIM_SST OR
|
|
|
4058 updateInd->file_info[i].datafield EQ SIM_SMS OR
|
|
|
4059 updateInd->file_info[i].datafield EQ SIM_SPN OR
|
|
|
4060 updateInd->file_info[i].datafield EQ SIM_LP )
|
|
|
4061 {
|
|
|
4062 if (cnt < MFW_MAX_NT_SIZE)
|
|
|
4063 {
|
|
|
4064 udNotify.fields[cnt] = updateInd->file_info[i].datafield;
|
|
|
4065 cnt++;
|
|
|
4066 if (updateInd->file_info[i].datafield EQ SIM_SMS) // bugfix for SIM refresh
|
|
|
4067 sms_busy_ind(); /* When SMS fields will be updated, MFW sends SMS BUSY event to MMI */
|
|
|
4068 }
|
|
|
4069 }
|
|
|
4070 }
|
|
|
4071 udNotify.count = cnt;
|
|
|
4072
|
|
|
4073 if (!cnt)
|
|
|
4074 {
|
|
|
4075 if (fuRef >= 0)
|
|
|
4076 fuRef = -1;
|
|
|
4077 return TRUE;
|
|
|
4078 }
|
|
|
4079
|
|
|
4080 for ( i=0; i < (int)udNotify.count; i++)
|
|
|
4081 {
|
|
|
4082 if ( udNotify.fields[i] EQ SIM_SST )
|
|
|
4083 f = 1;
|
|
|
4084 }
|
|
|
4085
|
|
|
4086 if (udNotify.count)
|
|
|
4087 {
|
|
|
4088 if (f)
|
|
|
4089 {
|
|
|
4090 f = 0;
|
|
|
4091 sim_sat_file_update(SIM_SST);
|
|
|
4092 }
|
|
|
4093 else
|
|
|
4094 satUpdateFiles(FALSE, 0);
|
|
|
4095 }
|
|
|
4096
|
|
|
4097 return FALSE;
|
|
|
4098 }
|
|
|
4099 #else
|
|
|
4100 BOOL satChangeNotify ( int ref, T_SIM_FILE_UPDATE_IND *updateInd)
|
|
|
4101 {
|
|
|
4102 int i;
|
|
|
4103 int cnt;
|
|
|
4104 UBYTE f = 0;
|
|
|
4105 #if(BOARD != 61)
|
|
|
4106 U32 evt = 0;
|
|
|
4107 #endif
|
|
|
4108
|
|
|
4109 TRACE_FUNCTION ("satChangeNotify ()");
|
|
|
4110
|
|
|
4111
|
|
|
4112 //send a notification to the MMI as well
|
|
|
4113 #ifdef OLD_MFW_SAT_REFRESH
|
|
|
4114 evt = decRefresh(); /* JVJ. This is not sending the proper information!!!!*/
|
|
|
4115 satSignal(evt, &cmd);
|
|
|
4116 #endif
|
|
|
4117
|
|
|
4118
|
|
|
4119
|
|
|
4120 memset ( &udNotify, 0, sizeof(udNotify));
|
|
|
4121 /***************************Go-lite Optimization changes Start***********************/
|
|
|
4122 //Aug 16, 2004 REF: CRR 24323 Deepa M.D
|
|
|
4123 TRACE_EVENT_P5("file_num: %d, files: %x %x %x %x", updateInd->val_nr,
|
|
|
4124 updateInd->file_id[0], updateInd->file_id[1],
|
|
|
4125 updateInd->file_id[2], updateInd->file_id[3]);
|
|
|
4126 /***************************Go-lite Optimization changes END***********************/
|
|
|
4127
|
|
|
4128
|
|
|
4129
|
|
|
4130 fuRef = ref;
|
|
|
4131 cnt = 0;
|
|
|
4132 for (i = 0; i < (int)updateInd->val_nr; i++)
|
|
|
4133 {
|
|
|
4134 if (updateInd->file_id[i] EQ SIM_GID1 OR
|
|
|
4135 updateInd->file_id[i] EQ SIM_GID2 OR
|
|
|
4136 updateInd->file_id[i] EQ SIM_CPHS_CINF OR
|
|
|
4137 updateInd->file_id[i] EQ SIM_SST OR
|
|
|
4138 updateInd->file_id[i] EQ SIM_SMS OR
|
|
|
4139 updateInd->file_id[i] EQ SIM_SPN OR
|
|
|
4140 updateInd->file_id[i] EQ SIM_LP
|
|
|
4141 )
|
|
|
4142 {
|
|
|
4143 if (cnt < MFW_MAX_NT_SIZE)
|
|
|
4144 {
|
|
|
4145 udNotify.fields[cnt] = updateInd->file_id[i];
|
|
|
4146 cnt++;
|
|
|
4147 if (updateInd->file_id[i] EQ SIM_SMS) // bugfix for SIM refresh
|
|
|
4148 sms_busy_ind(); /* When SMS fields will be updated, MFW sends SMS BUSY event to MMI */
|
|
|
4149 }
|
|
|
4150 }
|
|
|
4151 }
|
|
|
4152 udNotify.count = cnt;
|
|
|
4153
|
|
|
4154 if (!cnt)
|
|
|
4155 {
|
|
|
4156 if (fuRef >= 0)
|
|
|
4157 fuRef = -1;
|
|
|
4158 return TRUE;
|
|
|
4159 }
|
|
|
4160
|
|
|
4161 for ( i=0; i < (int)udNotify.count; i++)
|
|
|
4162 {
|
|
|
4163 if ( udNotify.fields[i] EQ SIM_SST )
|
|
|
4164 f = 1;
|
|
|
4165 }
|
|
|
4166
|
|
|
4167 if (udNotify.count)
|
|
|
4168 {
|
|
|
4169 if (f)
|
|
|
4170 {
|
|
|
4171 f = 0;
|
|
|
4172 sim_sat_file_update(SIM_SST);
|
|
|
4173 }
|
|
|
4174 else
|
|
|
4175 satUpdateFiles(FALSE, 0);
|
|
|
4176 }
|
|
|
4177
|
|
|
4178 return FALSE;
|
|
|
4179 }
|
|
|
4180
|
|
|
4181
|
|
|
4182 #endif
|
|
|
4183
|
|
|
4184 /*
|
|
|
4185 +--------------------------------------------------------------------+
|
|
|
4186 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
4187 | STATE : code ROUTINE : satUpdateFiles |
|
|
|
4188 +--------------------------------------------------------------------+
|
|
|
4189
|
|
|
4190 PURPOSE : Update changed files
|
|
|
4191 updated = TRUE, dataId field is updated
|
|
|
4192 updated = FALSE, no field is updated
|
|
|
4193
|
|
|
4194 */
|
|
|
4195
|
|
|
4196 void satUpdateFiles ( U8 updated, USHORT dataId )
|
|
|
4197 {
|
|
|
4198 int i;
|
|
|
4199
|
|
|
4200 TRACE_FUNCTION("satUpdateFiles()");
|
|
|
4201
|
|
|
4202 /* remove the updated file from list */
|
|
|
4203 if (updated)
|
|
|
4204 {
|
|
|
4205 for (i=0; i < MFW_MAX_NT_SIZE; i++)
|
|
|
4206 {
|
|
|
4207 if (udNotify.fields[i] EQ dataId)
|
|
|
4208 {
|
|
|
4209 udNotify.count--;
|
|
|
4210 udNotify.fields[i] = 0;
|
|
|
4211 }
|
|
|
4212 }
|
|
|
4213 }
|
|
|
4214
|
|
|
4215 if (!udNotify.count)
|
|
|
4216 {
|
|
|
4217 if (fuRef >= 0)
|
|
|
4218 {
|
|
|
4219 psaSAT_FUConfirm (fuRef, SIM_FU_SUCCESS);
|
|
|
4220 fuRef = -1;
|
|
|
4221 }
|
|
|
4222 return;
|
|
|
4223 }
|
|
|
4224
|
|
|
4225 /* update the next file */
|
|
|
4226 for ( i=0; i < MFW_MAX_NT_SIZE; i++)
|
|
|
4227 {
|
|
|
4228 if ( udNotify.fields[i] )
|
|
|
4229 {
|
|
|
4230 switch ( udNotify.fields[i] )
|
|
|
4231 {
|
|
|
4232 case SIM_GID1:
|
|
|
4233 sim_sat_file_update( SIM_GID1 );
|
|
|
4234 return;
|
|
|
4235 case SIM_GID2:
|
|
|
4236 sim_sat_file_update( SIM_GID2 );
|
|
|
4237 return;
|
|
|
4238 case SIM_CPHS_CINF:
|
|
|
4239 cphs_sat_file_update( SIM_CPHS_CINF );
|
|
|
4240 return;
|
|
|
4241 case SIM_SMS:
|
|
|
4242 sms_sat_file_update( SIM_SMS );
|
|
|
4243 return;
|
|
|
4244 case SIM_SPN:
|
|
|
4245 nm_sat_file_update( SIM_SPN );
|
|
|
4246 return;
|
|
|
4247 case SIM_LP:
|
|
|
4248 mfwSATLPRefresh = TRUE;
|
|
|
4249 sim_sat_file_update( SIM_LP );
|
|
|
4250 return;
|
|
|
4251 default:
|
|
|
4252 break;
|
|
|
4253 }
|
|
|
4254 }
|
|
|
4255 }
|
|
|
4256 }
|
|
|
4257
|
|
|
4258 /*
|
|
|
4259 +--------------------------------------------------------------------+
|
|
|
4260 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
4261 | STATE : code ROUTINE : satRefreshNotification |
|
|
|
4262 +--------------------------------------------------------------------+
|
|
|
4263
|
|
|
4264 PURPOSE : File change notification start and refresh confirmatio
|
|
|
4265
|
|
|
4266 */
|
|
|
4267
|
|
|
4268 BOOL satRefreshNotification ( int ref, T_SIM_FILE_UPDATE_IND *updateInd)
|
|
|
4269 {
|
|
|
4270 U32 evt=0;
|
|
|
4271
|
|
|
4272 TRACE_FUNCTION("satRefreshNotification");
|
|
|
4273
|
|
|
4274 if (ref<0) /*File update indication arrives from ACI */
|
|
|
4275 { /* MMI has to be notified once */
|
|
|
4276 #ifdef FF_2TO1_PS
|
|
|
4277 cmd.c.refFiles.files = (U16*)updateInd->file_info[0].datafield;
|
|
|
4278 #else
|
|
|
4279 cmd.c.refFiles.files = (U16*)updateInd->file_id;
|
|
|
4280 #endif
|
|
|
4281 cmd.c.refFiles.files_nr = updateInd->val_nr;
|
|
|
4282 cmd.c.refFiles.status = ref;
|
|
|
4283 if (updateInd->val_nr)
|
|
|
4284 evt = MfwSatRefresh;
|
|
|
4285 if (evt)
|
|
|
4286 satSignal(evt, &cmd);
|
|
|
4287 if (fu_aborted)
|
|
|
4288 {
|
|
|
4289 fu_aborted = FALSE;
|
|
|
4290 return FALSE;
|
|
|
4291 }
|
|
|
4292 }
|
|
|
4293 else
|
|
|
4294 {
|
|
|
4295 #ifdef FF_2TO1_PS
|
|
|
4296 cmd.c.refFiles.files = (U16*)updateInd->file_info[0].datafield;
|
|
|
4297 #else
|
|
|
4298 cmd.c.refFiles.files = (U16*)updateInd->file_id;
|
|
|
4299 #endif
|
|
|
4300 cmd.c.refFiles.files_nr = updateInd->val_nr;
|
|
|
4301 cmd.c.refFiles.status = ref;
|
|
|
4302 if (updateInd->val_nr)
|
|
|
4303 evt = MfwSatDataRefreshed;
|
|
|
4304 if (evt)
|
|
|
4305 satSignal(evt, &cmd);
|
|
|
4306 }
|
|
|
4307 return TRUE;
|
|
|
4308 }
|
|
|
4309
|
|
|
4310
|
|
|
4311 /*
|
|
|
4312 +--------------------------------------------------------------------+
|
|
|
4313 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
4314 | STATE : code ROUTINE : satRefreshAbort |
|
|
|
4315 +--------------------------------------------------------------------+
|
|
|
4316
|
|
|
4317 PURPOSE : MMI aborts the file update notification. It should answer the event MfwSatRefresh
|
|
|
4318 */
|
|
|
4319
|
|
|
4320 void satRefreshAbort()
|
|
|
4321 {
|
|
|
4322 fu_aborted = TRUE;
|
|
|
4323 }
|
|
|
4324
|
|
|
4325 /*
|
|
|
4326 +--------------------------------------------------------------------+
|
|
|
4327 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
4328 | STATE : code ROUTINE : satBrowserTerminated |
|
|
|
4329 +--------------------------------------------------------------------+
|
|
|
4330
|
|
|
4331 PURPOSE : downloads the Browser termination event to the SAT.
|
|
|
4332
|
|
|
4333 Cause can be,
|
|
|
4334
|
|
|
4335 SatBrowserTerminCauseUser 0x00
|
|
|
4336 SatBrowserTerminCauseError 0x01
|
|
|
4337
|
|
|
4338 SPR#2121 - DS - Dynamically allocate memory for Terminal Response.
|
|
|
4339
|
|
|
4340 */
|
|
|
4341
|
|
|
4342 #if defined(FF_WAP)
|
|
|
4343
|
|
|
4344 MfwRes satBrowserTerminated(U8 cause)
|
|
|
4345 {
|
|
|
4346 S16 ti = 0;
|
|
|
4347 U8* trmResponse = NULL;
|
|
|
4348
|
|
|
4349 TRACE_FUNCTION("satBrowserTerminated");
|
|
|
4350
|
|
|
4351 /* Allocate memory for Terminal Response buffer */
|
|
|
4352 trmResponse = (U8*)mfwAlloc(TRM_RSP_LEN);
|
|
|
4353
|
|
|
4354 if (trmResponse == NULL)
|
|
|
4355 {
|
|
|
4356 /* Memory allocation failed */
|
|
|
4357 TRACE_ERROR("ERROR: Failed to allocate memory for TR buffer");
|
|
|
4358 return MfwResNoMem;
|
|
|
4359 }
|
|
|
4360
|
|
|
4361 trmResponse[ti++] = 0xD6; /* event download tag */
|
|
|
4362 trmResponse[ti++] = 0; /* length (filled later) */
|
|
|
4363 trmResponse[ti++] = 0x99; /* --event list-- */
|
|
|
4364 trmResponse[ti++] = 0x01; /* length */
|
|
|
4365 trmResponse[ti++] = SatEvtBrowserTermination; /* actual event */
|
|
|
4366 trmResponse[ti++] = 0x82; /* --device identities-- */
|
|
|
4367 trmResponse[ti++] = 0x02; /* length */
|
|
|
4368 trmResponse[ti++] = SatDevME; /* source */
|
|
|
4369 trmResponse[ti++] = 0x81; /* destination: SIM */
|
|
|
4370 trmResponse[ti++] = 0x34; /* Browser Termination Cause tag */
|
|
|
4371 trmResponse[ti++] = 0x01; /* Browser Termination length*/
|
|
|
4372 trmResponse[ti++] = cause; /* termination cause */
|
|
|
4373 trmResponse[1] = ti - 2; /* length of event download */
|
|
|
4374
|
|
|
4375 sAT_PercentSATE(CMD_SRC_LCL,ti,trmResponse);
|
|
|
4376
|
|
|
4377 /* Deallocate memory used for Terminal Response buffer */
|
|
|
4378 if (trmResponse != NULL)
|
|
|
4379 {
|
|
|
4380 mfwFree(trmResponse, TRM_RSP_LEN);
|
|
|
4381 trmResponse = NULL;
|
|
|
4382 }
|
|
|
4383
|
|
|
4384 return MfwResOk;
|
|
|
4385
|
|
|
4386 }
|
|
|
4387
|
|
|
4388 #endif
|
|
|
4389
|
|
|
4390 /*
|
|
|
4391 +--------------------------------------------------------------------+
|
|
|
4392 | PROJECT : MMI-Framework (8417) MODULE : MFW_SAT |
|
|
|
4393 | STATE : code ROUTINE : sate_error |
|
|
|
4394 +--------------------------------------------------------------------+
|
|
|
4395
|
|
|
4396 PURPOSE : Handles errors returned from SAT.
|
|
|
4397
|
|
|
4398 SPR#2321 - DS - Function created.
|
|
|
4399
|
|
|
4400 */
|
|
|
4401 void sate_error(T_ACI_CME_ERR error)
|
|
|
4402 {
|
|
|
4403 TRACE_FUNCTION("sate_error()");
|
|
|
4404
|
|
|
4405 TRACE_EVENT_P1("SATE Error: %d", error);
|
|
|
4406
|
|
|
4407 if (error == CME_ERR_SimSatBusy)
|
|
|
4408 {
|
|
|
4409 /* Close any open connections */
|
|
|
4410 satDisc();
|
|
|
4411
|
|
|
4412 /* Send "temporary failure" terminal response so SIM can restart the busy SAT Application */
|
|
|
4413 satResponse(SatResBusyME);
|
|
|
4414
|
|
|
4415 /* Send event to BMI so user can be informed of error */
|
|
|
4416 satSignal(MfwSatErrBusy, (void*)error);
|
|
|
4417 }
|
|
|
4418 }
|
|
|
4419
|
|
|
4420 // Jun 16, 2005 REF: CRR 31543 x0021334
|
|
|
4421
|
|
|
4422 /*
|
|
|
4423 +--------------------------------------------------------------------+
|
|
|
4424 | PROJECT : MMI-Framework MODULE : MFW_SAT |
|
|
|
4425 | STATE : code ROUTINE : satHangup |
|
|
|
4426 +--------------------------------------------------------------------+
|
|
|
4427
|
|
|
4428 PURPOSE : Handles Hang up key event during USSD session.
|
|
|
4429
|
|
|
4430 */
|
|
|
4431 T_MFW_SS_RETURN satHangup (T_ACI_CMD_SRC sId)
|
|
|
4432 {
|
|
|
4433 T_ACI_RETURN result;
|
|
|
4434
|
|
|
4435 TRACE_FUNCTION("satHangup()");
|
|
|
4436
|
|
|
4437 result = sAT_end_ussd(sId); // end the USSD session
|
|
|
4438 return ((result EQ AT_CMPL) ? MFW_SS_OK : MFW_SS_FAIL);
|
|
|
4439 }
|
