FreeCalypso > hg > fc-tourmaline

comparison src/ui/bmi/mmiHomezone.c @ 151:60f8c8e710f4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mmiHomezone.c: bogotab fixes
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 16 Nov 2020 06:57:28 +0000
parents c0052fe355d3
children
comparison
equal deleted inserted replaced
150:abaee5bdfdc9 151:60f8c8e710f4
1 /******************************************************************************* 1 /*******************************************************************************
2 2
3 CONDAT (UK) 3 CONDAT (UK)
4 4
5 ******************************************************************************** 5 ********************************************************************************
6 6
7 This software product is the property of Condat (UK) Ltd and may not be 7 This software product is the property of Condat (UK) Ltd and may not be
8 disclosed to any third party without the express permission of the owner. 8 disclosed to any third party without the express permission of the owner.
9 9
10 ******************************************************************************** 10 ********************************************************************************
11 11
12 $Project name: Basic MMI 12 $Project name: Basic MMI
13 $Project code: BMI 13 $Project code: BMI
14 $Module: 14 $Module:
15 $File: MmiHomezone.c 15 $File: MmiHomezone.c
16 $Revision: 1.0 16 $Revision: 1.0
17 17
18 $Author: Condat(UK) 18 $Author: Condat(UK)
19 $Date: 15/02/02 19 $Date: 15/02/02
20 20
21 ******************************************************************************** 21 ********************************************************************************
22 22
23 Description: Homezone functionality in MMI 23 Description: Homezone functionality in MMI
24 24
25 25
26
27 ******************************************************************************** 26 ********************************************************************************
28 27
29 $History: MmiHomezone.c 28 $History: MmiHomezone.c
30 29
31 15/02/02 Original Condat(UK) BMI version. 30 15/02/02 Original Condat(UK) BMI version.
32 28/05/02 Latest Condat(UK) BMI version 31 28/05/02 Latest Condat(UK) BMI version
33 32
34 Sep 14, 2007 REF: OMAPS00145865 Adrian Salido 33 Sep 14, 2007 REF: OMAPS00145865 Adrian Salido
35 Description: FT - MMI: Wrong trace class 34 Description: FT - MMI: Wrong trace class
36 Solution: changed some event traces to function traces because the information content of 35 Solution: changed some event traces to function traces because the information content of
37 this is low for non-MMI people and against TI coding convention. 36 this is low for non-MMI people and against TI coding convention.
38 37
39 Mar 14, 2006 DR: OMAPS00061468 - x0035544. 38 Mar 14, 2006 DR: OMAPS00061468 - x0035544.
40 Description: SAT 27.22.4.22.2 SET UP IDLE MODE TEXT (Icon support) fails 39 Description: SAT 27.22.4.22.2 SET UP IDLE MODE TEXT (Icon support) fails
41 Solution : In the function homezoneUpdateDisplay(), additional parameter has been added to the 40 Solution : In the function homezoneUpdateDisplay(), additional parameter has been added to the
42 function call addSatMessage() under the flag FF_MMI_SAT_ICON to support SAT Icon for IDLE TEXT display. 41 function call addSatMessage() under the flag FF_MMI_SAT_ICON to support SAT Icon for IDLE TEXT display.
43 42
44 Dec 15, 2005 REF: MMI-FIX-OMAPS00058684 x0035544 43 Dec 15, 2005 REF: MMI-FIX-OMAPS00058684 x0035544
45 Description: OMAPS00045726 / MMI-FIX-30439 Follow-Up : ifdef for FF Home Zone forgotten. 44 Description: OMAPS00045726 / MMI-FIX-30439 Follow-Up : ifdef for FF Home Zone forgotten.
46 Solution: Added Feature flag FF_HOMEZONE for the function sms_homezoneCBToggle(U8 Activate_CB) 45 Solution: Added Feature flag FF_HOMEZONE for the function sms_homezoneCBToggle(U8 Activate_CB)
47 in this file as it has got the prototype for this function. 46 in this file as it has got the prototype for this function.
48 47
49 Jun 14, 2005 REF: MMI-FIX-30439 x0018858 48 Jun 14, 2005 REF: MMI-FIX-30439 x0018858
50 Description: The homezone/cityzone tags were not being displayed properly. 49 Description: The homezone/cityzone tags were not being displayed properly.
51 Solution: Modified to save the tags properly in caches and also made the 50 Solution: Modified to save the tags properly in caches and also made the
52 appropriate modifications to update the same properly during mobility. 51 appropriate modifications to update the same properly during mobility.
53 52
54 $End 53 $End
55 54
56 *******************************************************************************/ 55 *******************************************************************************/
57 #include <string.h> 56 #include <string.h>
128 #endif 127 #endif
129 128
130 129
131 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 130 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
132 // enable HZ trace 131 // enable HZ trace
133 //#undef TRACE_MMIHOMEZONE 132 //#undef TRACE_MMIHOMEZONE
134 #define TRACE_MMIHOMEZONE 1 133 #define TRACE_MMIHOMEZONE 1
135 134
136 T_homezone_data homezoneData; 135 T_homezone_data homezoneData;
137 extern T_SMSCB_DATASTORE g_smscb_data; /* storage for Cell Broadcast lists */ 136 extern T_SMSCB_DATASTORE g_smscb_data; /* storage for Cell Broadcast lists */
138 static int hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 137 static int hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
139 138
140 //Dec 14, 2005 REF: MMI-FIX-OMAPS00058684 x0035544 139 //Dec 14, 2005 REF: MMI-FIX-OMAPS00058684 x0035544
141 #ifdef FF_HOMEZONE 140 #ifdef FF_HOMEZONE
145 #endif 144 #endif
146 145
147 /* x0039928 - Lint warning fix */ 146 /* x0039928 - Lint warning fix */
148 static char *homezoneMNC_MCC[HZ_PERMITTED_NETWORKS] = 147 static char *homezoneMNC_MCC[HZ_PERMITTED_NETWORKS] =
149 { 148 {
150 "26207", /* VIAG Interkom */ 149 "26207", /* VIAG Interkom */
151 }; 150 };
152 151
153 //void sms_homezoneCBToggle(U8 Activate_CB); 152 //void sms_homezoneCBToggle(U8 Activate_CB);
154 153
155 /******************************************************************************* 154 /*******************************************************************************
156 155
157 LOCALLY REFERENCED FUNCTIONS 156 LOCALLY REFERENCED FUNCTIONS
158 157
159 *******************************************************************************/ 158 *******************************************************************************/
160 159
161 void homezoneReadParams(); 160 void homezoneReadParams();
162 void homezoneLocate(); 161 void homezoneLocate();
163 static U32 calculateDecimal( char *string, int length ); 162 static U32 calculateDecimal( char *string, int length );
164 static U32 readHexFromSimfile( UBYTE *simFile, int length ); 163 static U32 readHexFromSimfile( UBYTE *simFile, int length );
165 static void writeHexToSimfile( UBYTE *simFile, U32 value, int length ); 164 static void writeHexToSimfile( UBYTE *simFile, U32 value, int length );
166 165
167 /******************************************************************************* 166 /*******************************************************************************
168 167
169 $Function: homezoneInit 168 $Function: homezoneInit
170 169
171 $Description: Initialise homezone data structure. Reset the recent cache. 170 $Description: Initialise homezone data structure. Reset the recent cache.
172 171
173 $Returns: 172 $Returns:
174 173
175 $Arguments: 174 $Arguments:
176 *******************************************************************************/ 175 *******************************************************************************/
177 176
178 void homezoneInit() 177 void homezoneInit()
179 { 178 {
180 T_homezone_data *data = &homezoneData; 179 T_homezone_data *data = &homezoneData;
181 USHORT cacheIndex; 180 USHORT cacheIndex;
182 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 181 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
183 // Added the following local variables. 182 // Added the following local variables.
184 //begin 30439 183 //begin 30439
185 UBYTE version; 184 UBYTE version;
186 USHORT max_rcd; 185 USHORT max_rcd;
187 EF_HZCACHE cache; 186 EF_HZCACHE cache;
188 //end 30439 187 //end 30439
189 188
190 TRACE_FUNCTION("homezoneInit()"); 189 TRACE_FUNCTION("homezoneInit()");
191 190
192 /* Set all data to 0 */ 191 /* Set all data to 0 */
193 192
194 memset((UBYTE *)data, 0, sizeof(T_homezone_data)); 193 memset((UBYTE *)data, 0, sizeof(T_homezone_data));
195 194
196 data->current_zone = HZ_NOT_IN_ZONE; // 0xFF = not in a homezone 195 data->current_zone = HZ_NOT_IN_ZONE; // 0xFF = not in a homezone
197 data->recent_cell_index = HZ_RECENT_MAX-1; // Next entry will loop round & be at start of cache 196 data->recent_cell_index = HZ_RECENT_MAX-1; // Next entry will loop round & be at start of cache
198 197
199 /* Set up recent cell cache */ 198 /* Set up recent cell cache */
200 199
201 for (cacheIndex = 0; cacheIndex<HZ_RECENT_MAX; cacheIndex++) 200 for (cacheIndex = 0; cacheIndex<HZ_RECENT_MAX; cacheIndex++)
202 { 201 {
203 data->recent_cell[cacheIndex] = 0; 202 data->recent_cell[cacheIndex] = 0;
204 data->recent_cell_zone[cacheIndex] = HZ_NOT_IN_ZONE; 203 data->recent_cell_zone[cacheIndex] = HZ_NOT_IN_ZONE;
205 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 204 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
206 //begin 30439 205 //begin 30439
207 /* Read cache from PCM */ 206 /* Read cache from PCM */
208 if (pcm_ReadRecord((UBYTE *)EF_HZCACHE_ID, 207 if (pcm_ReadRecord((UBYTE *)EF_HZCACHE_ID,
209 (USHORT)(cacheIndex+1), 208 (USHORT)(cacheIndex+1),
210 SIZE_EF_HZCACHE, 209 SIZE_EF_HZCACHE,
211 (UBYTE *)&cache, 210 (UBYTE *)&cache,
212 &version, 211 &version,
213 &max_rcd) NEQ DRV_OK) 212 &max_rcd) NEQ DRV_OK)
214 { 213 {
215 TRACE_EVENT ("Init cache read from PCM wrong"); 214 TRACE_EVENT ("Init cache read from PCM wrong");
216 break; /* read error */ 215 break; /* read error */
217 } 216 }
218 else 217 else
219 { 218 {
220 if (cache.cid[0] != 0xFF AND cache.cid[1] != 0xFF) 219 if (cache.cid[0] != 0xFF AND cache.cid[1] != 0xFF)
221 { 220 {
222 data->recent_cell[cacheIndex] = readHexFromSimfile(&cache.cid[0],2); 221 data->recent_cell[cacheIndex] = readHexFromSimfile(&cache.cid[0],2);
223 data->recent_cell_zone[cacheIndex] = cache.zone; 222 data->recent_cell_zone[cacheIndex] = cache.zone;
224 } 223 }
225 } 224 }
226 TRACE_EVENT_P3("Init cache %d: CID %X, zone %X",cacheIndex, data->recent_cell[cacheIndex], data->recent_cell_zone[cacheIndex]); 225 TRACE_EVENT_P3("Init cache %d: CID %X, zone %X",cacheIndex, data->recent_cell[cacheIndex], data->recent_cell_zone[cacheIndex]);
227 //end 30439 226 //end 30439
228 } 227 }
229 228
230 data->new_cell_res = FALSE; 229 data->new_cell_res = FALSE;
231 230
232 return; 231 return;
233 } 232 }
234 233
235 234
236 /******************************************************************************* 235 /*******************************************************************************
237 236
238 $Function: homezoneReadSim 237 $Function: homezoneReadSim
239 238
240 $Description: Read homezone data in from SIM. Checks to see if conditions (SIM, 239 $Description: Read homezone data in from SIM. Checks to see if conditions (SIM,
241 network) are correct for homezone; switches it off if not. 240 network) are correct for homezone; switches it off if not.
242 241
243 $Returns: None. 242 $Returns: None.
244 243
245 $Arguments: read_again - if this is HZ_READ_ONCE_ONLY, then SIM fields will not 244 $Arguments: read_again - if this is HZ_READ_ONCE_ONLY, then SIM fields will not
246 be read in again if they have already been read in once. 245 be read in again if they have already been read in once.
247 If this is HZ_READ_SIM_AGAIN, they will be read in anyway. 246 If this is HZ_READ_SIM_AGAIN, they will be read in anyway.
248 247
249 *******************************************************************************/ 248 *******************************************************************************/
250 249
251 void homezoneReadSim(UBYTE read_again) 250 void homezoneReadSim(UBYTE read_again)
252 { 251 {
253 T_homezone_data *data = &homezoneData; 252 T_homezone_data *data = &homezoneData;
254 char IMSI[17]; 253 char IMSI[17];
255 char MNC_MCC[6]; 254 char MNC_MCC[6];
256 255
257 USHORT networkIndex; 256 USHORT networkIndex;
258 UBYTE networkOK; 257 UBYTE networkOK;
259 USHORT tries; 258 USHORT tries;
260 259
261 /* Check if homezone is switched off */ 260 /* Check if homezone is switched off */
262 261
263 if (data->received == HZ_RECEIVED_HZ_OFF) 262 if (data->received == HZ_RECEIVED_HZ_OFF)
264 return; 263 return;
265 264
266 /* SPR877 - If read_again specifies that SIM data should not be re-read, exit from function 265 /* SPR877 - If read_again specifies that SIM data should not be re-read, exit from function
267 * provided we have read it once. */ 266 * provided we have read it once. */
268 267
269 if (read_again == HZ_READ_ONCE_ONLY && data->received & HZ_RECEIVED_SIMDATA) 268 if (read_again == HZ_READ_ONCE_ONLY && data->received & HZ_RECEIVED_SIMDATA)
270 return; 269 return;
271 270
272 TRACE_FUNCTION("homezoneReadSim()"); 271 TRACE_FUNCTION("homezoneReadSim()");
273 272
274 /* Check if network operator is in list */ 273 /* Check if network operator is in list */
275 274
276 networkOK = FALSE; 275 networkOK = FALSE;
277 276
278 tries = 0; 277 tries = 0;
279 278
280 while ((qAT_PlusCIMI(CMD_SRC_LCL, IMSI)) != AT_CMPL && tries < 5) 279 while ((qAT_PlusCIMI(CMD_SRC_LCL, IMSI)) != AT_CMPL && tries < 5)
281 { 280 {
282 tries++; 281 tries++;
283 } 282 }
284 283
285 strncpy(MNC_MCC, IMSI, 5); 284 strncpy(MNC_MCC, IMSI, 5);
286 MNC_MCC[5] =0; //terminate string 285 MNC_MCC[5] =0; //terminate string
287 286
288 #ifdef TRACE_MMIHOMEZONE 287 #ifdef TRACE_MMIHOMEZONE
289 TRACE_EVENT_P1("MNC_MCC: %s", (char *)MNC_MCC); 288 TRACE_EVENT_P1("MNC_MCC: %s", (char *)MNC_MCC);
290 #endif 289 #endif
291 290
292 for (networkIndex=0; networkIndex<HZ_PERMITTED_NETWORKS; networkIndex++) 291 for (networkIndex=0; networkIndex<HZ_PERMITTED_NETWORKS; networkIndex++)
293 { 292 {
294 if (!strncmp((char *)MNC_MCC, homezoneMNC_MCC[networkIndex],5)) 293 if (!strncmp((char *)MNC_MCC, homezoneMNC_MCC[networkIndex],5))
295 { 294 {
296 #ifdef TRACE_MMIHOMEZONE 295 #ifdef TRACE_MMIHOMEZONE
297 TRACE_EVENT_P1("Matches entry %d", networkIndex); 296 TRACE_EVENT_P1("Matches entry %d", networkIndex);
298 #endif 297 #endif
299 networkOK = TRUE; 298 networkOK = TRUE;
300 } 299 }
301 } 300 }
302 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 301 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
303 //begin 30439 302 //begin 30439
304 /* Attempt to read first sim field */ 303 /* Attempt to read first sim field */
305 if (read_again == HZ_READ_SIM_AGAIN) 304 if (read_again == HZ_READ_SIM_AGAIN)
306 hzFlag = 1; 305 hzFlag = 1;
307 //end 30439 306 //end 30439
308 307
309 if (networkOK) 308 if (networkOK)
310 { 309 {
311 if (!Read_Sim(HZ_SIM_PARAMETERS, 0, HZ_SIM_PARAMETERS_SIZE, data->buffer)) 310 if (!Read_Sim(HZ_SIM_PARAMETERS, 0, HZ_SIM_PARAMETERS_SIZE, data->buffer))
312 { 311 {
313 TRACE_EVENT("SIM read error 1: Homezone OFF"); /* SIM field not present, switch off homezone */ 312 TRACE_EVENT("SIM read error 1: Homezone OFF"); /* SIM field not present, switch off homezone */
314 data->received = HZ_RECEIVED_HZ_OFF; 313 data->received = HZ_RECEIVED_HZ_OFF;
315 hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 - Seting the variable 314 hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 - Seting the variable
316 } 315 }
317 } 316 }
318 else 317 else
319 { 318 {
320 TRACE_EVENT("Wrong network: Homezone OFF"); /* Network not in list, switch off homezone */ 319 TRACE_EVENT("Wrong network: Homezone OFF"); /* Network not in list, switch off homezone */
321 data->received = HZ_RECEIVED_HZ_OFF; 320 data->received = HZ_RECEIVED_HZ_OFF;
322 hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 - Seting the variable 321 hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 - Seting the variable
323 } 322 }
324 323
325 return; 324 return;
326 } 325 }
327 326
328 327
329 /******************************************************************************* 328 /*******************************************************************************
330 329
331 $Function: homezoneReadSimCb 330 $Function: homezoneReadSimCb
332 331
333 $Description: Callback, called when read sim has occurred. Fills up the homezone 332 $Description: Callback, called when read sim has occurred. Fills up the homezone
334 data structure with the appropriate values retrieved from SIM. 333 data structure with the appropriate values retrieved from SIM.
335 334
336 $Returns: None. 335 $Returns: None.
337 336
338 $Arguments: field - the SIM field that was just read 337 $Arguments: field - the SIM field that was just read
339 record - the record in the SIM field that was read 338 record - the record in the SIM field that was read
340 result - the result code returned - 0 for successful. 339 result - the result code returned - 0 for successful.
341 *******************************************************************************/ 340 *******************************************************************************/
342 341
343 void homezoneReadSimCb(USHORT field, USHORT record, USHORT result) 342 void homezoneReadSimCb(USHORT field, USHORT record, USHORT result)
344 { 343 {
345 T_homezone_data *data = &homezoneData; 344 T_homezone_data *data = &homezoneData;
346 T_homezone *homezone = data->homezone; 345 T_homezone *homezone = data->homezone;
347 UBYTE *simFile; 346 UBYTE *simFile;
348 USHORT fileIndex; 347 USHORT fileIndex;
349 USHORT hzIndex; 348 USHORT hzIndex;
350 UBYTE keepLooking; 349 UBYTE keepLooking;
351 U8 Activate_cb =0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 350 U8 Activate_cb =0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
352 //To activate/deactivate homezoneCB 351 //To activate/deactivate homezoneCB
353 TRACE_FUNCTION("homezoneReadSimCb()"); 352 TRACE_FUNCTION("homezoneReadSimCb()");
354 353
355 #ifdef TRACE_MMIHOMEZONE 354 #ifdef TRACE_MMIHOMEZONE
356 TRACE_EVENT_P2("Have just read SIM file: %x record %d", field, record); 355 TRACE_EVENT_P2("Have just read SIM file: %x record %d", field, record);
357 #endif 356 #endif
358 357
359 /* Read in general homezone data. If reading first SIM field fails, switch homezone off */ 358 /* Read in general homezone data. If reading first SIM field fails, switch homezone off */
360 359
361 if (field==HZ_SIM_PARAMETERS) 360 if (field==HZ_SIM_PARAMETERS)
362 { 361 {
363 /* check SIM read result for homezone parameter */ 362 /* check SIM read result for homezone parameter */
364 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 363 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
365 //begin 30439 364 //begin 30439
366 //Modified the conditional statement 365 //Modified the conditional statement
367 //if (result) 366 //if (result)
368 if (result != 0x80FF) 367 if (result != 0x80FF)
369 //end 30439 368 //end 30439
370 { 369 {
371 TRACE_EVENT("SIM read error 2: Homezone OFF"); 370 TRACE_EVENT("SIM read error 2: Homezone OFF");
372 data->received = HZ_RECEIVED_HZ_OFF; 371 data->received = HZ_RECEIVED_HZ_OFF;
373 hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 -Setting the variable 372 hzFlag = 0; //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 -Setting the variable
374 return; 373 return;
375 } 374 }
376 homezoneReadParams(); 375 homezoneReadParams();
377 /*homezoneActivateCB();*/ /* Switch on cell broadcast */ 376 /*homezoneActivateCB();*/ /* Switch on cell broadcast */
378 /* SH - this is already done at startup */ 377 /* SH - this is already done at startup */
379 record = HZ_CACHE_MAX; 378 record = HZ_CACHE_MAX;
380 } 379 }
381 380
382 /* Read in records for each homezone cache */ 381 /* Read in records for each homezone cache */
383 382
384 /* check SIM read result for hoemzone cache */ 383 /* check SIM read result for hoemzone cache */
385 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 384 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
386 //begin 30439 385 //begin 30439
387 //Modified the conditional statement 386 //Modified the conditional statement
388 //if (field>HZ_SIM_PARAMETERS && !result) 387 //if (field>HZ_SIM_PARAMETERS && !result)
389 if (field>HZ_SIM_PARAMETERS && (result == 0x80FF)) 388 if (field>HZ_SIM_PARAMETERS && (result == 0x80FF))
390 //end 30439 389 //end 30439
391 { 390 {
392 hzIndex = field - HZ_SIM_CELL_CACHE; 391 hzIndex = field - HZ_SIM_CELL_CACHE;
393 simFile = data->buffer2; 392 simFile = data->buffer2;
394 fileIndex = 0; 393 fileIndex = 0;
395 394
396 homezone[hzIndex].lac[record-1] = readHexFromSimfile(&simFile[fileIndex],2); 395 homezone[hzIndex].lac[record-1] = readHexFromSimfile(&simFile[fileIndex],2);
397 fileIndex+=2; 396 fileIndex+=2;
398 homezone[hzIndex].cid[record-1] = readHexFromSimfile(&simFile[fileIndex],2); 397 homezone[hzIndex].cid[record-1] = readHexFromSimfile(&simFile[fileIndex],2);
399 398
400 #ifdef TRACE_MMIHOMEZONE 399 #ifdef TRACE_MMIHOMEZONE
401 TRACE_EVENT_P2("read lac = %x, cid = %x", homezone[hzIndex].lac[record-1], homezone[hzIndex].cid[record-1]); 400 TRACE_EVENT_P2("read lac = %x, cid = %x", homezone[hzIndex].lac[record-1], homezone[hzIndex].cid[record-1]);
402 #endif 401 #endif
403 } 402 }
404 403
405 /* Read in the next record */ 404 /* Read in the next record */
406 405
407 keepLooking = TRUE; 406 keepLooking = TRUE;
408 407
409 while (keepLooking) 408 while (keepLooking)
410 { 409 {
411 /* check SIM read result for hoemzone cache */ 410 /* check SIM read result for hoemzone cache */
412 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 411 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
413 //begin 30439 412 //begin 30439
414 //Modified the conditional statement 413 //Modified the conditional statement
415 //if (record==HZ_CACHE_MAX || result) 414 //if (record==HZ_CACHE_MAX || result)
416 if (record==HZ_CACHE_MAX || (result != 0x80FF)) 415 if (record==HZ_CACHE_MAX || (result != 0x80FF))
417 //end 30439 416 //end 30439
418 { 417 {
419 field++; // Look at next field 418 field++; // Look at next field
420 record = 1; 419 record = 1;
421 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 420 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
422 // Print the current feild. 421 // Print the current feild.
423 TRACE_EVENT_P1("current field = %x", field); 422 TRACE_EVENT_P1("current field = %x", field);
424 } 423 }
425 else 424 else
426 record++; 425 record++;
427 426
428 hzIndex = field-HZ_SIM_CELL_CACHE; 427 hzIndex = field-HZ_SIM_CELL_CACHE;
429 428
430 if (hzIndex==HZ_ZONES_MAX) 429 if (hzIndex==HZ_ZONES_MAX)
431 { 430 {
432 keepLooking = FALSE; 431 keepLooking = FALSE;
433 /* Have read all sim data, set flag so icon etc will be updated */ 432 /* Have read all sim data, set flag so icon etc will be updated */
434 data->received |= HZ_RECEIVED_SIMDATA; 433 data->received |= HZ_RECEIVED_SIMDATA;
435 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 434 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
436 //begin 30439 435 //begin 30439
437 /* homezone display update after SIM REFRESH (when hzFlag set to 1) */ 436 /* homezone display update after SIM REFRESH (when hzFlag set to 1) */
438 TRACE_EVENT_P1("hzFlag = %d", hzFlag); 437 TRACE_EVENT_P1("hzFlag = %d", hzFlag);
439 if (hzFlag) 438 if (hzFlag)
440 { 439 {
441 // hzFlag = 0; 440 // hzFlag = 0;
442 homezoneUpdate(0, 0, 1); 441 homezoneUpdate(0, 0, 1);
443 } 442 }
444 else 443 else
445 { 444 {
446 445
447 TRACE_EVENT("activate homezone CB"); 446 TRACE_EVENT("activate homezone CB");
448 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 447 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
449 //Call to activate the Homezone CB. 448 //Call to activate the Homezone CB.
450 Activate_cb = 1; 449 Activate_cb = 1;
451 450
452 #ifdef FF_HOMEZONE 451 #ifdef FF_HOMEZONE
453 sms_homezoneCBToggle(Activate_cb); 452 sms_homezoneCBToggle(Activate_cb);
454 #endif 453 #endif
455 homezoneUpdate(0, 0, 1); /* new VO : speed up update */ 454 homezoneUpdate(0, 0, 1); /* new VO : speed up update */
456 } 455 }
457 //end 30439 456 //end 30439
458 457
459 } 458 }
460 else if (homezone[hzIndex].active) 459 else if (homezone[hzIndex].active)
461 { 460 {
462 keepLooking = FALSE; 461 keepLooking = FALSE;
463 462
464 #ifdef TRACE_MMIHOMEZONE 463 #ifdef TRACE_MMIHOMEZONE
465 //TRACE_EVENT_P3("HZ READ HZ %d field %X record %d", hzIndex, field, record); 464 //TRACE_EVENT_P3("HZ READ HZ %d field %X record %d", hzIndex, field, record);
466 #endif 465 #endif
467 if (!Read_Sim_Record(field, record, HZ_SIM_CELL_CACHE_SIZE, data->buffer2)) 466 if (!Read_Sim_Record(field, record, HZ_SIM_CELL_CACHE_SIZE, data->buffer2))
468 { 467 {
469 TRACE_EVENT("SIM reading error!"); 468 TRACE_EVENT("SIM reading error!");
470 } 469 }
471 } 470 }
472 } 471 }
473 472
474 return; 473 return;
475 } 474 }
476 475
477 476
478 /******************************************************************************* 477 /*******************************************************************************
479 478
480 $Function: homezoneReadParams 479 $Function: homezoneReadParams
481 480
482 $Description: Decode the homezone parameters from the first SIM field 481 $Description: Decode the homezone parameters from the first SIM field
483 482
484 $Returns: None. 483 $Returns: None.
485 484
486 $Arguments: None. 485 $Arguments: None.
487 *******************************************************************************/ 486 *******************************************************************************/
488 487
489 void homezoneReadParams() 488 void homezoneReadParams()
490 { 489 {
491 T_homezone_data *data = &homezoneData; 490 T_homezone_data *data = &homezoneData;
492 T_homezone *homezone = data->homezone; 491 T_homezone *homezone = data->homezone;
493 UBYTE *simFile; 492 UBYTE *simFile;
494 USHORT fileIndex; 493 USHORT fileIndex;
495 USHORT tagIndex; 494 USHORT tagIndex;
496 USHORT hzIndex; 495 USHORT hzIndex;
497 char character; 496 char character;
498 497
499 TRACE_FUNCTION("homezoneReadParams()"); 498 TRACE_FUNCTION("homezoneReadParams()");
500 499
501 simFile = data->buffer; 500 simFile = data->buffer;
502 fileIndex = HZ_SIM_FIRST_ZONE; // Point to the first homezone data 501 fileIndex = HZ_SIM_FIRST_ZONE; // Point to the first homezone data
503 502
504 for (hzIndex=0; hzIndex<HZ_ZONES_MAX; hzIndex++) // For each homezone... 503 for (hzIndex=0; hzIndex<HZ_ZONES_MAX; hzIndex++) // For each homezone...
505 { 504 {
506 homezone[hzIndex].zoneID = simFile[fileIndex]; // Read in the various parameters 505 homezone[hzIndex].zoneID = simFile[fileIndex]; // Read in the various parameters
507 fileIndex++; 506 fileIndex++;
508 507
509 homezone[hzIndex].X = readHexFromSimfile(&simFile[fileIndex],4); 508 homezone[hzIndex].X = readHexFromSimfile(&simFile[fileIndex],4);
510 fileIndex += 4; 509 fileIndex += 4;
511 homezone[hzIndex].Y = readHexFromSimfile(&simFile[fileIndex],4); 510 homezone[hzIndex].Y = readHexFromSimfile(&simFile[fileIndex],4);
512 fileIndex += 4; 511 fileIndex += 4;
513 homezone[hzIndex].Rsquared = readHexFromSimfile(&simFile[fileIndex],4); 512 homezone[hzIndex].Rsquared = readHexFromSimfile(&simFile[fileIndex],4);
514 fileIndex += 4; 513 fileIndex += 4;
515 514
516 homezone[hzIndex].active = (BOOL) (simFile[fileIndex] & HZ_ACTIVE_FLAG)/HZ_ACTIVE_FLAG; 515 homezone[hzIndex].active = (BOOL) (simFile[fileIndex] & HZ_ACTIVE_FLAG)/HZ_ACTIVE_FLAG;
517 homezone[hzIndex].cityzone = (BOOL) (simFile[fileIndex] & HZ_CITYZONE_FLAG)/HZ_CITYZONE_FLAG; 516 homezone[hzIndex].cityzone = (BOOL) (simFile[fileIndex] & HZ_CITYZONE_FLAG)/HZ_CITYZONE_FLAG;
518 fileIndex++; 517 fileIndex++;
519 518
520 /* Read in the 12-character tag name */ 519 /* Read in the 12-character tag name */
521 520
522 for (tagIndex = 0; tagIndex<HZ_NAME_LENGTH; tagIndex++) 521 for (tagIndex = 0; tagIndex<HZ_NAME_LENGTH; tagIndex++)
523 { 522 {
524 character = (char) simFile[fileIndex]; 523 character = (char) simFile[fileIndex];
525 fileIndex++; 524 fileIndex++;
526 if (character<32 /*|| character>127*/) /*a0393213 - lint warnings removal - 'Relational operator '>' always evaluates to 'false'*/ 525 if (character<32 /*|| character>127*/) /*a0393213 - lint warnings removal - 'Relational operator '>' always evaluates to 'false'*/
527 character = 0; 526 character = 0;
528 homezone[hzIndex].Tag[tagIndex] = character; 527 homezone[hzIndex].Tag[tagIndex] = character;
529 } 528 }
530 homezone[hzIndex].Tag[HZ_NAME_LENGTH] = 0; // Make sure tag is null-terminated 529 homezone[hzIndex].Tag[HZ_NAME_LENGTH] = 0; // Make sure tag is null-terminated
531 530
532 #ifdef TRACE_MMIHOMEZONE 531 #ifdef TRACE_MMIHOMEZONE
533 TRACE_EVENT_P1("Homezone %d:", hzIndex); 532 TRACE_EVENT_P1("Homezone %d:", hzIndex);
534 TRACE_EVENT_P1("ID: %d", homezone[hzIndex].zoneID); 533 TRACE_EVENT_P1("ID: %d", homezone[hzIndex].zoneID);
535 TRACE_EVENT_P1("Active: %d", (UBYTE)homezone[hzIndex].active); 534 TRACE_EVENT_P1("Active: %d", (UBYTE)homezone[hzIndex].active);
536 TRACE_EVENT_P1("Cityzone: %d", (UBYTE)homezone[hzIndex].cityzone); 535 TRACE_EVENT_P1("Cityzone: %d", (UBYTE)homezone[hzIndex].cityzone);
537 TRACE_EVENT_P1("X: %X", homezone[hzIndex].X); 536 TRACE_EVENT_P1("X: %X", homezone[hzIndex].X);
538 TRACE_EVENT_P1("Y: %X", homezone[hzIndex].Y); 537 TRACE_EVENT_P1("Y: %X", homezone[hzIndex].Y);
539 TRACE_EVENT_P1("Rsquared: %X", homezone[hzIndex].Rsquared); 538 TRACE_EVENT_P1("Rsquared: %X", homezone[hzIndex].Rsquared);
540 TRACE_EVENT_P1("Homezone name: %s", homezone[hzIndex].Tag); 539 TRACE_EVENT_P1("Homezone name: %s", homezone[hzIndex].Tag);
541 #endif 540 #endif
542 541
543 } 542 }
544 543
545 return; 544 return;
546 } 545 }
547 546
548 547
549 /******************************************************************************* 548 /*******************************************************************************
550 549
551 $Function: homezoneWriteSim 550 $Function: homezoneWriteSim
552 551
553 $Description: Write homezone data to the SIM 552 $Description: Write homezone data to the SIM
554 SPR 877 - SH - now just writes a single record 553 SPR 877 - SH - now just writes a single record
555 554
556 $Returns: None. 555 $Returns: None.
557 556
558 $Arguments: cache, record 557 $Arguments: cache, record
559 ********************************************************************************/ 558 ********************************************************************************/
560 559
561 void homezoneWriteSim(USHORT field, USHORT record) 560 void homezoneWriteSim(USHORT field, USHORT record)
562 { 561 {
563 T_homezone_data *data = &homezoneData; 562 T_homezone_data *data = &homezoneData;
564 USHORT hzIndex; 563 USHORT hzIndex;
565 UBYTE *simFile; 564 UBYTE *simFile;
566 USHORT fileIndex; 565 USHORT fileIndex;
567 566
568 /* Check if homezone is already switched off */ 567 /* Check if homezone is already switched off */
569 568
570 if (data->received==HZ_RECEIVED_HZ_OFF) 569 if (data->received==HZ_RECEIVED_HZ_OFF)
571 return; 570 return;
572 571
573 TRACE_FUNCTION("homezoneWriteSim()"); 572 TRACE_FUNCTION("homezoneWriteSim()");
574 573
575 hzIndex = field-HZ_SIM_CELL_CACHE; 574 hzIndex = field-HZ_SIM_CELL_CACHE;
576 575
577 #ifdef TRACE_MMIHOMEZONE 576 #ifdef TRACE_MMIHOMEZONE
578 TRACE_EVENT_P4("HZ WRITE field: %X record %d lac %X cid %X", field, record, data->homezone[hzIndex].lac[record-1], data->homezone[hzIndex].cid[record-1]); 577 TRACE_EVENT_P4("HZ WRITE field: %X record %d lac %X cid %X", field, record, data->homezone[hzIndex].lac[record-1], data->homezone[hzIndex].cid[record-1]);
579 #endif 578 #endif
580 579
581 if (data->homezone[hzIndex].active) 580 if (data->homezone[hzIndex].active)
582 { 581 {
583 simFile = data->buffer2; 582 simFile = data->buffer2;
584 fileIndex = 0; 583 fileIndex = 0;
585 writeHexToSimfile(&simFile[fileIndex], data->homezone[hzIndex].lac[record-1], 2 ); 584 writeHexToSimfile(&simFile[fileIndex], data->homezone[hzIndex].lac[record-1], 2 );
586 fileIndex += 2; 585 fileIndex += 2;
587 writeHexToSimfile(&simFile[fileIndex], data->homezone[hzIndex].cid[record-1], 2 ); 586 writeHexToSimfile(&simFile[fileIndex], data->homezone[hzIndex].cid[record-1], 2 );
588 } 587 }
589 588
590 if (!Write_Sim_Record(field, record, HZ_SIM_CELL_CACHE_SIZE, data->buffer2)) 589 if (!Write_Sim_Record(field, record, HZ_SIM_CELL_CACHE_SIZE, data->buffer2))
591 { 590 {
592 TRACE_EVENT("SIM writing error!"); 591 TRACE_EVENT("SIM writing error!");
593 } 592 }
594 return; 593 return;
595 } 594 }
596 595
597 596
598 /******************************************************************************* 597 /*******************************************************************************
599 598
600 $Function: homezoneWriteSimCb 599 $Function: homezoneWriteSimCb
601 600
602 $Description: Write homezone data to the SIM. This function is called after a previous 601 $Description: Write homezone data to the SIM. This function is called after a previous
603 SIM write (or, in the initial case, by homezoneWriteSim above). 602 SIM write (or, in the initial case, by homezoneWriteSim above).
604 SPR877 - SH - Previous functionality no longer required here. 603 SPR877 - SH - Previous functionality no longer required here.
605 604
606 $Returns: None. 605 $Returns: None.
607 606
608 $Arguments: field - the SIM field that is to be written 607 $Arguments: field - the SIM field that is to be written
609 record - the SIM record that is to be written 608 record - the SIM record that is to be written
610 result - the result of the last write attempt 609 result - the result of the last write attempt
611 *******************************************************************************/ 610 *******************************************************************************/
612 611
613 void homezoneWriteSimCb(USHORT field, USHORT record, USHORT result) 612 void homezoneWriteSimCb(USHORT field, USHORT record, USHORT result)
614 { 613 {
615 TRACE_FUNCTION("homezoneWriteSimCb()"); 614 TRACE_FUNCTION("homezoneWriteSimCb()");
616 615
617 #ifdef TRACE_MMIHOMEZONE 616 #ifdef TRACE_MMIHOMEZONE
618 TRACE_EVENT_P1("RESULT: %d", result); 617 TRACE_EVENT_P1("RESULT: %d", result);
619 #endif 618 #endif
620 619
621 return; 620 return;
622 } 621 }
623 622
624 623
625 /******************************************************************************* 624 /*******************************************************************************
626 625
627 $Function: homezoneCBData 626 $Function: homezoneCBData
628 627
629 $Description: Make sure correct homezone CB channel is set up and activate CB 628 $Description: Make sure correct homezone CB channel is set up and activate CB
630 629
631 $Returns: None. 630 $Returns: None.
632 631
633 $Arguments: message - The text of the cell broadcast message 632 $Arguments: message - The text of the cell broadcast message
634 *******************************************************************************/ 633 *******************************************************************************/
635 634
636 void homezoneActivateCB(void) 635 void homezoneActivateCB(void)
637 { 636 {
638 T_homezone_data *data = &homezoneData; 637 T_homezone_data *data = &homezoneData;
639 USHORT index; 638 USHORT index;
640 UBYTE stopSearch; 639 UBYTE stopSearch;
641 USHORT emptyID; 640 USHORT emptyID;
642 641
643 /* Check if homezone is already switched off */ 642 /* Check if homezone is already switched off */
644 643
645 if (data->received==HZ_RECEIVED_HZ_OFF) 644 if (data->received==HZ_RECEIVED_HZ_OFF)
646 return; 645 return;
647 646
648 TRACE_FUNCTION("homezoneActivateCB()"); 647 TRACE_FUNCTION("homezoneActivateCB()");
649 648
650 /* Check table to see if correct channel is included */ 649 /* Check table to see if correct channel is included */
651 650
652 stopSearch = FALSE; 651 stopSearch = FALSE;
653 emptyID = 0xFFFF; 652 emptyID = 0xFFFF;
654 653
655 for (index=0; index<MAX_MIDS && !stopSearch; index++) 654 for (index=0; index<MAX_MIDS && !stopSearch; index++)
656 { 655 {
657 TRACE_EVENT_P2("Mid %d is %X", index, g_smscb_data.CBTopics.entry[index].msg_id); 656 TRACE_EVENT_P2("Mid %d is %X", index, g_smscb_data.CBTopics.entry[index].msg_id);
658 if (g_smscb_data.CBTopics.entry[index].msg_id==HZ_IDENTIFIER) 657 if (g_smscb_data.CBTopics.entry[index].msg_id==HZ_IDENTIFIER)
659 { 658 {
660 stopSearch = TRUE; 659 stopSearch = TRUE;
661 } 660 }
662 else if (g_smscb_data.CBTopics.entry[index].msg_id==NO_MID) 661 else if (g_smscb_data.CBTopics.entry[index].msg_id==NO_MID)
663 { 662 {
664 emptyID = index; 663 emptyID = index;
665 stopSearch = TRUE; 664 stopSearch = TRUE;
666 } 665 }
667 } 666 }
668 667
669 TRACE_EVENT_P1("Emtpy ID %d", emptyID); 668 TRACE_EVENT_P1("Emtpy ID %d", emptyID);
670 669
671 if (emptyID!=0xFFFF && emptyID<MAX_MIDS-1) 670 if (emptyID!=0xFFFF && emptyID<MAX_MIDS-1)
672 { 671 {
673 strncpy (g_smscb_data.CBTopics.entry[emptyID].name, HZ_CB_NAME, CB_TAG_LENGTH); 672 strncpy (g_smscb_data.CBTopics.entry[emptyID].name, HZ_CB_NAME, CB_TAG_LENGTH);
674 g_smscb_data.CBTopics.entry[emptyID].msg_id = HZ_IDENTIFIER; 673 g_smscb_data.CBTopics.entry[emptyID].msg_id = HZ_IDENTIFIER;
675 g_smscb_data.CBTopics.entry[emptyID].dcs = 0; 674 g_smscb_data.CBTopics.entry[emptyID].dcs = 0;
676 675
677 // add a new entry 676 // add a new entry
678 emptyID += 1; 677 emptyID += 1;
679 g_smscb_data.CBTopics.length = emptyID; 678 g_smscb_data.CBTopics.length = emptyID;
680 } 679 }
681 680
682 smscb_setCBsettings(SMSCB_SWITCH_ON); 681 smscb_setCBsettings(SMSCB_SWITCH_ON);
683 return; 682 return;
684 } 683 }
685 684
686 685
687 /******************************************************************************* 686 /*******************************************************************************
688 687
689 $Function: homezoneCBData 688 $Function: homezoneCBData
690 689
691 $Description: A cell broadcast message has been received, containing information about 690 $Description: A cell broadcast message has been received, containing information about
692 the location of the current cell 691 the location of the current cell
693 692
694 $Returns: None. 693 $Returns: None.
695 694
696 $Arguments: message - The text of the cell broadcast message 695 $Arguments: message - The text of the cell broadcast message
697 *******************************************************************************/ 696 *******************************************************************************/
698 697
699 void homezoneCBData(char *message) 698 void homezoneCBData(char *message)
700 { 699 {
701 T_homezone_data *data = &homezoneData; 700 T_homezone_data *data = &homezoneData;
702 701
703 /* Check if homezone is already switched off */ 702 /* Check if homezone is already switched off */
704 703
705 if (data->received==HZ_RECEIVED_HZ_OFF) 704 if (data->received==HZ_RECEIVED_HZ_OFF)
706 return; 705 return;
707 706
708 TRACE_FUNCTION("homezoneCellData()"); 707 TRACE_FUNCTION("homezoneCellData()");
709 708
710 /* Calculate the current position from the text of the message */ 709 /* Calculate the current position from the text of the message */
711 710
712 data->current_X = calculateDecimal( &message[0], HZ_COORD_DIGITS ); 711 data->current_X = calculateDecimal( &message[0], HZ_COORD_DIGITS );
713 data->current_Y = calculateDecimal( &message[HZ_COORD_DIGITS], HZ_COORD_DIGITS ); 712 data->current_Y = calculateDecimal( &message[HZ_COORD_DIGITS], HZ_COORD_DIGITS );
714 713
715 #ifdef TRACE_MMIHOMEZONE 714 #ifdef TRACE_MMIHOMEZONE
716 TRACE_EVENT_P2("current_X: %X, current_Y: %X", data->current_X, data->current_Y); 715 TRACE_EVENT_P2("current_X: %X, current_Y: %X", data->current_X, data->current_Y);
717 #endif 716 #endif
718 717
719 data->received |= HZ_RECEIVED_CB; // We now have received cell broadcast message. 718 data->received |= HZ_RECEIVED_CB; // We now have received cell broadcast message.
720 719
721 /* SPR877 - SH - now only call HZ algorithm if a cell res has recently taken place */ 720 /* SPR877 - SH - now only call HZ algorithm if a cell res has recently taken place */
722 721
723 if (data->received==HZ_RECEIVED_ALL && data->new_cell_res) // If we've received everything, call algorithm. 722 if (data->received==HZ_RECEIVED_ALL && data->new_cell_res) // If we've received everything, call algorithm.
724 { 723 {
725 homezoneLocate(); 724 homezoneLocate();
726 data->new_cell_res = FALSE; 725 data->new_cell_res = FALSE;
727 } 726 }
728 727
729 return; 728 return;
730 } 729 }
731 730
732 731
733 /******************************************************************************* 732 /*******************************************************************************
734 733
735 $Function: homezoneLocate 734 $Function: homezoneLocate
736 735
737 $Description: Looks at coordinates from cell broadcast message and calculates if 736 $Description: Looks at coordinates from cell broadcast message and calculates if
738 they are in a homezone 737 they are in a homezone
739 738
740 $Returns: None 739 $Returns: None
741 740
742 $Arguments: None 741 $Arguments: None
743 742
744 *******************************************************************************/ 743 *******************************************************************************/
745 744
746 void homezoneLocate() 745 void homezoneLocate()
747 { 746 {
748 T_homezone_data *data = &homezoneData; 747 T_homezone_data *data = &homezoneData;
749 T_homezone *homezone = data->homezone; 748 T_homezone *homezone = data->homezone;
750 long deltaX; 749 long deltaX;
751 long deltaY; 750 long deltaY;
752 USHORT hzIndex; 751 USHORT hzIndex;
753 USHORT cacheIndex=0; 752 USHORT cacheIndex=0;
754 U32 Dsquared; 753 U32 Dsquared;
755 BOOL foundInCache; 754 BOOL foundInCache;
756 USHORT cacheFreeSpace=0; 755 USHORT cacheFreeSpace=0;
757 USHORT field; 756 USHORT field;
758 USHORT record=0; 757 USHORT record=0;
759 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 758 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
760 //begin 30439 759 //begin 30439
761 EF_HZCACHE cache; 760 EF_HZCACHE cache;
762 UBYTE exist = 0; 761 UBYTE exist = 0;
763 //end 30439 762 //end 30439
764 763
765 /* Check if homezone is already switched off */ 764 /* Check if homezone is already switched off */
766 765
767 if (data->received==HZ_RECEIVED_HZ_OFF) 766 if (data->received==HZ_RECEIVED_HZ_OFF)
768 return; 767 return;
769 768
770 TRACE_FUNCTION("homezoneLocate()"); 769 TRACE_FUNCTION("homezoneLocate()");
771 770
772 data->current_zone = HZ_NOT_IN_ZONE; // We don't know if we're in a homezone yet (homezones = 0 to 3) 771 data->current_zone = HZ_NOT_IN_ZONE; // We don't know if we're in a homezone yet (homezones = 0 to 3)
773 field = HZ_NOT_IN_ZONE; // The cache to update 772 field = HZ_NOT_IN_ZONE; // The cache to update
774 773
775 /* Work out if we're in a homezone using current_X and current_Y, received from CB message */ 774 /* Work out if we're in a homezone using current_X and current_Y, received from CB message */
776 775
777 if (data->received == HZ_RECEIVED_ALL) 776 if (data->received == HZ_RECEIVED_ALL)
778 { 777 {
779 #ifdef TRACE_MMIHOMEZONE 778 #ifdef TRACE_MMIHOMEZONE
780 TRACE_EVENT_P2("Current cell X: %X, Y: %X", data->current_X,data->current_Y); 779 TRACE_EVENT_P2("Current cell X: %X, Y: %X", data->current_X,data->current_Y);
781 #endif 780 #endif
782 781
783 /* Check to see if (current_X,current_Y) is in any of the defined homezones */ 782 /* Check to see if (current_X,current_Y) is in any of the defined homezones */
784 783
785 for (hzIndex=0; hzIndex<HZ_ZONES_MAX && data->current_zone==HZ_NOT_IN_ZONE; hzIndex++) // For each homezone... 784 for (hzIndex=0; hzIndex<HZ_ZONES_MAX && data->current_zone==HZ_NOT_IN_ZONE; hzIndex++) // For each homezone...
786 { 785 {
787 #ifdef TRACE_MMIHOMEZONE 786 #ifdef TRACE_MMIHOMEZONE
788 TRACE_EVENT_P1("Homezone %d...", hzIndex); 787 TRACE_EVENT_P1("Homezone %d...", hzIndex);
789 TRACE_EVENT_P3("Has coords X: %X, Y: %X, R2: %X", homezone[hzIndex].X, homezone[hzIndex].Y, homezone[hzIndex].Rsquared); 788 TRACE_EVENT_P3("Has coords X: %X, Y: %X, R2: %X", homezone[hzIndex].X, homezone[hzIndex].Y, homezone[hzIndex].Rsquared);
790 #endif 789 #endif
791 790
792 if (homezone[hzIndex].active) // Provided the homezone is active 791 if (homezone[hzIndex].active) // Provided the homezone is active
793 { 792 {
794 #ifdef TRACE_MMIHOMEZONE // Calculate X and Y distance 793 #ifdef TRACE_MMIHOMEZONE // Calculate X and Y distance
795 TRACE_EVENT("Is active."); 794 TRACE_EVENT("Is active.");
796 #endif 795 #endif
797 deltaX = labs(data->current_X-homezone[hzIndex].X); // between centre of current cell 796 deltaX = labs(data->current_X-homezone[hzIndex].X); // between centre of current cell
798 deltaY = labs(data->current_Y-homezone[hzIndex].Y); // and centre of the homezone 797 deltaY = labs(data->current_Y-homezone[hzIndex].Y); // and centre of the homezone
799 #ifdef TRACE_MMIHOMEZONE 798 #ifdef TRACE_MMIHOMEZONE
800 TRACE_EVENT_P1("deltaX = %d",deltaX); 799 TRACE_EVENT_P1("deltaX = %d",deltaX);
801 TRACE_EVENT_P1("deltaY = %d",deltaY); 800 TRACE_EVENT_P1("deltaY = %d",deltaY);
802 #endif 801 #endif
803 if (deltaX<=HZ_DISTANCE_MAX && deltaY<=HZ_DISTANCE_MAX) // If not too far... 802 if (deltaX<=HZ_DISTANCE_MAX && deltaY<=HZ_DISTANCE_MAX) // If not too far...
804 { 803 {
805 Dsquared = deltaX*deltaX+deltaY*deltaY; // Calculate the resultant distance squared 804 Dsquared = deltaX*deltaX+deltaY*deltaY; // Calculate the resultant distance squared
806 #ifdef TRACE_MMIHOMEZONE 805 #ifdef TRACE_MMIHOMEZONE
807 TRACE_EVENT_P1("Dsquared = %d",Dsquared); 806 TRACE_EVENT_P1("Dsquared = %d",Dsquared);
808 #endif 807 #endif
809 if (Dsquared <= homezone[hzIndex].Rsquared) // If within radius of homezone squared 808 if (Dsquared <= homezone[hzIndex].Rsquared) // If within radius of homezone squared
810 { 809 {
811 #ifdef TRACE_MMIHOMEZONE 810 #ifdef TRACE_MMIHOMEZONE
812 TRACE_EVENT("Contains the current cell."); 811 TRACE_EVENT("Contains the current cell.");
813 #endif 812 #endif
814 data->current_zone = hzIndex; // Current zone is this homezone 813 data->current_zone = hzIndex; // Current zone is this homezone
815 814
816 if (!homezone[hzIndex].cityzone) // Then: if it's not a cityzone 815 if (!homezone[hzIndex].cityzone) // Then: if it's not a cityzone
817 { 816 {
818 #ifdef TRACE_MMIHOMEZONE 817 #ifdef TRACE_MMIHOMEZONE
819 TRACE_EVENT("Is not a cityzone."); 818 TRACE_EVENT("Is not a cityzone.");
820 #endif 819 #endif
821 foundInCache = FALSE; // Look through the cache for this 820 foundInCache = FALSE; // Look through the cache for this
822 cacheFreeSpace = HZ_CACHE_MAX; // homezone to see if cell is listed 821 cacheFreeSpace = HZ_CACHE_MAX; // homezone to see if cell is listed
823 822
824 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX && !foundInCache; cacheIndex++) 823 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX && !foundInCache; cacheIndex++)
825 { 824 {
826 if (data->cid==homezone[hzIndex].cid[cacheIndex]) 825 if (data->cid==homezone[hzIndex].cid[cacheIndex])
827 { 826 {
828 foundInCache = TRUE; // We've found it! 827 foundInCache = TRUE; // We've found it!
829 } 828 }
830 if (homezone[hzIndex].cid[cacheIndex]==0 && cacheFreeSpace==HZ_CACHE_MAX) 829 if (homezone[hzIndex].cid[cacheIndex]==0 && cacheFreeSpace==HZ_CACHE_MAX)
831 cacheFreeSpace = cacheIndex; // Or we've found an empty space 830 cacheFreeSpace = cacheIndex; // Or we've found an empty space
832 } 831 }
833 832
834 if (!foundInCache) // If not there, need to add it 833 if (!foundInCache) // If not there, need to add it
835 { 834 {
836 #ifdef TRACE_MMIHOMEZONE 835 #ifdef TRACE_MMIHOMEZONE
837 TRACE_EVENT("Is not in the cache."); 836 TRACE_EVENT("Is not in the cache.");
838 #endif 837 #endif
839 if (cacheFreeSpace==HZ_CACHE_MAX) // If we didn't find a free space... 838 if (cacheFreeSpace==HZ_CACHE_MAX) // If we didn't find a free space...
840 { 839 {
841 cacheFreeSpace = rand() % HZ_CACHE_MAX; // Choose a random entry 840 cacheFreeSpace = rand() % HZ_CACHE_MAX; // Choose a random entry
842 } 841 }
843 homezone[hzIndex].cid[cacheFreeSpace] = data->cid; // And store current cell there 842 homezone[hzIndex].cid[cacheFreeSpace] = data->cid; // And store current cell there
844 homezone[hzIndex].lac[cacheFreeSpace] = data->lac; // with its location area code 843 homezone[hzIndex].lac[cacheFreeSpace] = data->lac; // with its location area code
845 844
846 field = hzIndex+HZ_SIM_CELL_CACHE; // We've changed the cache 845 field = hzIndex+HZ_SIM_CELL_CACHE; // We've changed the cache
847 record = cacheFreeSpace+1; 846 record = cacheFreeSpace+1;
848 847
849 #ifdef TRACE_MMIHOMEZONE 848 #ifdef TRACE_MMIHOMEZONE
850 TRACE_EVENT_P1("Have added to cache, entry %d.",cacheFreeSpace); 849 TRACE_EVENT_P1("Have added to cache, entry %d.",cacheFreeSpace);
851 #endif 850 #endif
852 } 851 }
853 } 852 }
854 } 853 }
855 else // If we're not in the homezone... 854 else // If we're not in the homezone...
856 { 855 {
857 foundInCache = FALSE; // Look through the cache for this 856 foundInCache = FALSE; // Look through the cache for this
858 // homezone to see if cell is listed 857 // homezone to see if cell is listed
859 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX && !foundInCache; cacheIndex++) 858 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX && !foundInCache; cacheIndex++)
860 { 859 {
861 if (data->cid==homezone[hzIndex].cid[cacheIndex]) 860 if (data->cid==homezone[hzIndex].cid[cacheIndex])
862 { 861 {
863 foundInCache = TRUE; // We've found it! 862 foundInCache = TRUE; // We've found it!
864 cacheFreeSpace = cacheIndex; // Record where it is 863 cacheFreeSpace = cacheIndex; // Record where it is
865 break; 864 break;
866 } 865 }
867 } 866 }
868 867
869 if (foundInCache) // If it's there... 868 if (foundInCache) // If it's there...
870 { 869 {
871 #ifdef TRACE_MMIHOMEZONE 870 #ifdef TRACE_MMIHOMEZONE
872 TRACE_EVENT("Is in the cache and shouldn't be."); 871 TRACE_EVENT("Is in the cache and shouldn't be.");
873 #endif 872 #endif
874 homezone[hzIndex].cid[cacheFreeSpace] = 0; // ...remove it 873 homezone[hzIndex].cid[cacheFreeSpace] = 0; // ...remove it
875 field = hzIndex+HZ_SIM_CELL_CACHE; // We've changed the cache 874 field = hzIndex+HZ_SIM_CELL_CACHE; // We've changed the cache
876 record = cacheFreeSpace+1; 875 record = cacheFreeSpace+1;
877 data->current_zone = HZ_NOT_IN_ZONE; // We're not in this zone 876 data->current_zone = HZ_NOT_IN_ZONE; // We're not in this zone
878 } 877 }
879 #ifdef TRACE_MMIHOMEZONE 878 #ifdef TRACE_MMIHOMEZONE
880 else 879 else
881 { 880 {
882 TRACE_EVENT("Isn't in the cache and shouldn't be."); 881 TRACE_EVENT("Isn't in the cache and shouldn't be.");
883 } 882 }
884 #endif 883 #endif
885 } 884 }
886 885
887 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 886 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
888 //begin 30439 887 //begin 30439
889 /* check if the cid is already in cache */ 888 /* check if the cid is already in cache */
890 for (cacheIndex=0; cacheIndex<HZ_RECENT_MAX; cacheIndex++) /*a0393213 - lint warnings removal - HZ_CACHE_MAX changed to HZ_RECENT_MAX*/ 889 for (cacheIndex=0; cacheIndex<HZ_RECENT_MAX; cacheIndex++) /*a0393213 - lint warnings removal - HZ_CACHE_MAX changed to HZ_RECENT_MAX*/
891 { 890 {
892 if (data->recent_cell[cacheIndex] == data->cid) 891 if (data->recent_cell[cacheIndex] == data->cid)
893 exist = 1; 892 exist = 1;
894 } 893 }
895 /* Replace oldest cell in dynamic cache with new cell */ 894 /* Replace oldest cell in dynamic cache with new cell */
896 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 895 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
897 //begin 30439 896 //begin 30439
898 //Added a conditional statement 897 //Added a conditional statement
899 if (!exist) 898 if (!exist)
900 { 899 {
901 data->recent_cell_index++; 900 data->recent_cell_index++;
902 if (data->recent_cell_index>=HZ_RECENT_MAX) 901 if (data->recent_cell_index>=HZ_RECENT_MAX)
903 data->recent_cell_index = 0; 902 data->recent_cell_index = 0;
904 #ifdef TRACE_MMIHOMEZONE 903 #ifdef TRACE_MMIHOMEZONE
905 TRACE_EVENT_P1("Adding to recent list, index = %d", data->recent_cell_index); 904 TRACE_EVENT_P1("Adding to recent list, index = %d", data->recent_cell_index);
906 #endif 905 #endif
907 data->recent_cell[data->recent_cell_index] = data->cid; 906 data->recent_cell[data->recent_cell_index] = data->cid;
908 data->recent_cell_zone[data->recent_cell_index] = data->current_zone; 907 data->recent_cell_zone[data->recent_cell_index] = data->current_zone;
909 908
910 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 909 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
911 //begin 30439 910 //begin 30439
912 /* write cache to PCM */ 911 /* write cache to PCM */
913 writeHexToSimfile(&cache.cid[0], data->recent_cell[data->recent_cell_index], 2 ); 912 writeHexToSimfile(&cache.cid[0], data->recent_cell[data->recent_cell_index], 2 );
914 cache.zone = data->recent_cell_zone[data->recent_cell_index]; 913 cache.zone = data->recent_cell_zone[data->recent_cell_index];
915 /* write cache to PCM */ 914 /* write cache to PCM */
916 pcm_WriteRecord((UBYTE *)EF_HZCACHE_ID, 915 pcm_WriteRecord((UBYTE *)EF_HZCACHE_ID,
917 (USHORT)(data->recent_cell_index+1), 916 (USHORT)(data->recent_cell_index+1),
918 SIZE_EF_HZCACHE, 917 SIZE_EF_HZCACHE,
919 &cache.cid[0]); 918 &cache.cid[0]);
920 919
921 } 920 }
922 //end 30439 921 //end 30439
923 #ifdef TRACE_MMIHOMEZONE 922 #ifdef TRACE_MMIHOMEZONE
924 for (cacheIndex = 0; cacheIndex<HZ_RECENT_MAX; cacheIndex++) 923 for (cacheIndex = 0; cacheIndex<HZ_RECENT_MAX; cacheIndex++)
925 { 924 {
926 TRACE_EVENT_P3("Recent cache %d: CID %X, zone %X",cacheIndex, data->recent_cell[cacheIndex], data->recent_cell_zone[cacheIndex]); 925 TRACE_EVENT_P3("Recent cache %d: CID %X, zone %X",cacheIndex, data->recent_cell[cacheIndex], data->recent_cell_zone[cacheIndex]);
927 } 926 }
928 #endif 927 #endif
929 } 928 }
930 929
931 } 930 }
932 931
933 } 932 }
934 933
935 } 934 }
936 935
937 #ifdef TRACE_MMIHOMEZONE 936 #ifdef TRACE_MMIHOMEZONE
938 TRACE_EVENT("CACHES AFTER UPDATE"); 937 TRACE_EVENT("CACHES AFTER UPDATE");
939 for (hzIndex=0; hzIndex<HZ_ZONES_MAX; hzIndex++) // For each homezone... 938 for (hzIndex=0; hzIndex<HZ_ZONES_MAX; hzIndex++) // For each homezone...
940 { 939 {
941 /* x0083025 on Sep 14, 2007 for OMAPS00145865 (adrian) */ 940 /* x0083025 on Sep 14, 2007 for OMAPS00145865 (adrian) */
942 MMI_TRACE_EVENT_P2("Zone %d (%s)", hzIndex, homezone[hzIndex].Tag); 941 MMI_TRACE_EVENT_P2("Zone %d (%s)", hzIndex, homezone[hzIndex].Tag);
943 942
944 if (homezone[hzIndex].active && !homezone[hzIndex].cityzone) // If it's active, and not a cityzone 943 if (homezone[hzIndex].active && !homezone[hzIndex].cityzone) // If it's active, and not a cityzone
945 { 944 {
946 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX; cacheIndex++) // Check the cache. 945 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX; cacheIndex++) // Check the cache.
947 { 946 {
948 TRACE_EVENT_P3("Cache %d: lac %X, cid %X", cacheIndex, homezone[hzIndex].lac[cacheIndex], homezone[hzIndex].cid[cacheIndex]); 947 TRACE_EVENT_P3("Cache %d: lac %X, cid %X", cacheIndex, homezone[hzIndex].lac[cacheIndex], homezone[hzIndex].cid[cacheIndex]);
949 } 948 }
950 } 949 }
951 } 950 }
952 #endif 951 #endif
953 /* Update icon/text tag. */ 952 /* Update icon/text tag. */
954 953
955 homezoneUpdateDisplay(); 954 homezoneUpdateDisplay();
956 955
957 /* Write data back to SIM if cache has changed & SIM files present */ 956 /* Write data back to SIM if cache has changed & SIM files present */
958 957
959 if (field!=HZ_NOT_IN_ZONE && (data->received & HZ_RECEIVED_SIMDATA)) 958 if (field!=HZ_NOT_IN_ZONE && (data->received & HZ_RECEIVED_SIMDATA))
960 { 959 {
961 homezoneWriteSim(field, record); 960 homezoneWriteSim(field, record);
962 } 961 }
963 962
964 return; 963 return;
965 } 964 }
966 965
967 966
968 /******************************************************************************* 967 /*******************************************************************************
969 968
970 $Function: homezoneUpdate 969 $Function: homezoneUpdate
971 970
972 $Description: Main homezone function; check whether MS is in a homezone or not 971 $Description: Main homezone function; check whether MS is in a homezone or not
973 972
974 $Returns: 973 $Returns:
975 974
976 $Arguments: lac - the location area code of the current cell (on cell reselection) 975 $Arguments: lac - the location area code of the current cell (on cell reselection)
977 cid - the ID of the current cell (on cell reselection) 976 cid - the ID of the current cell (on cell reselection)
978 keep - 1: no change in lac and cid 977 keep - 1: no change in lac and cid
979 *******************************************************************************/ 978 *******************************************************************************/
980 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 979 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
981 //begin 30439 980 //begin 30439
982 //Added an extra argument in the function -- "keep" 981 //Added an extra argument in the function -- "keep"
983 void homezoneUpdate(USHORT lac, USHORT cid, UBYTE keep) 982 void homezoneUpdate(USHORT lac, USHORT cid, UBYTE keep)
984 { 983 {
985 T_homezone_data *data = &homezoneData; 984 T_homezone_data *data = &homezoneData;
986 T_homezone *homezone = data->homezone; 985 T_homezone *homezone = data->homezone;
987 USHORT hzIndex; 986 USHORT hzIndex;
988 USHORT cacheIndex; 987 USHORT cacheIndex;
989 UBYTE inCache = 0; 988 UBYTE inCache = 0;
990 989
991 /* Check if homezone is already switched off */ 990 /* Check if homezone is already switched off */
992 991
993 TRACE_EVENT_P1("Data received: %d", data->received); 992 TRACE_EVENT_P1("Data received: %d", data->received);
994 993
995 if (data->received==HZ_RECEIVED_HZ_OFF) 994 if (data->received==HZ_RECEIVED_HZ_OFF)
996 return; 995 return;
997 996
998 TRACE_FUNCTION("homezoneUpdate()"); 997 TRACE_FUNCTION("homezoneUpdate()");
999 998
1000 data->current_zone = HZ_NOT_IN_ZONE; // We don't know if we're in a homezone yet (homezones = 0 to 3) 999 data->current_zone = HZ_NOT_IN_ZONE; // We don't know if we're in a homezone yet (homezones = 0 to 3)
1001 data->received |= HZ_RECEIVED_CELLRES; // Have received this event 1000 data->received |= HZ_RECEIVED_CELLRES; // Have received this event
1002 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 1001 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
1003 //Modified to add a conditional statement 1002 //Modified to add a conditional statement
1004 //begin 30439 1003 //begin 30439
1005 if (!keep) 1004 if (!keep)
1006 { 1005 {
1007 data->lac = lac; 1006 data->lac = lac;
1008 data->cid = cid; 1007 data->cid = cid;
1009 } 1008 }
1010 /* keep the current lac and cid */ 1009 /* keep the current lac and cid */
1011 else 1010 else
1012 { 1011 {
1013 lac = data->lac; 1012 lac = data->lac;
1014 cid = data->cid; 1013 cid = data->cid;
1015 } 1014 }
1016 //end 30439 1015 //end 30439
1017 1016
1018 #ifdef TRACE_MMIHOMEZONE 1017 #ifdef TRACE_MMIHOMEZONE
1019 TRACE_EVENT_P3("lac: %X, cid: %X, received: %d", lac, cid, data->received); 1018 TRACE_EVENT_P3("lac: %X, cid: %X, received: %d", lac, cid, data->received);
1020 #endif 1019 #endif
1021 1020
1022 /* If either are zero or -1, the reselection data is invalid */ 1021 /* If either are zero or -1, the reselection data is invalid */
1023 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 1022 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
1024 //Modified to add a conditional statement 1023 //Modified to add a conditional statement
1025 if (((lac==0 || cid==0) || (lac==0xFFFF || cid==0xFFFF)) AND !keep) 1024 if (((lac==0 || cid==0) || (lac==0xFFFF || cid==0xFFFF)) AND !keep)
1026 { 1025 {
1027 TRACE_EVENT_P1("homezoneUpdateDisplay ~HZ_RECEIVED_CELLRES keep=%d", keep); 1026 TRACE_EVENT_P1("homezoneUpdateDisplay ~HZ_RECEIVED_CELLRES keep=%d", keep);
1028 //end 30439 1027 //end 30439
1029 data->received &= (~HZ_RECEIVED_CELLRES); 1028 data->received &= (~HZ_RECEIVED_CELLRES);
1030 homezoneUpdateDisplay(); 1029 homezoneUpdateDisplay();
1031 return; 1030 return;
1032 } 1031 }
1033 1032
1034 data->new_cell_res = TRUE; // Cell res just occurred 1033 data->new_cell_res = TRUE; // Cell res just occurred
1035 1034
1036 /* Must have received SIM data to continue*/ 1035 /* Must have received SIM data to continue*/
1037 1036
1038 if (!(data->received & HZ_RECEIVED_SIMDATA)) 1037 if (!(data->received & HZ_RECEIVED_SIMDATA))
1039 return; 1038 return;
1040 1039
1041 /* Check homezone cache for each homezone */ 1040 /* Check homezone cache for each homezone */
1042 /* Can do this even if we haven't received the CB message */ 1041 /* Can do this even if we haven't received the CB message */
1043 1042
1044 #ifdef TRACE_MMIHOMEZONE 1043 #ifdef TRACE_MMIHOMEZONE
1045 TRACE_EVENT("Checking zone caches..."); 1044 TRACE_EVENT("Checking zone caches...");
1046 #endif 1045 #endif
1047 1046
1048 for (hzIndex=0; hzIndex<HZ_ZONES_MAX && data->current_zone==HZ_NOT_IN_ZONE; hzIndex++) // For each homezone... 1047 for (hzIndex=0; hzIndex<HZ_ZONES_MAX && data->current_zone==HZ_NOT_IN_ZONE; hzIndex++) // For each homezone...
1049 { 1048 {
1050 #ifdef TRACE_MMIHOMEZONE 1049 #ifdef TRACE_MMIHOMEZONE
1051 /* x0083025 on Sep 14, 2007 for OMAPS00145865 (adrian) */ 1050 /* x0083025 on Sep 14, 2007 for OMAPS00145865 (adrian) */
1052 MMI_TRACE_EVENT_P2("Zone %d (%s)", hzIndex, homezone[hzIndex].Tag); 1051 MMI_TRACE_EVENT_P2("Zone %d (%s)", hzIndex, homezone[hzIndex].Tag);
1053 #endif 1052 #endif
1054 1053
1055 if (homezone[hzIndex].active && !homezone[hzIndex].cityzone) // If it's active, and not a cityzone 1054 if (homezone[hzIndex].active && !homezone[hzIndex].cityzone) // If it's active, and not a cityzone
1056 { 1055 {
1057 #ifdef TRACE_MMIHOMEZONE 1056 #ifdef TRACE_MMIHOMEZONE
1058 TRACE_EVENT("Is Active."); 1057 TRACE_EVENT("Is Active.");
1059 #endif 1058 #endif
1060 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX && data->current_zone==HZ_NOT_IN_ZONE; cacheIndex++) // Check the cache. 1059 for (cacheIndex=0; cacheIndex<HZ_CACHE_MAX && data->current_zone==HZ_NOT_IN_ZONE; cacheIndex++) // Check the cache.
1061 { 1060 {
1062 #ifdef TRACE_MMIHOMEZONE 1061 #ifdef TRACE_MMIHOMEZONE
1063 TRACE_EVENT_P3("Cache %d: lac %X, cid %X", cacheIndex, homezone[hzIndex].lac[cacheIndex], homezone[hzIndex].cid[cacheIndex]); 1062 TRACE_EVENT_P3("Cache %d: lac %X, cid %X", cacheIndex, homezone[hzIndex].lac[cacheIndex], homezone[hzIndex].cid[cacheIndex]);
1064 #endif 1063 #endif
1065 1064
1066 if (cid==homezone[hzIndex].cid[cacheIndex]) // If the current cell is in the cache.... 1065 if (cid==homezone[hzIndex].cid[cacheIndex]) // If the current cell is in the cache....
1067 { 1066 {
1068 #ifdef TRACE_MMIHOMEZONE 1067 #ifdef TRACE_MMIHOMEZONE
1069 TRACE_EVENT_P1("Cell found in cache %d.",cacheIndex); 1068 TRACE_EVENT_P1("Cell found in cache %d.",cacheIndex);
1070 #endif 1069 #endif
1071 data->current_zone = hzIndex; // Then this is our current homezone! 1070 data->current_zone = hzIndex; // Then this is our current homezone!
1072 inCache = 1; 1071 inCache = 1;
1073 } 1072 }
1074 } 1073 }
1075 if (!inCache AND hzFlag) 1074 if (!inCache AND hzFlag)
1076 { 1075 {
1077 hzFlag = 0; 1076 hzFlag = 0;
1078 TRACE_EVENT ("not in cache, caculate needed"); 1077 TRACE_EVENT ("not in cache, caculate needed");
1079 homezoneLocate(); 1078 homezoneLocate();
1080 return; 1079 return;
1081 } 1080 }
1082 else 1081 else
1083 inCache = 0; 1082 inCache = 0;
1084 } 1083 }
1085 } 1084 }
1086 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 1085 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
1087 //added a conditional statement 1086 //added a conditional statement
1088 //begin 30439 1087 //begin 30439
1089 /* If we didn't find a homezone, check recent cells cache to see if we're in a cityzone */ 1088 /* If we didn't find a homezone, check recent cells cache to see if we're in a cityzone */
1090 for (hzIndex=0; hzIndex<HZ_ZONES_MAX && data->current_zone==HZ_NOT_IN_ZONE; hzIndex++) // For each homezone... 1089 for (hzIndex=0; hzIndex<HZ_ZONES_MAX && data->current_zone==HZ_NOT_IN_ZONE; hzIndex++) // For each homezone...
1091 { 1090 {
1092 #ifdef TRACE_MMIHOMEZONE 1091 #ifdef TRACE_MMIHOMEZONE
1093 /* x0083025 on Sep 14, 2007 for OMAPS00145865 (adrian) */ 1092 /* x0083025 on Sep 14, 2007 for OMAPS00145865 (adrian) */
1094 MMI_TRACE_EVENT_P2("Zone %d (%s)", hzIndex, homezone[hzIndex].Tag); 1093 MMI_TRACE_EVENT_P2("Zone %d (%s)", hzIndex, homezone[hzIndex].Tag);
1095 #endif 1094 #endif
1096 1095
1097 if (homezone[hzIndex].active && homezone[hzIndex].cityzone) // If it's active, and not a cityzone 1096 if (homezone[hzIndex].active && homezone[hzIndex].cityzone) // If it's active, and not a cityzone
1098 { 1097 {
1099 #ifdef TRACE_MMIHOMEZONE 1098 #ifdef TRACE_MMIHOMEZONE
1100 TRACE_EVENT("Is Active."); 1099 TRACE_EVENT("Is Active.");
1101 #endif 1100 #endif
1102 1101
1103 for (cacheIndex=0; cacheIndex<HZ_RECENT_MAX && data->current_zone==HZ_NOT_IN_ZONE; cacheIndex++) // Check the cache. 1102 for (cacheIndex=0; cacheIndex<HZ_RECENT_MAX && data->current_zone==HZ_NOT_IN_ZONE; cacheIndex++) // Check the cache.
1104 { 1103 {
1105 #ifdef TRACE_MMIHOMEZONE 1104 #ifdef TRACE_MMIHOMEZONE
1106 TRACE_EVENT_P5("Cache %d: lac %X, cid %X, data->recent_cell %X, data->recent_cell_zone %d", cacheIndex, homezone[hzIndex].lac[cacheIndex], homezone[hzIndex].cid[cacheIndex], data->recent_cell[cacheIndex], data->recent_cell_zone[cacheIndex]); 1105 TRACE_EVENT_P5("Cache %d: lac %X, cid %X, data->recent_cell %X, data->recent_cell_zone %d", cacheIndex, homezone[hzIndex].lac[cacheIndex], homezone[hzIndex].cid[cacheIndex], data->recent_cell[cacheIndex], data->recent_cell_zone[cacheIndex]);
1107 #endif 1106 #endif
1108 1107
1109 if (cid==data->recent_cell[cacheIndex] && data->recent_cell_zone[cacheIndex]!=HZ_NOT_IN_ZONE) // If we're in that cell 1108 if (cid==data->recent_cell[cacheIndex] && data->recent_cell_zone[cacheIndex]!=HZ_NOT_IN_ZONE) // If we're in that cell
1110 { 1109 {
1111 #ifdef TRACE_MMIHOMEZONE 1110 #ifdef TRACE_MMIHOMEZONE
1112 TRACE_EVENT_P1("FOUND cityzone in cache %d.",cacheIndex); 1111 TRACE_EVENT_P1("FOUND cityzone in cache %d.",cacheIndex);
1113 #endif 1112 #endif
1114 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858 1113 //Jun 14, 2005 REF: MMI-FIX-30439 x0018858
1115 //Modified to directly assign value 1114 //Modified to directly assign value
1116 data->current_zone = hzIndex; // Then this is our current homezone! 1115 data->current_zone = hzIndex; // Then this is our current homezone!
1117 inCache = 1; 1116 inCache = 1;
1118 } 1117 }
1119 if (!inCache AND hzFlag) 1118 if (!inCache AND hzFlag)
1120 { 1119 {
1121 hzFlag = 0; 1120 hzFlag = 0;
1122 TRACE_EVENT ("not in cache, caculate needed"); 1121 TRACE_EVENT ("not in cache, caculate needed");
1123 homezoneLocate(); 1122 homezoneLocate();
1124 return; 1123 return;
1125 } 1124 }
1126 else 1125 else
1127 inCache = 0; 1126 inCache = 0;
1128 } 1127 }
1129 } 1128 }
1130 } 1129 }
1131 1130
1132 homezoneUpdateDisplay(); // Update icon/text tag. 1131 homezoneUpdateDisplay(); // Update icon/text tag.
1133 1132
1134 return; 1133 return;
1135 } 1134 }
1136 1135
1137 1136
1138 /******************************************************************************* 1137 /*******************************************************************************
1139 1138
1140 $Function: homezoneUpdateDisplay 1139 $Function: homezoneUpdateDisplay
1141 1140
1142 $Description: 1141 $Description:
1143 1142
1144 $Returns: Updates the homezone icon and text string appropriately 1143 $Returns: Updates the homezone icon and text string appropriately
1145 1144
1146 $Arguments: none 1145 $Arguments: none
1147 *******************************************************************************/ 1146 *******************************************************************************/
1148 1147
1149 void homezoneUpdateDisplay(void) 1148 void homezoneUpdateDisplay(void)
1150 { 1149 {
1151 T_homezone_data *data = &homezoneData; 1150 T_homezone_data *data = &homezoneData;
1152 1151
1153 TRACE_FUNCTION("homezoneUpdateDisplay()"); 1152 TRACE_FUNCTION("homezoneUpdateDisplay()");
1154 1153
1155 iconsDeleteState(iconIdHomezone); 1154 iconsDeleteState(iconIdHomezone);
1156 1155
1157 #ifdef FF_MMI_SAT_ICON 1156 #ifdef FF_MMI_SAT_ICON
1158 addSatMessage(NULL, 0, 0, NULL, FALSE, SAT_ICON_NONE); 1157 addSatMessage(NULL, 0, 0, NULL, FALSE, SAT_ICON_NONE);
1159 #else 1158 #else
1160 addSatMessage(NULL); 1159 addSatMessage(NULL);
1161 #endif 1160 #endif
1162 1161
1163 if (data->current_zone!=HZ_NOT_IN_ZONE) // If not in a homezone, leave blank 1162 if (data->current_zone!=HZ_NOT_IN_ZONE) // If not in a homezone, leave blank
1164 { 1163 {
1165 //x0035544 Mar 14, 2006 DR:OMAPS00061468 1164 //x0035544 Mar 14, 2006 DR:OMAPS00061468
1166 #ifdef FF_MMI_SAT_ICON 1165 #ifdef FF_MMI_SAT_ICON
1167 addSatMessage(data->homezone[data->current_zone].Tag, 0, 0, NULL, FALSE, SAT_ICON_NONE); 1166 addSatMessage(data->homezone[data->current_zone].Tag, 0, 0, NULL, FALSE, SAT_ICON_NONE);
1168 #else 1167 #else
1169 addSatMessage(data->homezone[data->current_zone].Tag); 1168 addSatMessage(data->homezone[data->current_zone].Tag);
1170 #endif 1169 #endif
1171 if (!data->homezone[data->current_zone].cityzone) // Display icon if homezone rather than cityzone 1170 if (!data->homezone[data->current_zone].cityzone) // Display icon if homezone rather than cityzone
1172 { 1171 {
1173 iconsSetState(iconIdHomezone); 1172 iconsSetState(iconIdHomezone);
1174 } 1173 }
1175 } 1174 }
1176 1175
1177 return; 1176 return;
1178 } 1177 }
1179 1178
1180 1179
1181 /******************************************************************************* 1180 /*******************************************************************************
1182 1181
1183 $Function: calculateDecimal 1182 $Function: calculateDecimal
1184 1183
1185 $Description: 1184 $Description:
1186 1185
1187 $Returns: Returns a decimal number from a string of ascii digits 1186 $Returns: Returns a decimal number from a string of ascii digits
1188 1187
1189 $Arguments: none 1188 $Arguments: none
1190 *******************************************************************************/ 1189 *******************************************************************************/
1191 1190
1192 static U32 calculateDecimal( char *string, int length ) 1191 static U32 calculateDecimal( char *string, int length )
1193 { 1192 {
1194 U32 total = 0; 1193 U32 total = 0;
1195 int index; 1194 int index;
1196 1195
1197 /* decode each decimal character in turn */ 1196 /* decode each decimal character in turn */
1198 for (index = 0; index < length; index++ ) 1197 for (index = 0; index < length; index++ )
1199 { 1198 {
1200 if (string[index]>='0' && string[index]<='9') 1199 if (string[index]>='0' && string[index]<='9')
1201 { 1200 {
1202 total = ( total * 10 ) + ( string[index] - '0' ); 1201 total = ( total * 10 ) + ( string[index] - '0' );
1203 } 1202 }
1204 } 1203 }
1205 1204
1206 return total; 1205 return total;
1207 } 1206 }
1208 1207
1209 /******************************************************************************* 1208 /*******************************************************************************
1210 1209
1211 $Function: readHexFromSimfile 1210 $Function: readHexFromSimfile
1212 1211
1213 $Description: Reads a hex string (MSB first) from a sim file 1212 $Description: Reads a hex string (MSB first) from a sim file
1214 1213
1215 $Returns: The hex number 1214 $Returns: The hex number
1216 1215
1217 $Arguments: simFile - the point in the simFile at which the string occurs 1216 $Arguments: simFile - the point in the simFile at which the string occurs
1218 length - the length of the string 1217 length - the length of the string
1219 *******************************************************************************/ 1218 *******************************************************************************/
1220 1219
1221 static U32 readHexFromSimfile( UBYTE *simFile, int length ) 1220 static U32 readHexFromSimfile( UBYTE *simFile, int length )
1222 { 1221 {
1223 U32 total = 0; 1222 U32 total = 0;
1224 int index; 1223 int index;
1225 1224
1226 for ( index = 0; index < length; index++ ) 1225 for ( index = 0; index < length; index++ )
1227 { 1226 {
1228 total = ( total << 8 ) + simFile[index]; 1227 total = ( total << 8 ) + simFile[index];
1229 } 1228 }
1230 1229
1231 return total; 1230 return total;
1232 } 1231 }
1233 1232
1234 /******************************************************************************* 1233 /*******************************************************************************
1235 1234
1236 $Function: writeHexToSimfile 1235 $Function: writeHexToSimfile
1237 1236
1238 $Description: Writes a hex string (MSB first) to a sim file 1237 $Description: Writes a hex string (MSB first) to a sim file
1239 1238
1240 $Returns: None 1239 $Returns: None
1241 1240
1242 $Arguments: simFile - the point in the simFile at which the string occurs 1241 $Arguments: simFile - the point in the simFile at which the string occurs
1243 length - the length of the string 1242 length - the length of the string
1244 *******************************************************************************/ 1243 *******************************************************************************/
1245 1244
1246 static void writeHexToSimfile( UBYTE *simFile, U32 value, int length ) 1245 static void writeHexToSimfile( UBYTE *simFile, U32 value, int length )
1247 { 1246 {
1248 int index; 1247 int index;
1249 1248
1250 #ifdef TRACE_MMIHOMEZONE 1249 #ifdef TRACE_MMIHOMEZONE
1251 TRACE_EVENT_P1("Hex of %X is:", value); 1250 TRACE_EVENT_P1("Hex of %X is:", value);
1252 #endif 1251 #endif
1253 1252
1254 /* Note: '-1' below clarification: 1253 /* Note: '-1' below clarification:
1255 * E.g. index=0, length=4: most significant byte is number shifted 3 bytes right. */ 1254 * E.g. index=0, length=4: most significant byte is number shifted 3 bytes right. */
1256 1255
1257 for ( index = 0; index < length; index++ ) 1256 for ( index = 0; index < length; index++ )
1258 { 1257 {
1259 simFile[index] = (value >> ((length-index-1)*8)) & 0xFF; /* SPR877 - SH - wrong before, added *8 */ 1258 simFile[index] = (value >> ((length-index-1)*8)) & 0xFF; /* SPR877 - SH - wrong before, added *8 */
1260 #ifdef TRACE_MMIHOMEZONE 1259 #ifdef TRACE_MMIHOMEZONE
1261 TRACE_EVENT_P2("Simfile %d is %X", index, simFile[index]); 1260 TRACE_EVENT_P2("Simfile %d is %X", index, simFile[index]);
1262 #endif 1261 #endif
1263 } 1262 }
1264 1263
1265 return; 1264 return;
1266 } 1265 }