FreeCalypso > hg > fc-magnetite

comparison src/ui3/mfw/mfw_fm.c @ 420:e8ddbb0837ed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/ui3: initial import of TCS3/LoCosto BMI & MFW code
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 21 Jan 2018 03:09:00 +0000
parents
children
comparison
equal deleted inserted replaced
419:59143cd42ec7 420:e8ddbb0837ed
1 #ifdef FF_MMI_FILEMANAGER
2 /* =========================================================
3 * Texas Instruments OMAP(TM) Platform Software
4 * (c) Copyright Texas Instruments, Incorporated. All Rights Reserved.
5 *
6 * Use of this software is controlled by the terms and conditions found
7 * in the license agreement under which this software has been supplied.
8 * ========================================================== */
9
10 /*==========================================================
11 * @file mfw_fmc
12 *
13 * This provides the functionality of File Manager Applications.
14 * It supports file/Directory related operations on NOR, NAND and MMC
15 *
16 * @path \bmi\condat\ms\src\mfw
17 *
18 * @rev 00.01
19 */
20 /* ========================================================== */
21 /*===========================================================
22 *!
23 *! Revision History
24 *! ===================================
25
26 Nov 12 2007 DRT :OMAPS00144861 x0056422
27 Description: MM: There are some issues with resume and stop
28 callback in BT MMI code.
29
30
31 Aug 27, 2007 REF:DRT OMAPS00137370 x0045876
32 Description: MM: MIDI/IMY file is not played correctly after listening a
33 MP3 in the Browse Midi list.
34 Solution: Param Voice_Limit is changed when MP3 or AAC file is played. So before
35 playing MP3 or AAC file, Voice_Limit should be saved.
36
37 Jul 04, 2007 DRT:OMAPS00135749 x0062174(Nimitha)
38 Description: Once the audio file has finished automatically play button has to be pressed twice,
39 in order to be played again.
40 Solution : The global variable aud_state_status is set to AUD_FM_NONE once the file playing stopped.
41
42 April 27, 2007 DRT:OMAPS00128836 x0073106
43 Description: Unexpected behavior when copying images with the same names from a memory to another.
44 Solution:In mfw_fm_copy_start () added a if condition if(rfs_stat() && image file).
45
46 Apr 10, 2007 DRT: OMAPS00125309 x0039928
47 Description: MM - Mono option does not work => MMI changes required
48 Solution: Selected Output channel from the settings menu is set for all the players.
49
50 Apr 06, 2007 DRT: OMAPS00124877 x0039928
51 Description: MM: Voice limit Options doesn't work
52 Solution: voice limit value is taken from the global variable set by menu options.
53
54 Mar 28, 2007 ER: OMAPS00106188 x0039928
55 Description: Align Midi application menu choices and audio Player menu choices
56
57 Mar 15, 2007 DRT: OMAPS00120201 x0039928
58 Description: JPEG dir not created in FFS in N5.23 pre release
59 Solution: The directories are created after format for NOR-MS, NAND and T-FLASH
60
61 *! 10-Apr-2006 mf: Modified x0020906. Change required per SRxxxx
62 *! to provide File Manager Functionality.
63 *!
64 *!
65 *! 17-Jan-2006 mf: Revisions appear in reverse chronological order;
66 *! that is, newest first. The date format is dd-Mon-yyyy.
67 * =========================================================== */
68
69 /******************************************************************************
70 Include Files
71 *******************************************************************************/
72 #define ENTITY_MFW
73
74 #include <string.h>
75 #include <stdio.h>
76 #include <stdlib.h>
77
78 #define FF_MMI_RFS_ENABLED
79
80 #if defined (NEW_FRAME)
81
82 #include "typedefs.h"
83 #include "vsi.h"
84 #include "pei.h"
85 #include "custom.h"
86 #include "gsm.h"
87
88 #else
89
90 #include "STDDEFS.H"
91 #include "custom.h"
92 #include "gsm.h"
93 #include "vsi.h"
94
95 #endif
96
97
98 #include "mfw_mfw.h"
99 #include "mfw_phb.h"
100 #include "mfw_phbi.h"
101 #include "mfw_cm.h"
102 #include "mfw_cmi.h"
103
104 #include "mfw_nm.h"
105 #include "mfw_sim.h"
106 #include "mfw_sima.h"
107 #include "mfw_nmi.h"
108 #include "mfw_simi.h"
109 #include "mfw_sms.h"
110 #include "mfw_smsi.h"
111 #include "mfw_win.h"
112
113 #include "ksd.h"
114 #include "psa.h"
115
116 #if defined (FAX_AND_DATA)
117 #include "aci_fd.h"
118 #endif
119
120 //#ifdef FF_MMI_RFS_ENABLED
121 #include "rfs/rfs_api.h"
122 //#else
123 #include "ffs/ffs_api.h"
124 //#endif
125
126 #include "message.h"
127 #include "prim.h"
128 #include "aci_cmh.h"
129
130 #include "cmh.h"
131 #include "phb.h"
132 #include "cmh_phb.h"
133
134 #include "mfw_ss.h"
135 #include "mfw_ssi.h"
136 #include "mfw_win.h"
137
138 #include "gdi.h"
139 #include "prim.h"
140 #ifndef PCM_2_FFS
141 #include "pcm.h"
142 #endif
143
144 #ifdef FF_MMI_MIDI_FORMAT
145 #include "bae/bae_options.h"
146 #endif
147
148 #include "mfw_fm.h"
149 /**********************NOTE***************************
150 FFS header To be replaced with FS Abstraction Header
151 ******************************************************/
152
153 #ifdef FF_MMI_A2DP_AVRCP
154 #include "mfw_bt_api.h"
155 #include "mfw_bt_private.h"
156 #endif
157
158
159 #ifdef INT_PHONEBOOK
160 #include "ATBPbGI.h"
161 #endif
162 /*******************************************************************************
163
164 Defines
165
166 *******************************************************************************/
167 EXTERN MfwHdr * current_mfw_elem;
168 static MSL_HANDLE msl_handle;
169 static T_RV_RETURN_PATH fm_aud_return_path;
170 T_MFW_AUD_PARA para_aud;
171 extern UBYTE mfw_player_playback_loop_flag;
172 extern T_AS_PLAYER_PARAMS player_para;
173 extern INT16 player_channel;
174 extern int aud_state_status;
175
176
177 /* OMAPS00151698, x0056422 */
178 #ifdef FF_MMI_A2DP_AVRCP
179 extern BMI_BT_STRUCTTYPE tGlobalBmiBtStruct;
180 #endif
181 //Daisy tang added for Real Resume feature 20071107
182 //start
183 BOOL isPlayer_Real_Pause = FALSE;
184 UINT32 last_file_size_played = 0;
185 char last_inputFileName[FM_MAX_DIR_PATH_LENGTH];
186 T_WCHAR last_inputFileName_uc[FM_MAX_DIR_PATH_LENGTH];
187 T_AS_PLAYER_TYPE last_file_type;
188 BOOL last_play_bar;
189 UINT32 last_para_aud_pt;
190 //end
191
192
193 /*******************************************************************************
194
195 Local prototypes
196
197 *******************************************************************************/
198
199 void Msl_mslil_Callback(void* handle, U32 ucp_type, U32 tCMd, U32 tStatus);
200 void mfw_fm_audPlay_cb(void *parameter);
201 void mfw_fm_signal(T_MFW_EVENT event, void *para);
202 BOOL mfw_fm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_FM_PARA * para);
203 /* June 28, 2007 DRT: OMAPS00135749 x0062174 */
204 EXTERN void mmi_set_aud_state_status( T_FM_AUD_STATE status);
205
206
207 /*******************************************************************************
208 $Function: mfw_fm_create
209
210 $Description: This function initialises an Mfw fm entity and adds it to the Window Stack
211
212 $Returns: T_MFW_HND : A handle for the entity
213
214 $Arguments: hWin : Parent Window Handle
215 event : Event Mask of the events to be handled
216 cbfunc : Callback function to handle the events
217 *******************************************************************************/
218 T_MFW_HND mfw_fm_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc)
219 {
220 T_MFW_HDR *hdr;
221 T_MFW_FM *fm_para;
222
223 TRACE_FUNCTION("mfw_FM_create()");
224
225 hdr = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR));
226 fm_para = (T_MFW_FM *) mfwAlloc(sizeof (T_MFW_FM));
227
228 if (!hdr OR !fm_para)
229 return FALSE;
230
231 /*
232 * initialisation of the handler
233 */
234 fm_para->emask = event;
235 fm_para->handler = cbfunc;
236
237 hdr->data = fm_para;
238 hdr->type = MfwTypfm;
239
240 /*
241 * installation of the handler
242 */
243 return mfwInsert((T_MFW_HDR *)hWin, hdr);
244 }
245
246 /*******************************************************************************
247
248 $Function: mfw_fm_delete
249
250 $Description: This function clears down an Mfw entity and removes it from the
251 Window Stack
252
253 $Returns: T_MFW_RES : The result of the function
254
255 $Arguments: T_MFW_HND : The Handle of the entity to be removed
256
257 *******************************************************************************/
258 T_MFW_RES mfw_fm_delete(T_MFW_HND hnd)
259 {
260 TRACE_FUNCTION("mfw_FM_delete()");
261
262 if (!hnd OR !((T_MFW_HDR *)hnd)->data)
263 return MFW_RES_ILL_HND;
264
265 if (!mfwRemove((T_MFW_HDR *)hnd))
266 return MFW_RES_ILL_HND;
267
268 mfwFree((U8 *)(((T_MFW_HDR *) hnd)->data),sizeof(T_MFW_FM));
269 mfwFree((U8 *)hnd,sizeof(T_MFW_HDR));
270
271 return MFW_RES_OK;
272 }
273
274 /*******************************************************************************
275
276 $Function: mfw_fm_sign_exec
277
278 $Description: This function sends the Mfw FM events from the Mfw to the BMI.
279
280 $Returns: None
281
282 $Arguments: None
283
284 *******************************************************************************/
285 BOOL mfw_fm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_FM_PARA * para)
286 {
287 TRACE_FUNCTION("mfw_fm_sign_exec()");
288
289
290 while (cur_elem)
291 {
292 /*
293 * event handler is available
294 */
295 if (cur_elem->type EQ MfwTypfm)
296 {
297 T_MFW_FM * fm_data;
298 TRACE_EVENT("MfwTyFm");
299 /*
300 * handler is FM management handler
301 */
302 fm_data = (T_MFW_FM *)cur_elem->data;
303 if (fm_data->emask & event)
304 {
305 /*
306 * event is expected by the call back function
307 */
308 fm_data->event = event;
309 switch (event)
310 {
311 /*
312 ** Generic Events
313 */
314 case E_FM_THMB_INIT:
315 case E_FM_THMB_DEINIT:
316 case E_FM_THMB_GEN:
317 case E_FM_IMG_INIT:
318 case E_FM_IMG_DRAW:
319 case E_FM_IMG_DEINIT:
320 case E_FM_AUDIO_STOP:
321 if(para!=NULL)
322 memcpy (&fm_data->para, para, sizeof (T_MFW_FM_PARA));
323 break;
324 }
325 /*
326 * if call back defined, call it
327 */
328 if (fm_data->handler)
329 {
330 // store current mfw elem
331 current_mfw_elem = cur_elem;
332 if ((*(fm_data->handler)) (fm_data->event, (void *)&fm_data->para))
333 return TRUE;
334 }
335 }
336 }
337 cur_elem = cur_elem->next;
338 }
339 return FALSE;
340 }
341
342 /*******************************************************************************
343
344 $Function: mfw_FM_signal
345
346 $Description: This function sends the Mfw events from the Mfw to the BMI.
347
348 $Returns: None
349
350 $Arguments: T_MFW_EVENT : The event to be sent to the BMI
351 void * : Pointer to the Event data
352
353 *******************************************************************************/
354 void mfw_fm_signal(T_MFW_EVENT event, void *para)
355 {
356 UBYTE temp;
357 temp = dspl_Enable(0);
358
359 TRACE_FUNCTION("mfw_FM_signal()");
360
361 if (mfwSignallingMethod EQ 0)
362 {
363 /*
364 * focus is on a window
365 */
366 if (mfwFocus)
367 {
368 /*
369 * send event to sim management
370 * handler if available
371 */
372 if (mfw_fm_sign_exec (mfwFocus, event, para))
373 {
374 dspl_Enable(temp);
375 return;
376 }
377 }
378 /*
379 * actual focussed window is not available
380 * or has no network management registration
381 * handler, then search all nodes from the root.
382 */
383 if (mfwRoot)
384 mfw_fm_sign_exec (mfwRoot, event, para);
385 }
386 else
387 {
388 MfwHdr * h = 0;
389 /*
390 * Focus set, then start here
391 */
392 if (mfwFocus)
393 h = mfwFocus;
394 /*
395 * Focus not set, then start root
396 */
397 if (!h)
398 h = mfwRoot;
399 /*
400 * No elements available, return
401 */
402 while (h)
403 {
404 /*
405 * Signal consumed, then return
406 */
407 if (mfw_fm_sign_exec (h, event, para))
408 {
409 dspl_Enable(temp);
410 return;
411 }
412 /*
413 * All windows tried inclusive root
414 */
415 if (h == mfwRoot)
416 {
417 dspl_Enable(temp);
418 return;
419 }
420 /*
421 * get parent window
422 */
423 h = mfwParent(mfwParent(h));
424
425 if (h)
426 h = ((MfwWin * )(h->data))->elems;
427 }
428
429 mfw_fm_sign_exec (mfwRoot, event, para);
430
431 }
432 dspl_Enable(temp);
433 return;
434 }
435
436 /*******************************************************************************
437 $Function: mfw_fm_readDir
438
439 $Description: Reads the objects from the given directory
440
441 $Returns: FM_DIR_DOESNOTEXISTS/FM_READDIR_ERROR/FM_NO_ERROR
442
443 $Arguments: dir_path : Current Directory Path
444 dir_name : Current Directory Name
445 num_objs : num of obejcts
446 obj_list : object list
447 source : Current Drive
448 *******************************************************************************/
449 T_MFW_FM_STATUS mfw_fm_readDir(char *dir_path, char *dir_name, UBYTE *num_objs, T_FM_OBJ **obj_list, T_FM_DEVICE_TYPE source, T_FM_APP_TYPE app)
450 {
451 char curDir[FM_MAX_DIR_PATH_LENGTH];
452 /* x0083025 - OMAPS00156759 - Jan 29, 2008 */
453 #if defined(FF_MMI_UNICODE_SUPPORT)||defined (FF_MMI_RFS_ENABLED)
454 T_WCHAR objName_uc[FM_MAX_OBJ_NAME_LENGTH];
455 T_WCHAR curObj_uc[FM_MAX_DIR_PATH_LENGTH];
456 #else
457 char objName_u8[FM_MAX_OBJ_NAME_LENGTH];
458 #endif
459
460 #ifdef FF_MMI_RFS_ENABLED
461 char ext1[FM_MAX_EXT_LENGTH];
462 T_RFS_DIR f_dir;
463 UINT16 curDir_uc[FM_MAX_DIR_PATH_LENGTH];
464 T_RFS_RET result;
465 T_RFS_STAT f_stat;
466 #else
467 T_FFS_DIR f_dir;
468 #endif
469 int iCount=0;
470
471 TRACE_FUNCTION("mfw_fm_readDir");
472
473 *num_objs = 0;
474 memset(curDir, 0, FM_MAX_DIR_PATH_LENGTH);
475 #ifdef FF_MMI_RFS_ENABLED
476 switch (source)
477 {
478 case FM_NOR_FLASH:
479 sprintf(curDir,"%s%s%s","/FFS",dir_path,dir_name);
480 TRACE_EVENT_P1("Current Dir %s",curDir);
481 break;
482 case FM_NORMS_FLASH:
483 sprintf(curDir,"%s%s%s","/NOR",dir_path,dir_name);
484 TRACE_EVENT_P1("Current Dir %s",curDir);
485 break;
486 case FM_NAND_FLASH:
487 sprintf(curDir,"%s%s%s","/NAND",dir_path,dir_name);
488 TRACE_EVENT_P1("Current Dir %s",curDir);
489 break;
490 case FM_T_FLASH:
491 sprintf(curDir,"%s%s%s","/MMC",dir_path,dir_name);
492 TRACE_EVENT_P1("Current Dir %s",curDir);
493 break;
494 default:
495 TRACE_EVENT("Default: Invalid value");
496 break;
497 }
498
499 convert_u8_to_unicode((const char *)curDir, curDir_uc);
500 if (rfs_opendir (curDir_uc, &f_dir) < 0)
501 {
502 TRACE_EVENT_P1("Opening dir %s Failed",curDir);
503 return FM_DIR_DOESNOTEXISTS;
504 }
505
506 for (iCount = 0; rfs_readdir (&f_dir, objName_uc, FM_MAX_OBJ_NAME_LENGTH) > 0x0; )
507 {
508 if (objName_uc[0] == '\0')
509 {
510 return FM_READDIR_ERROR;
511 }
512 if( objName_uc[0] != '.' )
513 {
514 /* x0083025 - OMAPS00156759 - Jan 29, 2008 */
515 wstrcpy(curObj_uc, curDir_uc);
516 { // append '/' char to the end of string
517 T_WCHAR *tmp = curObj_uc;
518 while (*tmp) ++tmp;
519 *tmp++ = '/';
520 *tmp = 0;
521 }
522 wstrcat(curObj_uc, objName_uc);
523
524 result= rfs_stat(curObj_uc, &f_stat);
525
526 if(result == RFS_EOK)
527 {
528 if(f_stat.file_dir.mode & RFS_IXUSR)
529 {
530 obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ));
531
532 /* x0083025 - OMAPS00156759 - Jan 29, 2008 */
533 #ifdef FF_MMI_UNICODE_SUPPORT
534 wstrcpy(obj_list[iCount]->name_uc, objName_uc);
535 TRACE_EVENT_P1("%s", obj_list[iCount]->name_uc);
536 #endif
537 convert_unicode_to_u8(objName_uc, obj_list[iCount]->name);
538 TRACE_EVENT_P1("%s", obj_list[iCount]->name);
539 (*num_objs)++;
540 iCount++;
541 if((*num_objs) >= FM_MAX_OBJ )
542 {
543 TRACE_EVENT("MAX COUNT Reached");
544 if(source == FM_NOR_FLASH)
545 rfs_closedir(&f_dir);
546 return FM_NO_ERROR;
547 }
548 }
549 else
550 {
551 /* x0083025 - OMAPS00156759 - Jan 29, 2008 */
552 convert_unicode_to_u8(wstrchr(objName_uc,'.')+1, ext1);
553
554 if(ext1)
555 {
556 switch(app)
557 {
558 case FM_IMAGE:
559 if(strcmp(ext1, "jpg") == 0)
560 {
561 obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ));
562
563 /* x0083025 - OMAPS00156759 - Jan 29, 2008 */
564 convert_unicode_to_u8(objName_uc, obj_list[iCount]->name);
565
566 TRACE_EVENT_P1("%s", obj_list[iCount]->name);
567 (*num_objs)++;
568 iCount++;
569 if((*num_objs) >= FM_MAX_OBJ )
570 {
571 TRACE_EVENT("MAX COUNT Reached");
572 if(source == FM_NOR_FLASH)
573 rfs_closedir(&f_dir);
574 return FM_NO_ERROR;
575 }
576 }
577 break;
578 case FM_AUDIO:
579 if(
580
581 #ifdef FF_MP3_RINGER
582 (strcmp(ext1, "mp3") == 0)
583 #else
584 (0)
585 #endif
586 #ifdef FF_AAC_RINGER
587 || (strcmp(ext1, "aac") == 0)
588 #else
589 || (0)
590 #endif
591
592 #ifdef FF_MMI_MIDI_FORMAT
593
594 #ifdef PAL_ENABLE_XMF
595 || (strcmp(ext1, "xmf") == 0)
596 #else
597 || (0)
598 #endif
599 #ifdef PAL_ENABLE_IMELODY
600 || (strcmp(ext1, "imy") == 0)
601 #else
602 || (0)
603 #endif
604 #ifdef PAL_ENABLE_SMAF_MA3
605 || (strcmp(ext1, "mmf") == 0)
606 #else
607 || (0)
608 #endif
609 #ifdef PAL_ENABLE_XMF
610 || (strcmp(ext1, "mxmf") == 0)
611 #else
612 || (0)
613 #endif
614 #ifdef PAL_ENABLE_SMS
615 || (strcmp(ext1, "sms") == 0)
616 #else
617 || (0)
618 #endif
619 #ifdef PAL_ENABLE_DIGITAL_AUDIO
620 || (strcmp(ext1, "wav") == 0)
621 #else
622 || (0)
623 #endif
624 #ifdef PAL_ENABLE_MIDI_NORMALIZER
625 || (strcmp(ext1, "mid") == 0)
626 #else
627 || (0)
628 #endif
629
630 #endif
631 )
632
633 {
634 obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ));
635 /* x0083025 - OMAPS00156759 - Jan 29, 2008 */
636 #ifdef FF_MMI_UNICODE_SUPPORT
637 wstrcpy(obj_list[iCount]->name_uc, objName_uc);
638 TRACE_EVENT_P1("%s", obj_list[iCount]->name_uc);
639 #else
640 convert_unicode_to_u8(objName_uc, obj_list[iCount]->name);
641 TRACE_EVENT_P1("%s", obj_list[iCount]->name);
642 #endif
643 (*num_objs)++;
644 iCount++;
645 if((*num_objs) >= FM_MAX_OBJ )
646 {
647 TRACE_EVENT("MAX COUNT Reached");
648 if(source == FM_NOR_FLASH)
649 rfs_closedir(&f_dir);
650 return FM_NO_ERROR;
651 }
652 }
653 break;
654 }
655 }
656 }
657 }
658 }
659 }
660 TRACE_EVENT_P2("Dir %s contains %d Objects",curDir,iCount);
661 if(source == FM_NOR_FLASH)
662 rfs_closedir(&f_dir);
663 #else
664 sprintf(curDir,"%s%s",dir_path,dir_name);
665 TRACE_EVENT_P1("Current Dir %s",curDir);
666
667 /**********************NOTE***************************
668 FFS API To be replaced with FS Abstraction API
669 ******************************************************/
670 if (ffs_opendir (curDir, &f_dir) < 0)
671 {
672 TRACE_EVENT_P1("Opening dir %s Failed",curDir);
673 return FM_DIR_DOESNOTEXISTS;
674 }
675 /**********************NOTE***************************
676 FFS API To be replaced with FS Abstraction API
677 ******************************************************/
678 for (iCount = 0; ffs_readdir (&f_dir, objName_u8, FM_MAX_OBJ_NAME_LENGTH) > 0x0; iCount++)
679 {
680 if (objName_u8[0] == '\0')
681 {
682 return FM_READDIR_ERROR;
683 }
684 if( objName_u8[0] != '.' )
685 {
686 obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ));
687 strcpy(obj_list[iCount]->name, objName_u8);
688 TRACE_EVENT_P1("%s", obj_list[iCount]->name);
689 (*num_objs)++;
690 if((*num_objs) >= FM_MAX_OBJ )
691 {
692 TRACE_EVENT("MAX COUNT Reached");
693 break;
694 }
695 }
696 }
697 TRACE_EVENT_P2("Dir %s contains %d Objects",curDir,iCount);
698 #endif
699
700
701 return FM_NO_ERROR;
702 }
703
704 /*******************************************************************************
705 $Function: mfw_fm_rename
706
707 $Description: Renames the selcted object with the new name
708
709 $Returns: FM_RENAME_ERROR/FM_NO_ERROR
710
711 $Arguments: old_filename : Old filename
712 new_filename : New filename
713 source : Current Drive
714 *******************************************************************************/
715 #ifdef FF_MMI_UNICODE_SUPPORT
716 T_MFW_FM_STATUS mfw_fm_rename(T_WCHAR* old_filename, T_WCHAR* new_filename, T_FM_DEVICE_TYPE source)
717 #else
718 T_MFW_FM_STATUS mfw_fm_rename(char* old_filename, char * new_filename, T_FM_DEVICE_TYPE source)
719 #endif
720 {
721
722 #ifdef FF_MMI_RFS_ENABLED
723 T_RFS_RET rfsResult;
724 char old_filename_mt[FM_MAX_DIR_PATH_LENGTH];
725 char new_filename_mt[FM_MAX_DIR_PATH_LENGTH];
726 UINT16 new_filename_uc[FM_MAX_DIR_PATH_LENGTH];
727 UINT16 old_filename_uc[FM_MAX_DIR_PATH_LENGTH];
728 #else
729
730 #if defined(FF_MMI_UNICODE_SUPPORT) && !defined(FF_MMI_RFS_ENABLED)
731 char old_filename_u8[FM_MAX_DIR_PATH_LENGTH];
732 char new_filename_u8[FM_MAX_DIR_PATH_LENGTH];
733 #endif
734
735 T_FFS_RET ffsResult;
736 #endif
737
738 TRACE_FUNCTION("mfw_fm_rename");
739
740 #ifdef FF_MMI_RFS_ENABLED
741 switch (source)
742 {
743 case FM_NOR_FLASH:
744 strcpy(old_filename_mt, "/FFS");
745 strcpy(new_filename_mt, "/FFS");
746 break;
747 case FM_NORMS_FLASH:
748 strcpy(old_filename_mt, "/NOR");
749 strcpy(new_filename_mt, "/NOR");
750 break;
751 case FM_NAND_FLASH:
752 strcpy(old_filename_mt, "/NAND");
753 strcpy(new_filename_mt, "/NAND");
754 break;
755 case FM_T_FLASH:
756 strcpy(old_filename_mt, "/MMC");
757 strcpy(new_filename_mt, "/MMC");
758 break;
759 }
760
761 #ifdef FF_MMI_UNICODE_SUPPORT
762 convert_u8_to_unicode(old_filename_mt,old_filename_uc);
763 convert_u8_to_unicode(new_filename_mt, new_filename_uc);
764 wstrcat(old_filename_uc, old_filename);
765 wstrcat(new_filename_uc, new_filename);
766 #else
767 strcat(old_filename_mt, old_filename);
768 strcat(new_filename_mt, new_filename);
769 convert_u8_to_unicode(old_filename_mt,old_filename_uc);
770 convert_u8_to_unicode(new_filename_mt, new_filename_uc);
771 #endif
772
773 rfsResult = rfs_rename(old_filename_uc, new_filename_uc);
774 if(rfsResult != RFS_EOK)
775 {
776 return FM_RENAME_ERROR;
777 }
778 #else
779
780 #ifdef FF_MMI_UNICODE_SUPPORT
781 convert_unicode_to_u8(old_filename, old_filename_u8);
782 convert_unicode_to_u8(new_filename, new_filename_u8;
783
784 ffsResult = ffs_rename(old_filename_u8,new_filename_u8);
785 #else
786 ffsResult = ffs_rename(old_filename,new_filename);
787 #endif
788 if(ffsResult != EFFS_OK)
789 {
790 return FM_RENAME_ERROR;
791 }
792 #endif
793 return FM_NO_ERROR;
794 }
795
796 /*******************************************************************************
797 $Function: mfw_fm_rename_image
798
799 $Description: Renames the selected image and its thumbnail with the new name
800
801 $Returns: FM_RENAME_ERROR/FM_NO_ERROR
802
803 $Arguments: path : Current directory path
804 dirname : Current Directory name
805 old_filename : Old filename
806 new_filename : New filename
807 source : Current Drive
808 *******************************************************************************/
809 T_MFW_FM_STATUS mfw_fm_rename_image(char * path, char * dirname, char* old_filename, char * new_filename, T_FM_DEVICE_TYPE source)
810 {
811 T_MFW_FM_STATUS ffsResult;
812 char t_oldfilename[FM_MAX_DIR_PATH_LENGTH];
813 char t_newfilename[FM_MAX_DIR_PATH_LENGTH];
814
815 #ifdef FF_MMI_UNICODE_SUPPORT
816 T_WCHAR oldfilename_uc[FM_MAX_DIR_PATH_LENGTH];
817 T_WCHAR newfilename_uc[FM_MAX_DIR_PATH_LENGTH];
818 #endif
819
820 TRACE_FUNCTION("mfw_fm_rename_image");
821
822 #ifdef FF_MMI_RFS_ENABLED
823
824 sprintf(t_oldfilename,"%s%s/%s.jpg",path,dirname,old_filename);
825 sprintf(t_newfilename,"%s%s/%s.jpg",path,dirname,new_filename);
826 /* February 8, 2008 DRT:OMAPS00156759 (x0083025) For Unicode Support--> Start*/
827
828 #ifdef FF_MMI_UNICODE_SUPPORT
829 convert_u8_to_unicode(t_oldfilename, oldfilename_uc);
830 convert_u8_to_unicode(t_newfilename, newfilename_uc);
831 ffsResult = mfw_fm_rename(oldfilename_uc,newfilename_uc,source);
832 #else
833 ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source);
834 #endif
835 if(ffsResult != FM_NO_ERROR)
836 {
837 return FM_RENAME_ERROR;
838 }
839 switch(source)
840 {
841 case FM_NOR_FLASH:
842 sprintf(t_oldfilename,"%s%s/%s.tmb",NORDIR,THUMB,old_filename);
843 sprintf(t_newfilename,"%s%s/%s.tmb",NORDIR,THUMB,new_filename);
844 break;
845 case FM_NORMS_FLASH:
846 sprintf(t_oldfilename,"%s%s/%s.tmb",NORMSDIR,THUMB,old_filename);
847 sprintf(t_newfilename,"%s%s/%s.tmb",NORMSDIR,THUMB,new_filename);
848 break;
849 case FM_NAND_FLASH:
850 sprintf(t_oldfilename,"%s%s/%s.tmb",NANDDIR,THUMB,old_filename);
851 sprintf(t_newfilename,"%s%s/%s.tmb",NANDDIR,THUMB,new_filename);
852 break;
853 case FM_T_FLASH:
854 sprintf(t_oldfilename,"%s%s/%s.tmb",TFLASHDIR,THUMB,old_filename);
855 sprintf(t_newfilename,"%s%s/%s.tmb",TFLASHDIR,THUMB,new_filename);
856 break;
857 }
858
859 #ifdef FF_MMI_UNICODE_SUPPORT
860 convert_u8_to_unicode(t_oldfilename, oldfilename_uc);
861 convert_u8_to_unicode(t_newfilename, newfilename_uc);
862 ffsResult = mfw_fm_rename(oldfilename_uc,newfilename_uc,source);
863 #else
864 ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source);
865 #endif
866 if(ffsResult != FM_NO_ERROR)
867 {
868 return FM_RENAME_ERROR;
869 }
870 #else
871 sprintf(t_oldfilename,"%s%s/%s.jpg",path,dirname,old_filename);
872 sprintf(t_newfilename,"%s%s/%s.jpg",path,dirname,new_filename);
873
874 ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source);
875 if(ffsResult != FM_NO_ERROR)
876 {
877 return FM_RENAME_ERROR;
878 }
879 sprintf(t_oldfilename,"%s%s/%s.tmb",NORDIR,THUMB,old_filename);
880 sprintf(t_newfilename,"%s%s/%s.tmb",NORDIR,THUMB,new_filename);
881
882 ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source);
883
884 if(ffsResult != FM_NO_ERROR)
885 {
886 return FM_RENAME_ERROR;
887 }
888 #endif
889 return FM_NO_ERROR;
890 }
891
892 /*******************************************************************************
893 $Function: mfw_fm_createRootDir
894
895 $Description: Creates the root jpeg, tones directory
896
897 $Returns: FM_NO_ERROR
898
899 $Arguments: source : Current Drive
900 *******************************************************************************/
901 T_MFW_FM_STATUS mfw_fm_createRootDir(T_FM_DEVICE_TYPE source)
902 {
903 #ifdef FF_MMI_RFS_ENABLED
904 T_RFS_RET ffsResult;
905 T_RFS_DIR f_dir;
906 UINT16 dir_path_uc[FM_MAX_DIR_PATH_LENGTH];
907 #else
908 T_FFS_RET ffsResult;
909 T_FFS_DIR f_dir;
910 #endif
911 char dir_path[FM_MAX_DIR_PATH_LENGTH];
912
913 TRACE_FUNCTION("mfw_fm_createRootDir");
914
915 #ifdef FF_MMI_RFS_ENABLED
916 TRACE_EVENT_P1("Source %d",source);
917 switch (source)
918 {
919 case FM_NOR_FLASH:
920 sprintf(dir_path,"%s%s%s","/FFS",NORDIR,NORDIR_IMG);
921 convert_u8_to_unicode(dir_path, dir_path_uc);
922 /**********************NOTE***************************
923 FFS API To be replaced with FS Abstraction API
924 ******************************************************/
925 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
926 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
927 if(ffsResult > 0)
928 rfs_closedir(&f_dir);
929 else if(RFS_ENOENT == ffsResult)
930 {
931 /**********************NOTE***************************
932 FFS API To be replaced with FS Abstraction API
933 ******************************************************/
934 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
935 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
936 }
937 sprintf(dir_path,"%s%s%s","/FFS",NORDIR,THUMB);
938 convert_u8_to_unicode(dir_path, dir_path_uc);
939 /**********************NOTE***************************
940 FFS API To be replaced with FS Abstraction API
941 ******************************************************/
942 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
943 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
944 if(ffsResult > 0)
945 rfs_closedir(&f_dir);
946 else if(RFS_ENOENT == ffsResult)
947 {
948 /**********************NOTE***************************
949 FFS API To be replaced with FS Abstraction API
950 ******************************************************/
951 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
952 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
953 }
954 sprintf(dir_path,"%s%s%s","/FFS",NORDIR,NORDIR_AUD);
955 convert_u8_to_unicode(dir_path, dir_path_uc);
956 /**********************NOTE***************************
957 FFS API To be replaced with FS Abstraction API
958 ******************************************************/
959 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
960 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
961 if(ffsResult > 0)
962 rfs_closedir(&f_dir);
963 else if(RFS_ENOENT == ffsResult)
964 {
965 /**********************NOTE***************************
966 FFS API To be replaced with FS Abstraction API
967 ******************************************************/
968 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
969 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
970 }
971 break;
972 case FM_NORMS_FLASH:
973 sprintf(dir_path,"%s%s%s","/NOR",NORMSDIR,NORMSDIR_IMG);
974 convert_u8_to_unicode(dir_path, dir_path_uc);
975 /**********************NOTE***************************
976 FFS API To be replaced with FS Abstraction API
977 ******************************************************/
978 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
979 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
980 // if(ffsResult > 0)
981 // rfs_closedir(&f_dir);
982 // else
983 if(RFS_ENOENT == ffsResult)
984 {
985 /**********************NOTE***************************
986 FFS API To be replaced with FS Abstraction API
987 ******************************************************/
988 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
989 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
990 }
991 sprintf(dir_path,"%s%s%s","/NOR",NORMSDIR,THUMB);
992 convert_u8_to_unicode(dir_path, dir_path_uc);
993 /**********************NOTE***************************
994 FFS API To be replaced with FS Abstraction API
995 ******************************************************/
996 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
997 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
998 // if(ffsResult > 0)
999 // rfs_closedir(&f_dir);
1000 // else
1001 if(RFS_ENOENT == ffsResult)
1002 {
1003 /**********************NOTE***************************
1004 FFS API To be replaced with FS Abstraction API
1005 ******************************************************/
1006 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1007 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1008 }
1009 sprintf(dir_path,"%s%s%s","/NOR",NORMSDIR,NORMSDIR_AUD);
1010 convert_u8_to_unicode(dir_path, dir_path_uc);
1011 /**********************NOTE***************************
1012 FFS API To be replaced with FS Abstraction API
1013 ******************************************************/
1014 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1015 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1016 // if(ffsResult > 0)
1017 // rfs_closedir(&f_dir);
1018 // else
1019 if(RFS_ENOENT == ffsResult)
1020 {
1021 /**********************NOTE***************************
1022 FFS API To be replaced with FS Abstraction API
1023 ******************************************************/
1024 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1025 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1026 }
1027 break;
1028 case FM_NAND_FLASH:
1029 /**********************NOTE***************************
1030 FS Abstraction API to be added
1031 ******************************************************/
1032 sprintf(dir_path,"%s%s%s","/NAND",NANDDIR,NANDDIR_IMG);
1033 convert_u8_to_unicode(dir_path, dir_path_uc);
1034 /**********************NOTE***************************
1035 FFS API To be replaced with FS Abstraction API
1036 ******************************************************/
1037 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1038 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1039 // if(ffsResult > 0)
1040 // rfs_closedir(&f_dir);
1041 // else
1042 if(RFS_ENOENT == ffsResult)
1043 {
1044 /**********************NOTE***************************
1045 FFS API To be replaced with FS Abstraction API
1046 ******************************************************/
1047 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1048 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1049 }
1050 sprintf(dir_path,"%s%s%s","/NAND",NANDDIR,THUMB);
1051 convert_u8_to_unicode(dir_path, dir_path_uc);
1052 /**********************NOTE***************************
1053 FFS API To be replaced with FS Abstraction API
1054 ******************************************************/
1055 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1056 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1057 // if(ffsResult > 0)
1058 // rfs_closedir(&f_dir);
1059 // else
1060 if(RFS_ENOENT == ffsResult)
1061 {
1062 /**********************NOTE***************************
1063 FFS API To be replaced with FS Abstraction API
1064 ******************************************************/
1065 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1066 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1067 }
1068 sprintf(dir_path,"%s%s%s","/NAND",NANDDIR,NANDDIR_AUD);
1069 convert_u8_to_unicode(dir_path, dir_path_uc);
1070 /**********************NOTE***************************
1071 FFS API To be replaced with FS Abstraction API
1072 ******************************************************/
1073 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1074 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1075 // if(ffsResult > 0)
1076 // rfs_closedir(&f_dir);
1077 // else
1078 if(RFS_ENOENT == ffsResult)
1079 {
1080 /**********************NOTE***************************
1081 FFS API To be replaced with FS Abstraction API
1082 ******************************************************/
1083 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1084 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1085 }
1086 break;
1087 case FM_T_FLASH:
1088 /**********************NOTE***************************
1089 FS Abstraction API to be added
1090 ******************************************************/
1091 sprintf(dir_path,"%s%s%s","/MMC",TFLASHDIR,TFLASHDIR_IMG);
1092 convert_u8_to_unicode(dir_path, dir_path_uc);
1093 /**********************NOTE***************************
1094 FFS API To be replaced with FS Abstraction API
1095 ******************************************************/
1096 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1097 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1098 // if(ffsResult > 0)
1099 // rfs_closedir(&f_dir);
1100 // else
1101 if(RFS_ENOENT == ffsResult)
1102 {
1103 /**********************NOTE***************************
1104 FFS API To be replaced with FS Abstraction API
1105 ******************************************************/
1106 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1107 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1108 }
1109 sprintf(dir_path,"%s%s%s","/MMC",TFLASHDIR,THUMB);
1110 convert_u8_to_unicode(dir_path, dir_path_uc);
1111 /**********************NOTE***************************
1112 FFS API To be replaced with FS Abstraction API
1113 ******************************************************/
1114 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1115 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1116 // if(ffsResult > 0)
1117 // rfs_closedir(&f_dir);
1118 // else
1119 if(RFS_ENOENT == ffsResult)
1120 {
1121 /**********************NOTE***************************
1122 FFS API To be replaced with FS Abstraction API
1123 ******************************************************/
1124 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1125 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1126 }
1127 sprintf(dir_path,"%s%s%s","/MMC",TFLASHDIR,TFLASHDIR_AUD);
1128 convert_u8_to_unicode(dir_path, dir_path_uc);
1129 /**********************NOTE***************************
1130 FFS API To be replaced with FS Abstraction API
1131 ******************************************************/
1132 ffsResult = rfs_opendir(dir_path_uc,&f_dir);
1133 TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path);
1134 // if(ffsResult > 0)
1135 // rfs_closedir(&f_dir);
1136 // else
1137 if(RFS_ENOENT == ffsResult)
1138 {
1139 /**********************NOTE***************************
1140 FFS API To be replaced with FS Abstraction API
1141 ******************************************************/
1142 ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU);
1143 TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path);
1144 }
1145 break;
1146 }
1147 #else
1148 sprintf(dir_path,"%s%s",NORDIR,NORDIR_IMG);
1149 /**********************NOTE***************************
1150 FFS API To be replaced with FS Abstraction API
1151 ******************************************************/
1152 ffsResult = ffs_opendir(dir_path,&f_dir);
1153 if(EFFS_NOTFOUND == ffsResult)
1154 {
1155 /**********************NOTE***************************
1156 FFS API To be replaced with FS Abstraction API
1157 ******************************************************/
1158 ffsResult = ffs_mkdir(dir_path);
1159 }
1160 sprintf(dir_path,"%s%s",NORDIR,THUMB);
1161 /**********************NOTE***************************
1162 FFS API To be replaced with FS Abstraction API
1163 ******************************************************/
1164 ffsResult = ffs_opendir(dir_path,&f_dir);
1165 if(EFFS_NOTFOUND == ffsResult)
1166 {
1167 /**********************NOTE***************************
1168 FFS API To be replaced with FS Abstraction API
1169 ******************************************************/
1170 ffsResult = ffs_mkdir(dir_path);
1171 }
1172 sprintf(dir_path,"%s%s",NORDIR,NORDIR_AUD);
1173 /**********************NOTE***************************
1174 FFS API To be replaced with FS Abstraction API
1175 ******************************************************/
1176 ffsResult = ffs_opendir(dir_path,&f_dir);
1177 if(EFFS_NOTFOUND == ffsResult)
1178 {
1179 /**********************NOTE***************************
1180 FFS API To be replaced with FS Abstraction API
1181 ******************************************************/
1182 ffsResult = ffs_mkdir(dir_path);
1183 }
1184 #endif
1185 return FM_NO_ERROR;
1186 }
1187
1188 /*******************************************************************************
1189 $Function: mfw_fm_newdir
1190
1191 $Description: creates a new direcotry with the given name
1192
1193 $Returns: FM_DIR_EXISTS/FM_NO_ERROR
1194
1195 $Arguments: dirname : new directory name
1196 source : Current Drive
1197 *******************************************************************************/
1198 T_MFW_FM_STATUS mfw_fm_newdir(char *dirname, T_FM_DEVICE_TYPE source)
1199 {
1200 #ifdef FF_MMI_RFS_ENABLED
1201 T_RFS_RET ffsResult;
1202 T_RFS_DIR f_dir;
1203 char pathname[FM_MAX_DIR_PATH_LENGTH];
1204 UINT16 pathname_uc[FM_MAX_DIR_PATH_LENGTH];
1205 #else
1206 T_FFS_RET ffsResult;
1207 T_FFS_DIR f_dir;
1208 #endif
1209
1210 TRACE_FUNCTION("mfw_fm_newdir");
1211
1212 #ifdef FF_MMI_RFS_ENABLED
1213 switch (source)
1214 {
1215 case FM_NOR_FLASH:
1216 strcpy(pathname,"/FFS");
1217 break;
1218 case FM_NORMS_FLASH:
1219 strcpy(pathname,"/NOR");
1220 break;
1221 case FM_NAND_FLASH:
1222 strcpy(pathname,"/NAND");
1223 break;
1224 case FM_T_FLASH:
1225 strcpy(pathname,"/MMC");
1226 break;
1227 }
1228 strcat(pathname,dirname);
1229 convert_u8_to_unicode(pathname,pathname_uc);
1230
1231 ffsResult = rfs_opendir(pathname_uc,&f_dir);
1232 if(RFS_ENOENT == ffsResult)
1233 {
1234 ffsResult = rfs_mkdir(pathname_uc,RFS_IRWXU);
1235 }
1236 else
1237 {
1238 return FM_DIR_EXISTS;
1239 }
1240 #else
1241
1242 ffsResult = ffs_opendir(dirname,&f_dir);
1243 if(EFFS_NOTFOUND == ffsResult)
1244 {
1245 ffsResult = ffs_mkdir(dirname);
1246 }
1247 else
1248 {
1249 return FM_DIR_EXISTS;
1250 }
1251 #endif
1252 return FM_NO_ERROR;
1253 }
1254
1255 /*******************************************************************************
1256 $Function: mfw_fm_readProperties
1257
1258 $Description: Reads the properties of all the objects in the given directory
1259
1260 $Returns: None
1261
1262 $Arguments: dir_path : Current Directory Path
1263 dir_name : Current Directory Name
1264 num_objs : num of obejcts
1265 obj_list : object list
1266 obj_properties: Object properties
1267 source : Current Drive
1268 *******************************************************************************/
1269 void mfw_fm_readProperties(char *dir_path, char *dir_name, UBYTE num_objs, T_FM_OBJ **obj_list, T_FM_OBJ_PROPERTIES **obj_properties,T_FM_DEVICE_TYPE source, T_FM_APP_TYPE app)
1270 {
1271 /* January 16, 2008 DRT:OMAPS00156759 (x0082844) Shubhro -> For Unicode Support--> Start*/
1272 #if defined(FF_MMI_UNICODE_SUPPORT)||defined (FF_MMI_RFS_ENABLED)
1273 T_WCHAR curObj_uc[FM_MAX_DIR_PATH_LENGTH];
1274 #else
1275 char curObj_u8[FM_MAX_DIR_PATH_LENGTH];
1276 #endif
1277 /* January 16, 2008 DRT:OMAPS00156759 (x0082844) Shubhro --> End*/
1278
1279 char curPath[FM_MAX_DIR_PATH_LENGTH];
1280 int iCount=0;
1281
1282 #ifdef FF_MMI_RFS_ENABLED
1283 T_RFS_RET result;
1284 T_RFS_STAT f_stat;
1285 T_RTC_DATE_TIME time_and_date;
1286 #else
1287 T_FFS_RET result;
1288 T_FFS_STAT f_stat;
1289 #endif
1290
1291 TRACE_FUNCTION("mfw_fm_readProperties");
1292
1293 #ifdef FF_MMI_RFS_ENABLED
1294 switch (source)
1295 {
1296 case FM_NOR_FLASH:
1297 sprintf(curPath,"%s%s%s/","/FFS",dir_path,dir_name);
1298 break;
1299 case FM_NORMS_FLASH:
1300 sprintf(curPath,"%s%s%s/","/NOR",dir_path,dir_name);
1301 break;
1302 case FM_NAND_FLASH:
1303 sprintf(curPath,"%s%s%s/","/NAND",dir_path,dir_name);
1304 break;
1305 case FM_T_FLASH:
1306 sprintf(curPath,"%s%s%s/","/MMC",dir_path,dir_name);
1307 break;
1308 }
1309
1310
1311 for (iCount = 0;iCount<num_objs; iCount++)
1312 {
1313
1314 /* February 8, 2008 DRT:OMAPS00156759 (x0083025) For Unicode Support--> Start*/
1315 convert_u8_to_unicode(curPath, curObj_uc);
1316
1317 #ifdef FF_MMI_UNICODE_SUPPORT
1318 // If it's an image it's stored as char
1319 if (app == FM_AUDIO)
1320 {
1321 wstrcat(curObj_uc, obj_list[iCount]->name_uc);
1322 }
1323 else
1324 #endif
1325 {
1326 T_WCHAR filename_uc[FM_MAX_OBJ_NAME_LENGTH];
1327 convert_u8_to_unicode(obj_list[iCount]->name, filename_uc);
1328 wstrcat(curObj_uc, filename_uc);
1329 }
1330 result= rfs_stat(curObj_uc, &f_stat);
1331 if(result == RFS_EOK)
1332 {
1333 if(f_stat.file_dir.mode & RFS_IXUSR)
1334 obj_list[iCount]->type=OBJECT_TYPE_FOLDER;
1335 else
1336 obj_list[iCount]->type=OBJECT_TYPE_FILE;
1337 }
1338 TRACE_EVENT_P2("Object %s type %d",curObj_uc, obj_list[iCount]->type);
1339
1340 obj_properties[iCount] = (T_FM_OBJ_PROPERTIES *)mfwAlloc(sizeof(T_FM_OBJ_PROPERTIES));
1341 obj_properties[iCount]->size = f_stat.file_dir.size;
1342 result = rfs_getdatetime(curObj_uc,NULL /* creation date and time */,&time_and_date /* last modified date and time */);
1343 sprintf(obj_properties[iCount]->date,"%d-%d-%d", time_and_date.day, time_and_date.month, 2000 + time_and_date.year);
1344 sprintf(obj_properties[iCount]->time,"%d.%d.%d", time_and_date.hour, time_and_date.minute, time_and_date.second);
1345 }
1346
1347 #else
1348 sprintf(curPath,"%s%s/",dir_path,dir_name);
1349 for (iCount = 0;iCount<num_objs; iCount++)
1350 {
1351 sprintf(curObj_u8,"%s%s",curPath,obj_list[iCount]->name);
1352 /**********************NOTE***************************
1353 FFS API To be replaced with FS Abstraction API
1354 ******************************************************/
1355 result= ffs_stat( curObj_u8, (void *)&f_stat );
1356 if(result == EFFS_OK)
1357 {
1358 switch(f_stat.type)
1359 {
1360 case OT_FILE:
1361 obj_list[iCount]->type=OBJECT_TYPE_FILE;
1362 break;
1363 case OT_DIR:
1364 obj_list[iCount]->type=OBJECT_TYPE_FOLDER;
1365 break;
1366 default:
1367 obj_list[iCount]->type=OBJECT_TYPE_NONE;
1368 break;
1369 }
1370 }
1371 TRACE_EVENT_P2("name %s, Object type %d", obj_list[iCount]->name,obj_list[iCount]->type);
1372 obj_properties[iCount] = (T_FM_OBJ_PROPERTIES*)mfwAlloc(sizeof(T_FM_OBJ_PROPERTIES));
1373 obj_properties[iCount]->size=f_stat.size;
1374 }
1375 #endif
1376 }
1377
1378 /*******************************************************************************
1379 $Function: mfw_fm_readFIleFolders
1380
1381 $Description: Classifies all the objects as either File or Directory
1382
1383 $Returns: None
1384
1385 $Arguments: fm_curr_dir : Current directory
1386 source : Current Drive
1387 *******************************************************************************/
1388 void mfw_fm_readFileFolders(char *dir_path, char *dir_name, UBYTE num_objs, T_FM_OBJ **obj_list, T_FM_DEVICE_TYPE source)
1389 {
1390 char curObj[FM_MAX_DIR_PATH_LENGTH];
1391 char curPath[FM_MAX_DIR_PATH_LENGTH];
1392 int iCount=0;
1393 #ifdef FF_MMI_RFS_ENABLED
1394 T_RFS_RET result;
1395 T_RFS_STAT f_stat;
1396 UINT16 curObj_uc[FM_MAX_DIR_PATH_LENGTH];
1397 #else
1398 T_FFS_RET result;
1399 T_FFS_STAT f_stat;
1400 #endif
1401
1402 TRACE_FUNCTION("mfw_fm_readFileFolders");
1403
1404 #ifdef FF_MMI_RFS_ENABLED
1405 switch (source)
1406 {
1407 case FM_NOR_FLASH:
1408 sprintf(curPath,"%s%s%s/","/FFS",dir_path,dir_name);
1409 break;
1410 case FM_NORMS_FLASH:
1411 sprintf(curPath,"%s%s%s/","/NOR",dir_path,dir_name);
1412 break;
1413 case FM_NAND_FLASH:
1414 sprintf(curPath,"%s%s%s/","/NAND",dir_path,dir_name);
1415 break;
1416 case FM_T_FLASH:
1417 sprintf(curPath,"%s%s%s/","/MMC",dir_path,dir_name);
1418 break;
1419 }
1420 for (iCount = 0;iCount<num_objs; iCount++)
1421 {
1422 sprintf(curObj,"%s%s",curPath,obj_list[iCount]->name);
1423 convert_u8_to_unicode(curObj, curObj_uc);
1424 result= rfs_stat(curObj_uc, &f_stat);
1425 if(result == RFS_EOK)
1426 {
1427 if(f_stat.file_dir.mode & RFS_IXUSR)
1428 obj_list[iCount]->type=OBJECT_TYPE_FOLDER;
1429 else
1430 obj_list[iCount]->type=OBJECT_TYPE_FILE;
1431 }
1432 TRACE_EVENT_P2("Object %s type %d",curObj, obj_list[iCount]->type);
1433 }
1434 #else
1435 sprintf(curPath,"%s%s/",dir_path,dir_name);
1436
1437 for (iCount = 0;iCount<num_objs; iCount++)
1438 {
1439 sprintf(curObj,"%s%s",curPath,obj_list[iCount]->name);
1440
1441 result= ffs_stat( curObj, (void *)&f_stat );
1442 if(result == EFFS_OK)
1443 {
1444 switch(f_stat.type)
1445 {
1446 case OT_FILE:
1447 obj_list[iCount]->type=OBJECT_TYPE_FILE;
1448 break;
1449 case OT_DIR:
1450 obj_list[iCount]->type=OBJECT_TYPE_FOLDER;
1451 break;
1452 default:
1453 obj_list[iCount]->type=OBJECT_TYPE_NONE;
1454 break;
1455 }
1456 }
1457 TRACE_EVENT_P2("Object %s type %d",curObj, obj_list[iCount]->type);
1458 }
1459 #endif
1460 }
1461 /*******************************************************************************
1462 $Function: mfw_fm_getMemStat
1463
1464 $Description: Extracts the memory usage details of a given drive
1465
1466 $Returns: None
1467
1468 $Arguments: nfree : free bytes
1469 nused : used bytes
1470 source : Current Drive
1471 *******************************************************************************/
1472 void mfw_fm_getMemStat(int *nfree, int *nused,T_FM_DEVICE_TYPE source)
1473 {
1474
1475 T_RFS_STAT f_stat;
1476 char curObj[FM_MAX_DIR_PATH_LENGTH];
1477 UINT16 curObj_uc[FM_MAX_DIR_PATH_LENGTH];
1478 TRACE_FUNCTION("mfw_fm_getMemStat");
1479
1480 memset(curObj, 0, FM_MAX_DIR_PATH_LENGTH);
1481 switch (source)
1482 {
1483 case FM_NOR_FLASH:
1484 strcpy(curObj,"/FFS");
1485 break;
1486 case FM_NORMS_FLASH:
1487 strcpy(curObj,"/NOR");
1488 break;
1489 case FM_NAND_FLASH:
1490 strcpy(curObj,"/NAND");
1491 break;
1492 case FM_T_FLASH:
1493 strcpy(curObj,"/MMC");
1494 break;
1495 }
1496 convert_u8_to_unicode(curObj, curObj_uc);
1497 rfs_stat(curObj_uc, &f_stat); /* warning fix */
1498 *nfree = f_stat.mount_point.free_space;
1499 *nused = f_stat.mount_point.used_size;
1500
1501 }
1502
1503 /*******************************************************************************
1504 $Function: mfw_fm_format
1505
1506 $Description: Formats the given drive
1507
1508 $Returns: FM_NO_ERROR/FM_FORMAT_ERROR
1509
1510 $Arguments: source : Current Drive
1511 *******************************************************************************/
1512 T_MFW_FM_STATUS mfw_fm_format(T_FM_DEVICE_TYPE source)
1513 {
1514 T_RFS_RET result;
1515 UINT16 mount_point_uc[6];
1516 TRACE_FUNCTION("mfw_fm_format");
1517 memset(mount_point_uc, 0x00,6);
1518 switch (source)
1519 {
1520 case FM_NORMS_FLASH:
1521 convert_u8_to_unicode("/NOR", mount_point_uc);
1522 break;
1523 case FM_NAND_FLASH:
1524 convert_u8_to_unicode("/NAND", mount_point_uc);
1525 break;
1526 case FM_T_FLASH:
1527 convert_u8_to_unicode("/MMC", mount_point_uc);
1528 break;
1529 }
1530
1531 result = rfs_preformat(mount_point_uc, 0xDEAD);
1532 if(result < RFS_EOK)
1533 return FM_FORMAT_ERROR;
1534 else
1535 {
1536 result = rfs_format(mount_point_uc, NULL, 0x2BAD);
1537 if (result < RFS_EOK)
1538 return FM_FORMAT_ERROR;
1539 else
1540 {
1541 /* Mar 15, 2007 DRT: OMAPS00120201 x0039928 */
1542 /* Fix: Creating the default directories for the selected device after format */
1543 mfw_fm_createRootDir(source);
1544 return FM_NO_ERROR;
1545 }
1546 }
1547 }
1548
1549 /*******************************************************************************
1550 $Function: mfw_fm_remove
1551
1552 $Description: Deletes the selected object
1553
1554 $Returns: FM_DELETE_DIRNOTEMPTY/FM_DELETE_ERROR/FM_NO_ERROR
1555
1556 $Arguments: source : Current Drive
1557 *******************************************************************************/
1558 #ifdef FF_MMI_UNICODE_SUPPORT
1559 T_MFW_FM_STATUS mfw_fm_remove(T_WCHAR* objname_u16,T_FM_DEVICE_TYPE source)
1560 #else
1561 T_MFW_FM_STATUS mfw_fm_remove(char* objname,T_FM_DEVICE_TYPE source)
1562 #endif
1563 {
1564 #ifdef FF_MMI_RFS_ENABLED
1565 T_RFS_RET rfsResult;
1566 char objname_mt[FM_MAX_DIR_PATH_LENGTH];
1567 T_WCHAR objname_uc[FM_MAX_DIR_PATH_LENGTH];
1568 #else
1569 T_FFS_RET ffsResult;
1570 #endif
1571
1572
1573 TRACE_FUNCTION("mfw_fm_remove");
1574
1575 #ifdef FF_MMI_RFS_ENABLED
1576 switch (source)
1577 {
1578 case FM_NOR_FLASH:
1579 strcpy(objname_mt,"/FFS");
1580 break;
1581 case FM_NORMS_FLASH:
1582 strcpy(objname_mt,"/NOR");
1583 break;
1584 case FM_NAND_FLASH:
1585 strcpy(objname_mt,"/NAND");
1586 break;
1587 case FM_T_FLASH:
1588 strcpy(objname_mt,"/MMC");
1589 break;
1590 }
1591 #ifdef FF_MMI_UNICODE_SUPPORT
1592 convert_u8_to_unicode(objname_mt, objname_uc);
1593 wstrcat(objname_uc, objname_u16);
1594 #else
1595 strcat(objname_mt,objname);
1596 convert_u8_to_unicode(objname_mt, objname_uc);
1597 #endif
1598 TRACE_EVENT_P1("objname %s",objname_uc);
1599 rfsResult = rfs_remove(objname_uc);
1600 if(rfsResult != RFS_EOK)
1601 {
1602 return FM_DELETE_ERROR;
1603 }
1604 #else
1605 {
1606 #ifdef FF_MMI_UNICODE_SUPPORT
1607 char objname[FM_MAX_DIR_PATH_LENGTH];
1608 convert_unicode_to_u8(objname_u16, objname);
1609 #endif
1610 TRACE_EVENT_P1("objname %s",objname);
1611 ffsResult = ffs_remove(objname);
1612 }
1613 if(ffsResult != EFFS_OK)
1614 {
1615 if(ffsResult == EFFS_DIRNOTEMPTY)
1616 return FM_DELETE_DIRNOTEMPTY;
1617 else
1618 return FM_DELETE_ERROR;
1619 }
1620
1621 #endif
1622 return FM_NO_ERROR;
1623 }
1624
1625 /*******************************************************************************
1626 $Function: mfw_fm_remove_image
1627
1628 $Description: Deletes the selcted image and its thumbnail
1629
1630 $Returns: FM_DELETE_ERROR/FM_NO_ERROR
1631
1632 $Arguments: path : Current directory path
1633 dirname : Current Directory name
1634 old_filename : Old filename
1635 new_filename : New filename
1636 source : Current Drive
1637 *******************************************************************************/
1638 T_MFW_FM_STATUS mfw_fm_remove_image(char * path, char * dirname, char* objname,T_FM_DEVICE_TYPE source)
1639 {
1640 char obj[FM_MAX_DIR_PATH_LENGTH];
1641 T_MFW_FM_STATUS ffsResult;
1642
1643 TRACE_FUNCTION("mfw_fm_delete_image");
1644
1645 sprintf(obj,"%s%s/%s.jpg",path,dirname,objname);
1646 TRACE_EVENT_P1("obj %s",obj);
1647 #ifdef FF_MMI_UNICODE_SUPPORT
1648 {
1649 T_WCHAR obj_uc[FM_MAX_DIR_PATH_LENGTH];
1650 convert_u8_to_unicode(obj, obj_uc);
1651 ffsResult = mfw_fm_remove(obj_uc,source);
1652 }
1653 #else
1654 ffsResult = mfw_fm_remove(obj,source);
1655 #endif
1656 if(ffsResult != FM_NO_ERROR)
1657 {
1658 return FM_DELETE_ERROR;
1659 }
1660 switch(source)
1661 {
1662 case FM_NOR_FLASH:
1663 sprintf(obj,"%s%s/%s.tmb",NORDIR,THUMB,objname);
1664 break;
1665 case FM_NORMS_FLASH:
1666 sprintf(obj,"%s%s/%s.tmb",NORMSDIR,THUMB,objname);
1667 break;
1668 case FM_NAND_FLASH:
1669 sprintf(obj,"%s%s/%s.tmb",NANDDIR,THUMB,objname);
1670 break;
1671 case FM_T_FLASH:
1672 sprintf(obj,"%s%s/%s.tmb",TFLASHDIR,THUMB,objname);
1673 break;
1674 }
1675 #ifdef FF_MMI_UNICODE_SUPPORT
1676 {
1677 T_WCHAR obj_uc[FM_MAX_DIR_PATH_LENGTH];
1678 convert_u8_to_unicode(obj, obj_uc);
1679 ffsResult = mfw_fm_remove(obj_uc,source);
1680 }
1681 #else
1682 ffsResult = mfw_fm_remove(obj,source);
1683 #endif
1684 if(ffsResult != FM_NO_ERROR)
1685 {
1686 return FM_DELETE_ERROR;
1687 }
1688 return FM_NO_ERROR;
1689 }
1690
1691 /*******************************************************************************
1692 $Function: mfw_fm_copy_start
1693
1694 $Description: starts copying the give file
1695
1696 $Returns: FM_COPY_ERROR/FM_COPY_DONE/FM_COPY_PROGRESS
1697
1698 $Arguments: data : Copy/Move operation related structure
1699 *******************************************************************************/
1700 T_FM_COPY_STATE mfw_fm_copy_start(T_MFW_FM_COPYMOVE_STRUCT *data)
1701 {
1702 char *ext2;
1703 T_RFS_STAT f_stat;
1704 T_RFS_SIZE iResult = 0;
1705 UINT16 source_file_uc[FM_MAX_DIR_PATH_LENGTH];
1706 UINT16 destination_file_uc[FM_MAX_DIR_PATH_LENGTH];
1707 char source_file[FM_MAX_DIR_PATH_LENGTH];
1708 char destination_file[FM_MAX_DIR_PATH_LENGTH];
1709
1710 TRACE_FUNCTION("mfw_fm_copy_start");
1711
1712 switch (data->source_type)
1713 {
1714 case FM_NOR_FLASH:
1715 strcpy(source_file,"/FFS");
1716 break;
1717 case FM_NORMS_FLASH:
1718 strcpy(source_file,"/NOR");
1719 break;
1720 case FM_NAND_FLASH:
1721 strcpy(source_file,"/NAND");
1722 break;
1723 case FM_T_FLASH:
1724 strcpy(source_file,"/MMC");
1725 break;
1726 }
1727
1728 switch (data->destination_type)
1729 {
1730 case FM_NOR_FLASH:
1731 strcpy(destination_file,"/FFS");
1732 break;
1733 case FM_NORMS_FLASH:
1734 strcpy(destination_file,"/NOR");
1735 break;
1736 case FM_NAND_FLASH:
1737 strcpy(destination_file,"/NAND");
1738 break;
1739 case FM_T_FLASH:
1740 strcpy(destination_file,"/MMC");
1741 break;
1742 }
1743 #ifdef FF_MMI_UNICODE_SUPPORT
1744 convert_u8_to_unicode(source_file, source_file_uc);
1745 convert_u8_to_unicode(destination_file, destination_file_uc);
1746 wstrcat(source_file_uc, data->sourceFile);
1747 wstrcat(destination_file_uc, data->destinationFile);
1748 #else
1749 strcat(source_file, data->sourceFile);
1750 strcat(destination_file, data->destinationFile);
1751
1752 convert_u8_to_unicode(source_file, source_file_uc);
1753 convert_u8_to_unicode(destination_file, destination_file_uc);
1754 #endif
1755
1756 ext2=(char *)mmi_fm_get_ext(source_file);//April 27, 2007 DRT:OMAPS00128836 x0073106
1757
1758 if( ( (rfs_stat(destination_file_uc, &f_stat)) != RFS_ENOENT)//April 27, 2007 DRT:OMAPS00128836 x0073106
1759 && (strcmp((const char*)ext2, "jpg") ==0 ))
1760 {
1761 return FM_COPY_NONE;
1762 }
1763
1764 data->sourceFileID = (T_RFS_FD)rfs_open( source_file_uc, RFS_O_RDONLY, NULL);
1765 data->destFileID= (T_RFS_FD)rfs_open( destination_file_uc, RFS_O_WRONLY|RFS_O_CREAT, RFS_IRUSR|RFS_IWUSR);
1766 data->bytesRead = 0;
1767
1768 if(data->sourceFileSize > FM_COPY_BUFFER_SIZE )
1769 {
1770 data->buf_size = FM_COPY_BUFFER_SIZE;
1771 data->bytesRead = data->buf_size;
1772 }
1773 else
1774 {
1775 data->buf_size = data->sourceFileSize;
1776 data->bytesRead = data->buf_size;
1777 }
1778
1779 iResult = (T_RFS_SIZE)rfs_read(data->sourceFileID, data->buf, data->buf_size );
1780 TRACE_EVENT_P1("iResult %d",iResult);
1781 if(iResult < 0)
1782 {
1783 //Error Reading
1784 rfs_close( data->sourceFileID);
1785 rfs_close(data->destFileID );
1786 return FM_COPY_ERROR;
1787 }
1788 iResult = (T_RFS_SIZE)rfs_write( data->destFileID, data->buf, data->buf_size);
1789 TRACE_EVENT_P1("iResult %d",iResult);
1790 if(iResult < 0)
1791 {
1792 //Error writing
1793 rfs_close( data->sourceFileID);
1794 rfs_close(data->destFileID );
1795 return FM_COPY_ERROR;
1796 }
1797 if(data->bytesRead < data->sourceFileSize)
1798 {
1799 return FM_COPY_PROGRESS;
1800 }
1801 else
1802 {
1803 rfs_close( data->sourceFileID);
1804 rfs_close(data->destFileID );
1805 return FM_COPY_DONE;
1806 }
1807
1808 // return FM_COPY_ERROR;
1809 }
1810
1811 /*******************************************************************************
1812 $Function: mfw_fm_copy_continue
1813
1814 $Description: resumes copying the give file
1815
1816 $Returns: FM_COPY_ERROR/FM_COPY_DONE/FM_COPY_PROGRESS
1817
1818 $Arguments: data : Copy/Move operation related structure
1819 *******************************************************************************/
1820 T_FM_COPY_STATE mfw_fm_copy_continue(T_MFW_FM_COPYMOVE_STRUCT *data)
1821 {
1822 T_RFS_SIZE iResult = 0;
1823
1824 /*
1825 UINT16 source_file_uc[FM_MAX_DIR_PATH_LENGTH];
1826 UINT16 destination_file_uc[FM_MAX_DIR_PATH_LENGTH];
1827 char source_file[FM_MAX_DIR_PATH_LENGTH];
1828 char destination_file[FM_MAX_DIR_PATH_LENGTH];
1829
1830 TRACE_FUNCTION("mfw_fm_copy_continue");
1831
1832
1833 switch (data->source_type)
1834 {
1835 case FM_NOR_FLASH:
1836 strcpy(source_file,"/FFS");
1837 break;
1838 case FM_NORMS_FLASH:
1839 strcpy(source_file,"/NOR");
1840 break;
1841 case FM_NAND_FLASH:
1842 strcpy(source_file,"/NAND");
1843 break;
1844 case FM_T_FLASH:
1845 strcpy(source_file,"/MMC");
1846 break;
1847 }
1848
1849 switch (data->destination_type)
1850 {
1851 case FM_NOR_FLASH:
1852 strcpy(destination_file,"/FFS");
1853 break;
1854 case FM_NORMS_FLASH:
1855 strcpy(destination_file,"/NOR");
1856 break;
1857 case FM_NAND_FLASH:
1858 strcpy(destination_file,"/NAND");
1859 break;
1860 case FM_T_FLASH:
1861 strcpy(destination_file,"/MMC");
1862 break;
1863 }
1864
1865 strcat(source_file, data->sourceFile);
1866 strcat(destination_file, data->destinationFile);
1867
1868 convert_u8_to_unicode(source_file, source_file_uc);
1869 convert_u8_to_unicode(destination_file, destination_file_uc);
1870
1871 */
1872 if( (data->bytesRead+ FM_COPY_BUFFER_SIZE) < data->sourceFileSize)
1873 {
1874 //More blocks to be read
1875 data->buf_size = FM_COPY_BUFFER_SIZE;
1876 data->bytesRead = data->bytesRead + data->buf_size;
1877 }
1878 else
1879 {
1880 //Last chunk to be read
1881 data->buf_size = data->sourceFileSize - data->bytesRead;
1882 data->bytesRead = data->bytesRead + FM_COPY_BUFFER_SIZE;
1883 }
1884
1885 iResult = (T_RFS_SIZE)rfs_read(data->sourceFileID, data->buf, data->buf_size );
1886 TRACE_EVENT_P1("iResult %d",iResult);
1887 if(iResult < 0)
1888 {
1889 //Error Reading
1890 rfs_close( data->sourceFileID);
1891 rfs_close(data->destFileID );
1892 return FM_COPY_ERROR;
1893 }
1894 iResult = (T_RFS_SIZE)rfs_write( data->destFileID, data->buf, data->buf_size);
1895 TRACE_EVENT_P1("iResult %d",iResult);
1896 if(iResult < 0)
1897 {
1898 //Error Writing
1899 rfs_close( data->sourceFileID);
1900 rfs_close(data->destFileID );
1901 return FM_COPY_ERROR;
1902 }
1903
1904 if(data->bytesRead < data->sourceFileSize)
1905 {
1906 return FM_COPY_PROGRESS;
1907 }
1908 else
1909 {
1910 rfs_close(data->sourceFileID);
1911 rfs_close(data->destFileID );
1912 return FM_COPY_DONE;
1913 }
1914 // return FM_COPY_ERROR;
1915 }
1916
1917 //Image List
1918 /*******************************************************************************
1919 $Function: mfw_fm_checkThumbnail
1920
1921 $Description: Checks for thumbnail
1922
1923 $Returns: FM_FILE_DOESNOTEXISTS/FM_NO_ERROR
1924
1925 $Arguments: obj : Current image
1926 source : Current Drive
1927 *******************************************************************************/
1928 T_MFW_FM_STATUS mfw_fm_checkThumbnail( char * obj,T_FM_DEVICE_TYPE source)
1929 {
1930
1931 char filename[FM_MAX_DIR_PATH_LENGTH];
1932 #ifdef FF_MMI_RFS_ENABLED
1933 T_RFS_FD fd = 0;
1934 UINT16 filename_uc[FM_MAX_DIR_PATH_LENGTH];
1935 #else
1936 T_FFS_FD fd = 0;
1937 #endif
1938 TRACE_FUNCTION("mfw_fm_check_thumbnail");
1939
1940 TRACE_EVENT_P1("File %s",obj);
1941
1942 #ifdef FF_MMI_RFS_ENABLED
1943 memset(filename, 0, FM_MAX_DIR_PATH_LENGTH);
1944 switch(source)
1945 {
1946 case FM_NOR_FLASH:
1947 sprintf(filename,"%s%s%s/%s.tmb","/FFS",NORDIR,THUMB,obj);
1948 break;
1949 case FM_NORMS_FLASH:
1950 sprintf(filename,"%s%s%s/%s.tmb","/NOR",NORMSDIR,THUMB,obj);
1951 break;
1952 case FM_NAND_FLASH:
1953 sprintf(filename,"%s%s%s/%s.tmb","/NAND",NANDDIR,THUMB,obj);
1954 break;
1955 case FM_T_FLASH:
1956 sprintf(filename,"%s%s%s/%s.tmb","/MMC",TFLASHDIR,THUMB,obj);
1957 break;
1958 }
1959 convert_u8_to_unicode(filename, filename_uc);
1960 if ((fd = rfs_open (filename_uc, RFS_O_RDONLY, NULL)) == RFS_ENOENT)
1961 {
1962 TRACE_EVENT("Create the thmbnail.");
1963 return FM_FILE_DOESNOTEXISTS;
1964 }
1965 else
1966 {
1967 TRACE_EVENT_P1("Error %d",fd);
1968 rfs_close(fd);
1969 return FM_FILE_EXISTS;
1970 }
1971 #else
1972 sprintf(filename,"%s%s/%s.tmb",NORDIR,THUMB,obj);
1973 /**********************NOTE***************************
1974 FFS API To be replaced with FS Abstraction API
1975 ******************************************************/
1976 if ((fd = ffs_open (filename, FFS_O_RDONLY)) <= EFFS_NOTFOUND)
1977 {
1978 TRACE_EVENT("Create the thmbnail.");
1979 return FM_FILE_DOESNOTEXISTS;
1980 }
1981 else
1982 {
1983 TRACE_EVENT_P1("Error %d",fd);
1984 /**********************NOTE***************************
1985 FFS API To be replaced with FS Abstraction API
1986 ******************************************************/
1987 ffs_close(fd);
1988 return FM_FILE_EXISTS;
1989 }
1990 #endif
1991 // return FM_FILE_DOESNOTEXISTS;
1992 }
1993 /*******************************************************************************
1994 $Function: mfw_fm_imgViewer_create
1995
1996 $Description: This function will create the handle of imageviewer UCP
1997
1998 $Returns: Result of the UCP creation
1999
2000 $Arguments: None
2001 *******************************************************************************/
2002 T_FM_IMG_STATE mfw_fm_imgViewer_create(void)
2003 {
2004 MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK;
2005
2006 TRACE_FUNCTION ("mfw_fm_imgViewer_create()");
2007
2008 mslResult = MSL_ImgView_Create(&msl_handle);
2009 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2010 return FM_UCP_NO_ERROR;
2011 else
2012 return FM_UCP_ERROR;
2013 }
2014
2015 /*******************************************************************************
2016 $Function: mfw_fm_imgViewer_init
2017
2018 $Description: This function will initialise the imageviewer UCP
2019
2020 $Returns: Result of the UCP initialization
2021
2022 $Arguments: None
2023 *******************************************************************************/
2024 T_FM_IMG_STATE mfw_fm_imgViewer_init(void)
2025 {
2026 MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK;
2027
2028 TRACE_FUNCTION ("mfw_fm_imgViewer_init()");
2029
2030 mslResult = MSL_ImgView_Init(msl_handle);
2031
2032 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2033 return FM_UCP_NO_ERROR;
2034 else
2035 return FM_UCP_ERROR;
2036 }
2037
2038 /*******************************************************************************
2039 $Function: mfw_fm_imgViewer_destroy
2040
2041 $Description: This function destroy the imageviewer UCP
2042
2043 $Returns: Result of the UCP destroy
2044
2045 $Arguments: None
2046 *******************************************************************************/
2047 T_FM_IMG_STATE mfw_fm_imgViewer_destroy(void)
2048 {
2049 MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK;
2050
2051 TRACE_FUNCTION ("mfw_fm_imgViewer_destroy()");
2052 mslResult = MSL_ImgView_Destroy(msl_handle);
2053 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2054 return FM_UCP_NO_ERROR;
2055 else
2056 return FM_UCP_ERROR;
2057 }
2058
2059 /*******************************************************************************
2060 $Function: mfw_fm_imgViewer_deinit
2061
2062 $Description: This function will deinit the imageviewer UCP
2063
2064 $Returns: Result of the UCP de-initialization
2065
2066 $Arguments: None
2067 *******************************************************************************/
2068 T_FM_IMG_STATE mfw_fm_imgViewer_deinit(void)
2069 {
2070 MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK;
2071
2072 TRACE_FUNCTION ("mfw_fm_imgViewer_deinit()");
2073
2074 mslResult = MSL_ImgView_Deinit(msl_handle);
2075
2076 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2077 return FM_UCP_NO_ERROR;
2078 else
2079 return FM_UCP_ERROR;
2080 }
2081
2082
2083 /*******************************************************************************
2084 $Function: mfw_fm_imgViewer_pause
2085
2086 $Description: This function will pause the imageviewer UCP.
2087
2088 $Returns: Result of the UCP pause
2089
2090 $Arguments: None
2091 *******************************************************************************/
2092 T_FM_IMG_STATE mfw_fm_imgViewer_pause(void)
2093 {
2094 MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK;
2095
2096 TRACE_FUNCTION ("mfw_fm_imgViewer_pause()");
2097 mslResult = MSL_ImgView_Pause((MSL_HANDLE)msl_handle);
2098
2099 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2100 return FM_UCP_NO_ERROR;
2101 else
2102 return FM_UCP_ERROR;
2103 }
2104
2105
2106 /*******************************************************************************
2107 $Function: mfw_fm_imgViewer_view
2108
2109 $Description: This function will start the rendering of the image on LCD.
2110
2111 $Returns: Result of the drawing the image
2112
2113 $Arguments: None
2114 *******************************************************************************/
2115 T_FM_IMG_STATE mfw_fm_imgViewer_view(void)
2116 {
2117 MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK;
2118
2119 TRACE_FUNCTION ("mfw_fm_imgViewer_view()");
2120 mslResult = MSL_ImgView_View((MSL_HANDLE)msl_handle);
2121
2122 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2123 return FM_UCP_NO_ERROR;
2124 else
2125 return FM_UCP_ERROR;}
2126 /*******************************************************************************
2127 $Function: mfw_fm_imgViewer_setImageProperty
2128
2129 $Description: This function will set the parameters for the imageviewer UCP
2130
2131 $Returns: Result of the UCP updation of configurations
2132
2133 $Arguments: filepath : Image path
2134 filename : Image name
2135 width : Image width
2136 height : Image height
2137 xoffset : Image x offset
2138 yoffset : Image y offset
2139 source : Current drive
2140 *******************************************************************************/
2141 T_FM_IMG_STATE mfw_fm_imgViewer_setImageProperty( char * filepath, char *filename, int width, int height,int xoffset, int yoffset, T_FM_DEVICE_TYPE source)
2142 {
2143
2144 MSL_IMGVIEW_STATUS mslResult;
2145 //The fullpath will be included.
2146 char tmb_name_p[FM_MAX_OBJ_NAME_LENGTH];
2147 MSL_DISPLAY_CONFIGTYPE mfw_fm_dspl_config;
2148 MSL_FILE_CONFIGTYPE mfw_fm_file_config ;
2149 int rotation_degree = 0;
2150 int zoom_factor = 0;
2151
2152 TRACE_FUNCTION ("mfw_fm_imgViewer_setImageProperty()");
2153
2154 mfw_fm_dspl_config.tImgFormat = MSL_COLOR_RGB565;
2155 mfw_fm_dspl_config.unDisplayImgHeight = height;
2156 mfw_fm_dspl_config.unDisplayImgWidth = width;
2157 mfw_fm_dspl_config.unDisplayXOffset = xoffset;
2158 mfw_fm_dspl_config.unDisplayYOffset = yoffset;
2159 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DISPLAY_CONFIGINDEX,&mfw_fm_dspl_config);
2160 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2161 mslResult = MSL_ImgView_SetConfig (msl_handle,MSL_ROTATE_CONFIGINDEX,&rotation_degree);
2162 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2163 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_ZOOM_CONFIGINDEX,&zoom_factor);
2164 mfw_fm_file_config.sFileName = (char *) mfwAlloc(FM_MAX_OBJ_NAME_LENGTH);
2165
2166 #ifdef FF_MMI_RFS_ENABLED
2167 switch (source)
2168 {
2169 case FM_NOR_FLASH:
2170 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/FFS",NORDIR,THUMB, filename);
2171 // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS;
2172 break;
2173 case FM_NORMS_FLASH:
2174 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NOR",NORMSDIR,THUMB, filename);
2175 // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS;
2176 break;
2177 case FM_NAND_FLASH:
2178 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NAND",NANDDIR,THUMB, filename);
2179 /**********************NOTE***************************
2180 Drive type to be updated
2181 ******************************************************/
2182 // mfw_fm_file_config.tFileType = MSL_FILETYPE_RFS;
2183 break;
2184 case FM_T_FLASH:
2185 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/MMC",TFLASHDIR,THUMB, filename);
2186 /**********************NOTE***************************
2187 Drive type to be updated
2188 ******************************************************/
2189 //mfw_fm_file_config.tFileType = MSL_FILETYPE_TFLASH;
2190 break;
2191 default:
2192 sprintf(tmb_name_p,"/%s/%s.tmb",THUMB, filename);
2193 }
2194 strcat(mfw_fm_file_config.sFileName,tmb_name_p);
2195 #else
2196 strcpy(mfw_fm_file_config.sFileName,tmb_name_p);
2197 #endif
2198 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2199 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DECFILE_CONFIGINDEX,&mfw_fm_file_config);
2200 mfwFree((U8 *)mfw_fm_file_config.sFileName,FM_MAX_OBJ_NAME_LENGTH);
2201 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2202 return FM_UCP_NO_ERROR;
2203 else
2204 return FM_UCP_ERROR;
2205
2206 }
2207
2208 /*******************************************************************************
2209 $Function: mfw_fm_imgViewer_setConfigs
2210
2211 $Description: This function will set the parameters for the imageviewer UCP
2212
2213 $Returns: Result of the UCP updation of configurations
2214
2215 $Arguments: filepath : Image path
2216 filename : Image name
2217 width : Image width
2218 height : Image height
2219 xoffset : Image x offset
2220 yoffset : Image y offset
2221 zFactor : Zoom factor
2222 rotation_degree : Rotate factor
2223 source : Current drive
2224 *******************************************************************************/
2225 T_FM_IMG_STATE mfw_fm_imgViewer_setConfigs(char *filename,int width, int height,int xoffset, int yoffset,U32 zFactor,int rotation_degree,T_FM_DEVICE_TYPE source)
2226 {
2227 MSL_IMGVIEW_STATUS mslResult;
2228 MSL_DISPLAY_CONFIGTYPE mfw_fm_dspl_config;
2229 MSL_FILE_CONFIGTYPE mfw_fm_file_config ;
2230 int zoom_factor = zFactor;
2231 int rAngle = rotation_degree;
2232
2233 TRACE_FUNCTION ("mfw_fm_imgViewer_setRotationConfigs()");
2234
2235 mfw_fm_dspl_config.unDisplayImgHeight = height;
2236 mfw_fm_dspl_config.unDisplayImgWidth = width;
2237 mfw_fm_dspl_config.unDisplayXOffset = xoffset;
2238 mfw_fm_dspl_config.unDisplayYOffset = yoffset;
2239 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DISPLAY_CONFIGINDEX,&mfw_fm_dspl_config);
2240
2241 mfw_fm_file_config.sFileName = (char *) mfwAlloc(FM_MAX_OBJ_NAME_LENGTH);
2242
2243 #ifdef FF_MMI_RFS_ENABLED
2244 switch (source)
2245 {
2246 case FM_NOR_FLASH:
2247 strcpy(mfw_fm_file_config.sFileName,"/FFS");
2248 // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS;
2249 break;
2250 case FM_NORMS_FLASH:
2251 strcpy(mfw_fm_file_config.sFileName,"/NOR");
2252 // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS;
2253 break;
2254 case FM_NAND_FLASH:
2255 strcpy(mfw_fm_file_config.sFileName,"/NAND");
2256 /**********************NOTE***************************
2257 Drive type to be updated
2258 ******************************************************/
2259 // mfw_fm_file_config.tFileType = MSL_FILETYPE_RFS;
2260 break;
2261 case FM_T_FLASH:
2262 strcpy(mfw_fm_file_config.sFileName,"/MMC");
2263 /**********************NOTE***************************
2264 Drive type to be updated
2265 ******************************************************/
2266 //mfw_fm_file_config.tFileType = MSL_FILETYPE_TFLASH;
2267 break;
2268 }
2269 strcat(mfw_fm_file_config.sFileName,filename);
2270 #else
2271 strcpy(mfw_fm_file_config.sFileName,filename);
2272 #endif
2273
2274 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2275 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DECFILE_CONFIGINDEX,&mfw_fm_file_config);
2276
2277 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2278 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_ZOOM_CONFIGINDEX,&zoom_factor);
2279
2280 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2281 mslResult = MSL_ImgView_SetConfig (msl_handle,MSL_ROTATE_CONFIGINDEX,&rAngle);
2282
2283 mfwFree((U8 *)mfw_fm_file_config.sFileName,FM_MAX_OBJ_NAME_LENGTH);
2284
2285 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2286 return FM_UCP_NO_ERROR;
2287 else
2288 return FM_UCP_ERROR;
2289 }
2290
2291 /*******************************************************************************
2292 $Function: mfw_imgView_setcallback
2293
2294 $Description: This function will set the callback for viewer UCP
2295
2296 $Returns: Result of the updating the callback function
2297
2298 $Arguments: None
2299 *******************************************************************************/
2300 T_FM_IMG_STATE mfw_fm_imgViewer_setcallback(void)
2301 {
2302 MSL_IMGVIEW_STATUS mslResult;
2303
2304 TRACE_FUNCTION("mfw_fm_imgViewer_setcallback");
2305
2306 mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_CALLBACKSET_CONFIGINDEX,(MSL_CALLBACK)Msl_mslil_Callback);
2307 if(mslResult == MSL_IMGVIEW_STATUS_OK)
2308 return FM_UCP_NO_ERROR;
2309 else
2310 return FM_UCP_ERROR;
2311 }
2312
2313 /*******************************************************************************
2314 $Function: mfw_fm_imgThmb_create
2315
2316 $Description: This function will create the handle of thumbnail UCP
2317
2318 $Returns: Result of the UCP create
2319
2320 $Arguments: None
2321 *******************************************************************************/
2322 T_FM_IMG_STATE mfw_fm_imgThmb_create(void)
2323 {
2324 MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK;
2325
2326 TRACE_FUNCTION ("mfw_fm_imgThmb_create()");
2327
2328 mslResult = MSL_ImgThmb_Create(&msl_handle);
2329
2330 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2331 return FM_UCP_NO_ERROR;
2332 else
2333 return FM_UCP_ERROR;
2334 }
2335
2336 /*******************************************************************************
2337 $Function: mfw_fm_imgThmb_init
2338
2339 $Description: This function will initialise of thumbnail UCP
2340
2341 $Returns: Result of the UCP initialization
2342
2343 $Arguments: None
2344 *******************************************************************************/
2345 T_FM_IMG_STATE mfw_fm_imgThmb_init(void)
2346 {
2347 MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK;
2348
2349 TRACE_FUNCTION ("mfw_fm_imgThmb_init()");
2350
2351 mslResult = MSL_ImgThmb_Init(msl_handle);
2352
2353 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2354 return FM_UCP_NO_ERROR;
2355 else
2356 return FM_UCP_ERROR;
2357 }
2358
2359 /*******************************************************************************
2360 $Function: mfw_fm_imgThmb_destroy
2361
2362 $Description: This function will destroy the thumbnail UCP.
2363
2364 $Returns: Result of the UCP destroy
2365
2366 $Arguments: None
2367 *******************************************************************************/
2368 T_FM_IMG_STATE mfw_fm_imgThmb_destroy(void)
2369 {
2370 MSL_IMGTHMB_STATUS mslResult;
2371
2372 TRACE_FUNCTION ("mfw_fm_imgThmb_destroy()");
2373
2374 mslResult = MSL_ImgThmb_Destroy(msl_handle);
2375 if (mslResult != MSL_IMGTHMB_STATUS_OK)
2376 {
2377 MSL_ImgThmb_Destroy(msl_handle);
2378 msl_handle=0;
2379 return FM_UCP_ERROR;
2380 }
2381 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2382 return FM_UCP_NO_ERROR;
2383 else
2384 return FM_UCP_ERROR;
2385 }
2386
2387 /*******************************************************************************
2388 $Function: mfw_fm_imgThmb_deinit
2389
2390 $Description: This function will deinit the thumbnail UCP.
2391
2392 $Returns: Result of the UCP de-initialization
2393
2394 $Arguments: None
2395 *******************************************************************************/
2396 T_FM_IMG_STATE mfw_fm_imgThmb_deinit(void)
2397 {
2398 MSL_IMGTHMB_STATUS mslResult;
2399
2400 TRACE_FUNCTION ("mfw_fm_imgThmb_deinit()");
2401
2402 mslResult = MSL_ImgThmb_Deinit(msl_handle);
2403
2404 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2405 return FM_UCP_NO_ERROR;
2406 else
2407 return FM_UCP_ERROR;
2408 }
2409
2410 /*******************************************************************************
2411
2412 $Function: mfw_fm_imgThmb_pause
2413
2414 $Description: This function will pasue the thumbnail UCP.
2415
2416 $Returns: Result of the UCP pause
2417
2418 $Arguments: None
2419
2420 *******************************************************************************/
2421 T_FM_IMG_STATE mfw_fm_imgThmb_pause(void)
2422 {
2423 MSL_IMGTHMB_STATUS mslResult;
2424
2425 TRACE_FUNCTION ("mfw_fm_imgThmb_pause()");
2426 mslResult = MSL_ImgThmb_Pause((MSL_HANDLE)msl_handle);
2427
2428 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2429 return FM_UCP_NO_ERROR;
2430 else
2431 return FM_UCP_ERROR;
2432 }
2433
2434 /*******************************************************************************
2435 $Function: mfw_fm_imgThmb_generate
2436
2437 $Description: This function will generate the thumbnail file in filesystem.
2438
2439 $Returns: Result of the thumbanil generation
2440
2441 $Arguments: None
2442 *******************************************************************************/
2443 T_FM_IMG_STATE mfw_fm_imgThmb_generate(void)
2444 {
2445 MSL_IMGTHMB_STATUS mslResult;
2446
2447 TRACE_FUNCTION ("mfw_fm_imgThmb_generate()");
2448
2449 mslResult = MSL_ImgThmb_Generate((MSL_HANDLE)msl_handle);
2450 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2451 return FM_UCP_NO_ERROR;
2452 else
2453 return FM_UCP_ERROR;
2454 }
2455
2456
2457 /*******************************************************************************
2458 $Function: mfw_fm_imgThmb_setparams
2459
2460 $Description: This function will set the parameters for thumbnail UCP
2461
2462 $Returns: Result of the UCP updation of configurations
2463
2464 $Arguments: inFilepath : Image path
2465 inFilename : Image name
2466 width : Image width
2467 height : Image height
2468 source : Current drive
2469 *******************************************************************************/
2470 T_FM_IMG_STATE mfw_fm_imgThmb_setparams(char * inFilepath, char* inFilename, int width,int height, T_FM_DEVICE_TYPE source)
2471 {
2472 MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK;
2473 char tmb_name_p[FM_MAX_DIR_PATH_LENGTH];
2474
2475 MSL_RESCALE_CONFIGTYPE mfw_fm_rescaleconfig ;
2476 MSL_FILE_CONFIGTYPE mfw_fm_file_config ;
2477
2478 TRACE_FUNCTION ("mfw_fm_imgThmb_setparams()");
2479
2480 mfw_fm_rescaleconfig.unRescaledImgHeight = height;
2481 mfw_fm_rescaleconfig.unRescaledImgWidth =width ;
2482 mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_RESCALE_CONFIGINDEX,&mfw_fm_rescaleconfig);
2483 mfw_fm_file_config.sFileName = (char *) mfwAlloc(FM_MAX_DIR_PATH_LENGTH);
2484 switch (source)
2485 {
2486 case FM_NOR_FLASH:
2487 sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/FFS",inFilepath,inFilename);
2488 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/FFS",NORDIR,THUMB, inFilename);
2489 // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS;
2490 break;
2491 case FM_NORMS_FLASH:
2492 sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/NOR",inFilepath,inFilename);
2493 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NOR",NORMSDIR,THUMB, inFilename);
2494 // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS;
2495 break;
2496 case FM_NAND_FLASH:
2497 /**********************NOTE***************************
2498 Drive type to be updated
2499 ******************************************************/
2500 sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/NAND",inFilepath,inFilename);
2501 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NAND",NANDDIR,THUMB, inFilename);
2502 mfw_fm_file_config.tFileType = MSL_FILETYPE_RFS;
2503 break;
2504 case FM_T_FLASH:
2505 /**********************NOTE***************************
2506 Drive type to be updated
2507 ******************************************************/
2508 sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/MMC",inFilepath,inFilename);
2509 sprintf(tmb_name_p,"%s%s%s/%s.tmb","/MMC",TFLASHDIR,THUMB, inFilename);
2510 //mfw_fm_file_config.tFileType = MSL_FILETYPE_TFLASH;
2511 break;
2512 }
2513 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2514 {
2515 mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_DECFILE_CONFIGINDEX,&mfw_fm_file_config);
2516 }
2517 sprintf(mfw_fm_file_config.sFileName,"%s",tmb_name_p);
2518 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2519 {
2520 mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_ENCFILE_CONFIGINDEX,&mfw_fm_file_config);
2521 }
2522 mfwFree((U8 *)mfw_fm_file_config.sFileName,FM_MAX_DIR_PATH_LENGTH);
2523 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2524 return FM_UCP_NO_ERROR;
2525 else
2526 return FM_UCP_ERROR;
2527 }
2528
2529 /*******************************************************************************
2530 $Function: mfw_fm_imgThmb_setcallback
2531
2532 $Description: This function will set the callback for thumbnail UCP
2533
2534 $Returns: Result of the UCP updation of configurations
2535
2536 $Arguments: None
2537 *******************************************************************************/
2538 T_FM_IMG_STATE mfw_fm_imgThmb_setcallback()
2539 {
2540 MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK;
2541
2542 TRACE_FUNCTION("mfw_fm_imgThmb_setcallback");
2543
2544 mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_CALLBACKSET_CONFIGINDEX,(MSL_CALLBACK)Msl_mslil_Callback);
2545 if(mslResult == MSL_IMGTHMB_STATUS_OK)
2546 return FM_UCP_NO_ERROR;
2547 else
2548 return FM_UCP_ERROR;
2549 }
2550
2551 /*******************************************************************************
2552 $Function: mfw_fm_thmb_mslcb
2553
2554 $Description: This function is the callback for the thumbnail UCP
2555
2556 $Returns: None
2557
2558 $Arguments: tCMd : Current command being executed by the MSL
2559 tStatus : Status of the current command
2560 *******************************************************************************/
2561 void mfw_fm_thmb_mslcb( U32 tCMd,U32 tStatus)
2562 {
2563 T_MFW_FM_PARA para;
2564
2565 TRACE_FUNCTION("mfw_fm_thmb_mslcb()");
2566 switch(tCMd)
2567 {
2568 case MSL_CMD_INIT:
2569 TRACE_EVENT_P1("MSL_CMD_INIT %d",tStatus);
2570 if(tStatus ==MSL_IMGTHMB_STATUS_OK)
2571 {
2572 para.img_state=FM_UCP_NO_ERROR;
2573 }
2574 else
2575 {
2576 para.img_state=FM_UCP_ERROR;
2577 }
2578 mfw_fm_signal(E_FM_THMB_INIT, &para);
2579 break;
2580 case MSL_CMD_GENERATE:
2581 TRACE_EVENT_P1("MSL_CMD_GENERATE %d",tStatus);
2582 switch(tStatus)
2583 {
2584 case MSL_IMGTHMB_STATUS_OK:
2585 para.img_state = FM_UCP_NO_ERROR;
2586 break;
2587 case MSL_IMGTHMB_ERROR_BAD_STREAM:
2588 para.img_state = FM_UCP_ERROR_BAD_STREAM;
2589 break;
2590 case MSL_IMGTHMB_ERROR_UNKNOWN:
2591 para.img_state = FM_UCP_ERROR_UNKNOWN;
2592 break;
2593 case MSL_IMGTHMB_ERROR_IOWRITE:
2594 para.img_state = FM_UCP_ERROR_NO_MEM;
2595 break;
2596 case MSL_IMGTHMB_ERROR_INVALID_ARGUMENT:
2597 para.img_state = FM_UCP_ERROR_INVALID_ARGUMENT;
2598 break;
2599 default :
2600 para.img_state = FM_UCP_ERROR;
2601 }
2602 mfw_fm_signal(E_FM_THMB_GEN, &para);
2603 break;
2604 case MSL_CMD_DEINIT:
2605 TRACE_EVENT_P1("MSL_CMD_DEINIT %d",tStatus);
2606 if(tStatus ==MSL_IMGTHMB_STATUS_OK)
2607 {
2608 para.img_state=FM_UCP_NO_ERROR;
2609 }
2610 else
2611 {
2612 para.img_state=FM_UCP_ERROR;
2613 }
2614 mfw_fm_signal(E_FM_THMB_DEINIT, &para);
2615 break;
2616 }
2617 }
2618
2619 /*******************************************************************************
2620 $Function: mfw_fm_view_mslcb
2621
2622 $Description: This function is the callback for the Viewer UCP
2623
2624 $Returns: None
2625
2626 $Arguments: tCMd : Current command being executed by the MSL
2627 tStatus : Status of the current command
2628 *******************************************************************************/
2629 void mfw_fm_view_mslcb( U32 tCMd,U32 tStatus)
2630 {
2631 T_MFW_FM_PARA para;
2632
2633 TRACE_FUNCTION("mfw_fm_view_mslcb()");
2634
2635 switch(tCMd)
2636 {
2637 case MSL_CMD_INIT:
2638 TRACE_EVENT_P1("MSL_CMD_INIT %d",tStatus);
2639 if(tStatus ==MSL_IMGVIEW_STATUS_OK)
2640 {
2641 para.img_state=FM_UCP_NO_ERROR;
2642 }
2643 else
2644 {
2645 para.img_state=FM_UCP_ERROR;
2646 }
2647 mfw_fm_signal(E_FM_IMG_INIT, &para);
2648 break;
2649 case MSL_CMD_VIEW:
2650 TRACE_EVENT_P1("MSL_CMD_VIEW %d",tStatus);
2651 switch(tStatus )
2652 {
2653 case MSL_IMGVIEW_STATUS_OK:
2654 para.img_state = FM_UCP_NO_ERROR;
2655 break;
2656 case MSL_IMGVIEW_ERROR_BAD_STREAM:
2657 para.img_state = FM_UCP_ERROR_BAD_STREAM;
2658 break;
2659 case MSL_IMGVIEW_ERROR_UNKNOWN:
2660 para.img_state = FM_UCP_ERROR_UNKNOWN;
2661 break;
2662 case MSL_IMGVIEW_ERROR_IOREAD:
2663 para.img_state = FM_UCP_ERROR_READ_FAILED;
2664 break;
2665 case MSL_IMGVIEW_ERROR_INVALID_ARGUMENT:
2666 para.img_state = FM_UCP_ERROR_INVALID_ARGUMENT;
2667 break;
2668 default :
2669 para.img_state = FM_UCP_ERROR;
2670 }
2671 mfw_fm_signal(E_FM_IMG_DRAW,&para);
2672 break;
2673 case MSL_CMD_DEINIT:
2674 TRACE_EVENT_P1("MSL_CMD_DEINIT %d",tStatus);
2675 if(tStatus ==MSL_IMGVIEW_STATUS_OK)
2676 {
2677 para.img_state=FM_UCP_NO_ERROR;
2678 }
2679 else
2680 {
2681 para.img_state=FM_UCP_ERROR;
2682 }
2683 mfw_fm_signal(E_FM_IMG_DEINIT, &para);
2684 break;
2685
2686 }
2687 }
2688
2689
2690 //Audio List
2691
2692 /*******************************************************************************
2693 $Function: mfw_fm_audPlay_cb
2694
2695 $Description: Callback fundtion for auio play/stop
2696
2697 $Returns: None
2698
2699 $Arguments: parameter : The structure conveying the stop indication data
2700 *******************************************************************************/
2701 void mfw_fm_audPlay_cb(void *parameter)
2702 {
2703 T_MFW_FM_PARA para;
2704 T_AS_STOP_IND *stop_ind = (T_AS_STOP_IND *)parameter;
2705
2706 /* OMAPS00151698, x0056422 */
2707 T_AS_START_IND *start_ind = ( T_AS_START_IND *)parameter;
2708
2709 /* OMAPS00151698, x0056422 */
2710
2711 T_AS_PROBAR_IND_MP3 *mp3_pb = (T_AS_PROBAR_IND_MP3 *)parameter;
2712
2713 TRACE_FUNCTION("mfw_fm_audPlay_cb");
2714
2715
2716
2717 if(mmi_get_aud_state_status() == FM_AUD_NONE)
2718 {
2719
2720 TRACE_EVENT_P1("AS_START_IND status %d ",start_ind->status);
2721 mmi_set_aud_state_status(FM_AUD_PLAY);
2722
2723 /* OMAPS00151698, x0056422 */
2724 #ifdef FF_MMI_A2DP_AVRCP
2725
2726 //if BT connected and aud is initialized, and the command wasnt from BT, then send callback
2727 tGlobalBmiBtStruct.tAudioState = FM_AUD_PLAY;
2728 if((tGlobalBmiBtStruct.bConnected != BMI_BT_NOTCONNECTED)
2729 && (start_ind->status == AS_OK))
2730 {
2731
2732
2733 if( NULL != tGlobalBmiBtStruct.BmiEventCallback)
2734 tGlobalBmiBtStruct.BmiEventCallback(BMI_EVENT_USER_PLAY);
2735 tGlobalBmiBtStruct.tCmdSrc == BMI_BT_COMMAND_NONE;
2736 }
2737 #endif // FF_MMI_A2DP_AVRCP
2738 }
2739
2740 switch(stop_ind->header.msg_id )
2741 {
2742 /* OMAPS00151698, x0056422 */
2743 case AS_PAUSE_IND:
2744 TRACE_EVENT_P1("AS_PAUSE_IND status %d",stop_ind->status);
2745 mmi_set_aud_state_status( FM_AUD_PAUSE);
2746 /* OMAPS00151698, x0056422 */
2747 #ifdef FF_MMI_A2DP_AVRCP
2748 tGlobalBmiBtStruct.tAudioState = FM_AUD_PAUSE;
2749 if(tGlobalBmiBtStruct.bConnected != BMI_BT_NOTCONNECTED)
2750 {
2751 if(NULL != tGlobalBmiBtStruct.BmiEventCallback)
2752 tGlobalBmiBtStruct.BmiEventCallback(BMI_EVENT_USER_PAUSE);
2753 tGlobalBmiBtStruct.tCmdSrc = BMI_BT_COMMAND_NONE;
2754 }
2755 #endif//FF_MMI_A2DP_AVRCP
2756 break;
2757 /* OMAPS00151698, x0056422 */
2758
2759 case AS_STOP_IND:
2760 TRACE_EVENT_P2("AS_STOP_IND status %d end %d",stop_ind->status, stop_ind->end_of_media);
2761 mfw_unset_stereo_path(mfw_get_current_audioDevice());
2762 //Daisy tang added for Real Resume feature 20071107
2763 if(isPlayer_Real_Pause)
2764 {
2765 last_file_size_played = stop_ind->file_size;
2766 last_para_aud_pt = para_aud.aud_pt;
2767 }
2768
2769 switch((int)(stop_ind->status))
2770 {
2771 case AS_NOT_SUPPORTED:
2772 para.aud_state = FM_AUD_ERROR_NOTSUPPORTED;
2773 break;
2774 case AS_MEMORY_ERR:
2775 para.aud_state = FM_AUD_ERROR_MEM;
2776 break;
2777 case AS_INTERNAL_ERR:
2778 para.aud_state = FM_AUD_ERROR_INTERNAL;
2779 break;
2780 case AS_INVALID_PARAM:
2781 para.aud_state = FM_AUD_ERROR_INVALIDPARAM;
2782 break;
2783 case AS_NOT_READY:
2784 para.aud_state = FM_AUD_ERROR_NOTREADY;
2785 break;
2786 case AS_MESSAGING_ERR:
2787 para.aud_state = FM_AUD_ERROR_MSGING;
2788 break;
2789 case AS_FFS_ERR:
2790 para.aud_state = FM_AUD_ERROR_FFS;
2791 break;
2792 case AS_PLAYER_ERR:
2793 para.aud_state = FM_AUD_ERROR_PLAYER;
2794 break;
2795 case AS_DENIED:
2796 para.aud_state = FM_AUD_ERROR_DENIED;
2797 break;
2798 case AS_AUDIO_ERR:
2799 para.aud_state = FM_AUD_ERROR_AUDIO;
2800 break;
2801 case AS_NOT_ALLOWED:
2802 para.aud_state = FM_AUD_ERROR_NOTALLOWED;
2803 break;
2804 default:
2805 para.aud_state = FM_AUD_NONE;
2806 }
2807 /* June 28, 2007 DRT: OMAPS00135749 x0062174 */
2808 mmi_set_aud_state_status( FM_AUD_NONE);
2809
2810 /* OMAPS00151698, x0056422 */
2811 #ifdef FF_MMI_A2DP_AVRCP
2812 tGlobalBmiBtStruct.tAudioState = FM_AUD_NONE;
2813 /* x0056422, updated changes from this ID */
2814 /*OMAPS001448610 : This callback code is removed since L1 sends the callback to BT for
2815 stop playback irrespective of whether the stop is due to end of media or is user prompted. */
2816 tGlobalBmiBtStruct.tCmdSrc = BMI_BT_COMMAND_NONE;
2817
2818 #endif//FF_MMI_A2DP_AVRCP
2819 /* OMAPS00151698, x0056422 */
2820 mfw_fm_signal(E_FM_AUDIO_STOP, &para);
2821 break;
2822
2823 case AS_PROBAR_IND:
2824 TRACE_EVENT_P2("pt %d tt %d",mp3_pb->u32TotalTimePlayed, mp3_pb->u32totalTimeEst);
2825 para_aud.aud_pt = mp3_pb->u32TotalTimePlayed + last_para_aud_pt; //Daisy tang added for Real Resume feature 20071107
2826 para_aud.aud_tt = mp3_pb->u32totalTimeEst;
2827 mfw_fm_signal(E_FM_AUDIO_PROG, NULL);
2828 break;
2829 }
2830 return;
2831
2832 }
2833
2834 /*******************************************************************************
2835 $Function: mfw_fm_aud_get_type
2836
2837 $Description: Deduces the type of audio file
2838
2839 $Returns: audio file type
2840
2841 $Arguments: file_name : audio file
2842 *******************************************************************************/
2843 T_FM_OBJ_TYPE mfw_fm_aud_get_type(char * file_name)
2844 {
2845 T_AS_PLAYER_TYPE player_type;
2846 UINT16 filename_uc[47];
2847 TRACE_FUNCTION("mfw_fm_aud_get_type");
2848
2849 convert_u8_to_unicode(file_name, filename_uc);
2850 as_deduce_player_type(filename_uc,&player_type);
2851 switch(player_type)
2852 {
2853 case AS_PLAYER_TYPE_MIDI:
2854 TRACE_EVENT("AS_PLAYER_TYPE_MIDI");
2855 return OBJECT_TYPE_AUDIO_MIDI;
2856 case AS_PLAYER_TYPE_MP3:
2857 TRACE_EVENT("AS_PLAYER_TYPE_MP3");
2858 return OBJECT_TYPE_AUDIO_MP3;
2859 case AS_PLAYER_TYPE_AAC:
2860 TRACE_EVENT("AS_PLAYER_TYPE_AAC");
2861 return OBJECT_TYPE_AUDIO_AAC;
2862 default:
2863 TRACE_EVENT("Default");
2864 return OBJECT_TYPE_FILE;
2865 }
2866 }
2867
2868 /*******************************************************************************
2869 $Function: mfw_fm_audPlay
2870
2871 $Description: Plays the selected audio file
2872
2873 $Returns: None
2874
2875 $Arguments: file_name : audio file
2876 file_type : audio file type
2877 *******************************************************************************/
2878 #ifdef FF_MMI_UNICODE_SUPPORT
2879 T_FM_AUD_STATE mfw_fm_audPlay(T_WCHAR * filename_uc, T_FM_OBJ_TYPE file_type, BOOL play_bar)
2880 {
2881
2882 #else
2883 T_FM_AUD_STATE mfw_fm_audPlay(char * file_name, T_FM_OBJ_TYPE file_type, BOOL play_bar)
2884 {
2885 UINT16 filename_uc[FM_MAX_DIR_PATH_LENGTH];
2886
2887 convert_u8_to_unicode(file_name, filename_uc);
2888 #endif
2889 T_AS_RET status;
2890 T_AS_PLAYER_TYPE player_type;
2891 int i=0;
2892
2893 TRACE_FUNCTION("mfw_fm_audPlay");
2894
2895 //Daisy tang added for Real Resume feature 20071107
2896 //start
2897 #ifdef FF_MMI_UNICODE_SUPPORT
2898 for(i==0;i<FM_MAX_DIR_PATH_LENGTH;i++)
2899 {
2900 last_inputFileName_uc[i]=filename_uc[i];
2901 }
2902
2903 #else
2904 strcpy(last_inputFileName, file_name);
2905 #endif
2906 last_file_type = file_type;
2907 last_play_bar = play_bar;
2908 last_file_size_played = 0;
2909 last_para_aud_pt = 0;
2910 //end
2911 switch(file_type)
2912 {
2913 case OBJECT_TYPE_AUDIO_MIDI:
2914 TRACE_EVENT("AS_PLAYER_TYPE_MIDI");
2915
2916 /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */
2917 /* Voice Limit parameter should be saved to a temp var before playing
2918 MP3 or AAC file */
2919 player_para.midi.voice_limit = mfw_player_midi_get_voice_limit();
2920 /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */
2921 /* MONO is 1 and STEREO is 2 for midi player*/
2922 player_para.midi.output_channels = player_channel;
2923 player_type = AS_PLAYER_TYPE_MIDI;
2924 break;
2925 case OBJECT_TYPE_AUDIO_MP3:
2926 TRACE_EVENT("AS_PLAYER_TYPE_MP3");
2927
2928 /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */
2929 /* Voice Limit parameter should be saved to a temp var before playing
2930 MP3 or AAC file */
2931 mfw_player_set_voice_limit (player_para.midi.voice_limit);
2932 /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */
2933 /* MONO is 0 and STEREO is 1 for mp3 player*/
2934 player_para.mp3.mono_stereo = player_channel - 1;
2935 player_para.mp3.size_file_start = 0;
2936 player_type = AS_PLAYER_TYPE_MP3;
2937 break;
2938 case OBJECT_TYPE_AUDIO_AAC:
2939 TRACE_EVENT("AS_PLAYER_TYPE_AAC");
2940
2941 /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */
2942 /* Voice Limit parameter should be saved to a temp var before playing
2943 MP3 or AAC file */
2944 mfw_player_set_voice_limit (player_para.midi.voice_limit);
2945 /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */
2946 /* MONO is 0 and STEREO is 1 for aac player*/
2947 player_para.aac.mono_stereo = player_channel - 1 ;
2948 player_para.aac.size_file_start= 0;
2949 player_type = AS_PLAYER_TYPE_AAC;
2950 break;
2951 default:
2952 /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */
2953 /* Voice Limit parameter should be saved to a temp var before playing
2954 MP3 or AAC file */
2955 player_para.midi.voice_limit = mfw_player_midi_get_voice_limit();
2956 /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */
2957 /* MONO is 1 and STEREO is 2 for midi player*/
2958 player_para.midi.output_channels = player_channel;
2959 player_type = AS_PLAYER_TYPE_MIDI;
2960 break;
2961 }
2962 as_player_set_params(player_type,&player_para);
2963
2964 mfw_set_stereo_path(mfw_get_current_audioDevice());
2965 fm_aud_return_path.addr_id = 0;
2966 fm_aud_return_path.callback_func = mfw_fm_audPlay_cb;
2967
2968 status=as_play_file(player_type,filename_uc,AS_VOLUME_HIGH,mfw_player_playback_loop_flag,play_bar,&fm_aud_return_path);
2969 if(status == AS_OK)
2970 return FM_AUD_NO_ERROR;
2971 else
2972 return FM_AUD_ERROR;
2973 }
2974
2975 /*******************************************************************************
2976 $Function: mfw_fm_audStop
2977
2978 $Description: Stops playing the selected audio file
2979
2980 $Returns: None
2981
2982 $Arguments: file_name : audio file
2983 file_type : audio file type
2984 *******************************************************************************/
2985 T_FM_AUD_STATE mfw_fm_audStop(void)
2986 {
2987 T_AS_RET status;
2988 TRACE_EVENT("mfw_fm_audStop");
2989 fm_aud_return_path.addr_id = 0;
2990 fm_aud_return_path.callback_func = mfw_fm_audPlay_cb;
2991 status=as_stop(&fm_aud_return_path);
2992 if(status == AS_OK)
2993 return FM_AUD_NO_ERROR;
2994 else
2995 return FM_AUD_ERROR;
2996 }
2997
2998 T_FM_AUD_STATE mfw_fm_audPause(void)
2999 {
3000 T_AS_RET status;
3001 TRACE_EVENT("mfw_fm_audPause");
3002 fm_aud_return_path.addr_id = 0;
3003 fm_aud_return_path.callback_func = mfw_fm_audPlay_cb;
3004 status=as_pause(&fm_aud_return_path);
3005 if(status == AS_OK)
3006 return FM_AUD_NO_ERROR;
3007 else
3008 return FM_AUD_ERROR;
3009 }
3010
3011 T_FM_AUD_STATE mfw_fm_audResume(void)
3012 {
3013 T_AS_RET status;
3014 TRACE_EVENT("mfw_fm_audResume");
3015 fm_aud_return_path.addr_id = 0;
3016 fm_aud_return_path.callback_func = mfw_fm_audPlay_cb;
3017 mmi_set_aud_state_status( FM_AUD_PLAY);
3018
3019
3020 /* OMAPS00151698, x0056422 */
3021 #ifdef FF_MMI_A2DP_AVRCP
3022 tGlobalBmiBtStruct.tAudioState = FM_AUD_PLAY;
3023 if(tGlobalBmiBtStruct.bConnected != BMI_BT_NOTCONNECTED)
3024 {
3025 /*OMAPS001448610 : This check for Headset/handset command is to be removed since the handling is now exactly the same. */
3026 if(NULL != tGlobalBmiBtStruct.BmiEventCallback)
3027 tGlobalBmiBtStruct.BmiEventCallback(BMI_EVENT_USER_RESUME);
3028 tGlobalBmiBtStruct.tCmdSrc = BMI_BT_COMMAND_NONE;
3029
3030 }
3031 #endif//FF_MMI_A2DP_AVRCP
3032
3033 /* OMAPS00151698, x0056422 */
3034 status=as_resume(&fm_aud_return_path);
3035 if(status == AS_OK)
3036 return FM_AUD_NO_ERROR;
3037 else
3038 return FM_AUD_ERROR;
3039 }
3040 //Daisy tang added for Real Resume feature 20071107
3041 //start
3042 T_FM_AUD_STATE mfw_fm_audRealPause(void)
3043 {
3044 T_AS_RET status;
3045 TRACE_EVENT("mfw_fm_audRealPause");
3046 isPlayer_Real_Pause = TRUE;
3047
3048 fm_aud_return_path.addr_id = 0;
3049 fm_aud_return_path.callback_func = mfw_fm_audPlay_cb;
3050 status=as_stop(&fm_aud_return_path);
3051 if(status == AS_OK)
3052 return FM_AUD_NO_ERROR;
3053 else
3054 return FM_AUD_ERROR;
3055 }
3056
3057 T_FM_AUD_STATE mfw_fm_audRealResume(void)
3058 {
3059 T_AS_RET status;
3060 T_AS_PLAYER_TYPE player_type;
3061 UINT16 filename_uc[FM_MAX_DIR_PATH_LENGTH];
3062 int i=0;
3063
3064
3065 TRACE_FUNCTION("mfw_fm_audRealResume");
3066
3067 if(!isPlayer_Real_Pause)
3068 return FM_AUD_ERROR;
3069 if((last_file_type NEQ OBJECT_TYPE_AUDIO_MP3) AND (last_file_type NEQ OBJECT_TYPE_AUDIO_AAC))
3070 return FM_AUD_ERROR;
3071
3072 isPlayer_Real_Pause = FALSE;
3073
3074 switch(last_file_type)
3075 {
3076 case OBJECT_TYPE_AUDIO_MP3:
3077 TRACE_EVENT("AS_PLAYER_TYPE_MP3");
3078
3079 /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */
3080 /* Voice Limit parameter should be saved to a temp var before playing
3081 MP3 or AAC file */
3082 mfw_player_set_voice_limit (player_para.midi.voice_limit);
3083 /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */
3084 /* MONO is 0 and STEREO is 1 for mp3 player*/
3085 player_para.mp3.mono_stereo = player_channel - 1;
3086 player_para.mp3.size_file_start = last_file_size_played;//Daisy tang added for MP3 feature 20071107
3087 player_type = AS_PLAYER_TYPE_MP3;
3088 break;
3089 case OBJECT_TYPE_AUDIO_AAC:
3090 TRACE_EVENT("AS_PLAYER_TYPE_AAC");
3091
3092 /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */
3093 /* Voice Limit parameter should be saved to a temp var before playing
3094 MP3 or AAC file */
3095 mfw_player_set_voice_limit (player_para.midi.voice_limit);
3096 /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */
3097 /* MONO is 0 and STEREO is 1 for aac player*/
3098 player_para.aac.mono_stereo = player_channel - 1 ;
3099 player_para.aac.size_file_start= last_file_size_played;//Daisy tang added for MP3 feature 20071107
3100
3101 player_type = AS_PLAYER_TYPE_AAC;
3102 break;
3103 }
3104 as_player_set_params(player_type,&player_para);
3105
3106 mfw_set_stereo_path(mfw_get_current_audioDevice());
3107 fm_aud_return_path.addr_id = 0;
3108 fm_aud_return_path.callback_func = mfw_fm_audPlay_cb;
3109 #ifdef FF_MMI_UNICODE_SUPPORT
3110 for(i==0;i<FM_MAX_DIR_PATH_LENGTH;i++)
3111 {
3112 filename_uc[i]=last_inputFileName_uc[i];
3113 }
3114 #else
3115 convert_u8_to_unicode(last_inputFileName, filename_uc);
3116 #endif
3117 status=as_play_file(player_type,filename_uc,AS_VOLUME_HIGH,mfw_player_playback_loop_flag,last_play_bar,&fm_aud_return_path);
3118 if(status == AS_OK)
3119 return FM_AUD_NO_ERROR;
3120 else
3121 return FM_AUD_ERROR;
3122 }
3123 //end
3124
3125
3126 #endif
3127
3128