FreeCalypso > hg > fc-tourmaline
diff src/ui/mfw/mfw_fm.c @ 3:67bfe9f274f6
src/ui: import of src/ui3 from Magnetite
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Fri, 16 Oct 2020 06:33:10 +0000 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/ui/mfw/mfw_fm.c Fri Oct 16 06:33:10 2020 +0000 @@ -0,0 +1,3128 @@ +#ifdef FF_MMI_FILEMANAGER +/* ========================================================= +* Texas Instruments OMAP(TM) Platform Software +* (c) Copyright Texas Instruments, Incorporated. All Rights Reserved. +* +* Use of this software is controlled by the terms and conditions found +* in the license agreement under which this software has been supplied. +* ========================================================== */ + +/*========================================================== +* @file mfw_fmc +* +* This provides the functionality of File Manager Applications. +* It supports file/Directory related operations on NOR, NAND and MMC +* +* @path \bmi\condat\ms\src\mfw +* +* @rev 00.01 +*/ +/* ========================================================== */ +/*=========================================================== +*! +*! Revision History +*! =================================== + + Nov 12 2007 DRT :OMAPS00144861 x0056422 + Description: MM: There are some issues with resume and stop + callback in BT MMI code. + + + Aug 27, 2007 REF:DRT OMAPS00137370 x0045876 + Description: MM: MIDI/IMY file is not played correctly after listening a + MP3 in the Browse Midi list. + Solution: Param Voice_Limit is changed when MP3 or AAC file is played. So before + playing MP3 or AAC file, Voice_Limit should be saved. + + Jul 04, 2007 DRT:OMAPS00135749 x0062174(Nimitha) + Description: Once the audio file has finished automatically play button has to be pressed twice, + in order to be played again. + Solution : The global variable aud_state_status is set to AUD_FM_NONE once the file playing stopped. + + April 27, 2007 DRT:OMAPS00128836 x0073106 + Description: Unexpected behavior when copying images with the same names from a memory to another. + Solution:In mfw_fm_copy_start () added a if condition if(rfs_stat() && image file). + + Apr 10, 2007 DRT: OMAPS00125309 x0039928 + Description: MM - Mono option does not work => MMI changes required + Solution: Selected Output channel from the settings menu is set for all the players. + + Apr 06, 2007 DRT: OMAPS00124877 x0039928 + Description: MM: Voice limit Options doesn't work + Solution: voice limit value is taken from the global variable set by menu options. + + Mar 28, 2007 ER: OMAPS00106188 x0039928 + Description: Align Midi application menu choices and audio Player menu choices + + Mar 15, 2007 DRT: OMAPS00120201 x0039928 + Description: JPEG dir not created in FFS in N5.23 pre release + Solution: The directories are created after format for NOR-MS, NAND and T-FLASH + +*! 10-Apr-2006 mf: Modified x0020906. Change required per SRxxxx +*! to provide File Manager Functionality. +*! +*! +*! 17-Jan-2006 mf: Revisions appear in reverse chronological order; +*! that is, newest first. The date format is dd-Mon-yyyy. +* =========================================================== */ + +/****************************************************************************** + Include Files +*******************************************************************************/ +#define ENTITY_MFW + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> + +#define FF_MMI_RFS_ENABLED + +#if defined (NEW_FRAME) + +#include "typedefs.h" +#include "vsi.h" +#include "pei.h" +#include "custom.h" +#include "gsm.h" + +#else + +#include "STDDEFS.H" +#include "custom.h" +#include "gsm.h" +#include "vsi.h" + +#endif + + +#include "mfw_mfw.h" +#include "mfw_phb.h" +#include "mfw_phbi.h" +#include "mfw_cm.h" +#include "mfw_cmi.h" + +#include "mfw_nm.h" +#include "mfw_sim.h" +#include "mfw_sima.h" +#include "mfw_nmi.h" +#include "mfw_simi.h" +#include "mfw_sms.h" +#include "mfw_smsi.h" +#include "mfw_win.h" + +#include "ksd.h" +#include "psa.h" + +#if defined (FAX_AND_DATA) +#include "aci_fd.h" +#endif + +//#ifdef FF_MMI_RFS_ENABLED +#include "rfs/rfs_api.h" +//#else +#include "ffs/ffs_api.h" +//#endif + +#include "message.h" +#include "prim.h" +#include "aci_cmh.h" + +#include "cmh.h" +#include "phb.h" +#include "cmh_phb.h" + +#include "mfw_ss.h" +#include "mfw_ssi.h" +#include "mfw_win.h" + +#include "gdi.h" +#include "prim.h" +#ifndef PCM_2_FFS +#include "pcm.h" +#endif + +#ifdef FF_MMI_MIDI_FORMAT +#include "bae/bae_options.h" +#endif + +#include "mfw_fm.h" +/**********************NOTE*************************** +FFS header To be replaced with FS Abstraction Header +******************************************************/ + +#ifdef FF_MMI_A2DP_AVRCP +#include "mfw_bt_api.h" +#include "mfw_bt_private.h" +#endif + + +#ifdef INT_PHONEBOOK +#include "ATBPbGI.h" +#endif +/******************************************************************************* + + Defines + +*******************************************************************************/ +EXTERN MfwHdr * current_mfw_elem; +static MSL_HANDLE msl_handle; +static T_RV_RETURN_PATH fm_aud_return_path; +T_MFW_AUD_PARA para_aud; +extern UBYTE mfw_player_playback_loop_flag; +extern T_AS_PLAYER_PARAMS player_para; +extern INT16 player_channel; +extern int aud_state_status; + + +/* OMAPS00151698, x0056422 */ +#ifdef FF_MMI_A2DP_AVRCP +extern BMI_BT_STRUCTTYPE tGlobalBmiBtStruct; +#endif +//Daisy tang added for Real Resume feature 20071107 +//start +BOOL isPlayer_Real_Pause = FALSE; +UINT32 last_file_size_played = 0; +char last_inputFileName[FM_MAX_DIR_PATH_LENGTH]; +T_WCHAR last_inputFileName_uc[FM_MAX_DIR_PATH_LENGTH]; +T_AS_PLAYER_TYPE last_file_type; +BOOL last_play_bar; +UINT32 last_para_aud_pt; +//end + + +/******************************************************************************* + + Local prototypes + +*******************************************************************************/ + +void Msl_mslil_Callback(void* handle, U32 ucp_type, U32 tCMd, U32 tStatus); +void mfw_fm_audPlay_cb(void *parameter); +void mfw_fm_signal(T_MFW_EVENT event, void *para); +BOOL mfw_fm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_FM_PARA * para); +/* June 28, 2007 DRT: OMAPS00135749 x0062174 */ +EXTERN void mmi_set_aud_state_status( T_FM_AUD_STATE status); + + +/******************************************************************************* + $Function: mfw_fm_create + + $Description: This function initialises an Mfw fm entity and adds it to the Window Stack + + $Returns: T_MFW_HND : A handle for the entity + + $Arguments: hWin : Parent Window Handle + event : Event Mask of the events to be handled + cbfunc : Callback function to handle the events +*******************************************************************************/ +T_MFW_HND mfw_fm_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc) +{ + T_MFW_HDR *hdr; + T_MFW_FM *fm_para; + + TRACE_FUNCTION("mfw_FM_create()"); + + hdr = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR)); + fm_para = (T_MFW_FM *) mfwAlloc(sizeof (T_MFW_FM)); + + if (!hdr OR !fm_para) + return FALSE; + + /* + * initialisation of the handler + */ + fm_para->emask = event; + fm_para->handler = cbfunc; + + hdr->data = fm_para; + hdr->type = MfwTypfm; + + /* + * installation of the handler + */ + return mfwInsert((T_MFW_HDR *)hWin, hdr); +} + +/******************************************************************************* + + $Function: mfw_fm_delete + + $Description: This function clears down an Mfw entity and removes it from the + Window Stack + + $Returns: T_MFW_RES : The result of the function + + $Arguments: T_MFW_HND : The Handle of the entity to be removed + +*******************************************************************************/ +T_MFW_RES mfw_fm_delete(T_MFW_HND hnd) +{ + TRACE_FUNCTION("mfw_FM_delete()"); + + if (!hnd OR !((T_MFW_HDR *)hnd)->data) + return MFW_RES_ILL_HND; + + if (!mfwRemove((T_MFW_HDR *)hnd)) + return MFW_RES_ILL_HND; + + mfwFree((U8 *)(((T_MFW_HDR *) hnd)->data),sizeof(T_MFW_FM)); + mfwFree((U8 *)hnd,sizeof(T_MFW_HDR)); + + return MFW_RES_OK; +} + +/******************************************************************************* + + $Function: mfw_fm_sign_exec + + $Description: This function sends the Mfw FM events from the Mfw to the BMI. + + $Returns: None + + $Arguments: None + +*******************************************************************************/ +BOOL mfw_fm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_FM_PARA * para) +{ + TRACE_FUNCTION("mfw_fm_sign_exec()"); + + + while (cur_elem) + { + /* + * event handler is available + */ + if (cur_elem->type EQ MfwTypfm) + { + T_MFW_FM * fm_data; + TRACE_EVENT("MfwTyFm"); + /* + * handler is FM management handler + */ + fm_data = (T_MFW_FM *)cur_elem->data; + if (fm_data->emask & event) + { + /* + * event is expected by the call back function + */ + fm_data->event = event; + switch (event) + { + /* + ** Generic Events + */ + case E_FM_THMB_INIT: + case E_FM_THMB_DEINIT: + case E_FM_THMB_GEN: + case E_FM_IMG_INIT: + case E_FM_IMG_DRAW: + case E_FM_IMG_DEINIT: + case E_FM_AUDIO_STOP: + if(para!=NULL) + memcpy (&fm_data->para, para, sizeof (T_MFW_FM_PARA)); + break; + } + /* + * if call back defined, call it + */ + if (fm_data->handler) + { + // store current mfw elem + current_mfw_elem = cur_elem; + if ((*(fm_data->handler)) (fm_data->event, (void *)&fm_data->para)) + return TRUE; + } + } + } + cur_elem = cur_elem->next; + } + return FALSE; +} + +/******************************************************************************* + + $Function: mfw_FM_signal + + $Description: This function sends the Mfw events from the Mfw to the BMI. + + $Returns: None + + $Arguments: T_MFW_EVENT : The event to be sent to the BMI + void * : Pointer to the Event data + +*******************************************************************************/ +void mfw_fm_signal(T_MFW_EVENT event, void *para) +{ + UBYTE temp; + temp = dspl_Enable(0); + + TRACE_FUNCTION("mfw_FM_signal()"); + + if (mfwSignallingMethod EQ 0) + { + /* + * focus is on a window + */ + if (mfwFocus) + { + /* + * send event to sim management + * handler if available + */ + if (mfw_fm_sign_exec (mfwFocus, event, para)) + { + dspl_Enable(temp); + return; + } + } + /* + * actual focussed window is not available + * or has no network management registration + * handler, then search all nodes from the root. + */ + if (mfwRoot) + mfw_fm_sign_exec (mfwRoot, event, para); + } + else + { + MfwHdr * h = 0; + /* + * Focus set, then start here + */ + if (mfwFocus) + h = mfwFocus; + /* + * Focus not set, then start root + */ + if (!h) + h = mfwRoot; + /* + * No elements available, return + */ + while (h) + { + /* + * Signal consumed, then return + */ + if (mfw_fm_sign_exec (h, event, para)) + { + dspl_Enable(temp); + return; + } + /* + * All windows tried inclusive root + */ + if (h == mfwRoot) + { + dspl_Enable(temp); + return; + } + /* + * get parent window + */ + h = mfwParent(mfwParent(h)); + + if (h) + h = ((MfwWin * )(h->data))->elems; + } + + mfw_fm_sign_exec (mfwRoot, event, para); + + } + dspl_Enable(temp); + return; +} + +/******************************************************************************* + $Function: mfw_fm_readDir + + $Description: Reads the objects from the given directory + + $Returns: FM_DIR_DOESNOTEXISTS/FM_READDIR_ERROR/FM_NO_ERROR + + $Arguments: dir_path : Current Directory Path + dir_name : Current Directory Name + num_objs : num of obejcts + obj_list : object list + source : Current Drive +*******************************************************************************/ +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) +{ + char curDir[FM_MAX_DIR_PATH_LENGTH]; + /* x0083025 - OMAPS00156759 - Jan 29, 2008 */ +#if defined(FF_MMI_UNICODE_SUPPORT)||defined (FF_MMI_RFS_ENABLED) + T_WCHAR objName_uc[FM_MAX_OBJ_NAME_LENGTH]; + T_WCHAR curObj_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + char objName_u8[FM_MAX_OBJ_NAME_LENGTH]; +#endif + +#ifdef FF_MMI_RFS_ENABLED + char ext1[FM_MAX_EXT_LENGTH]; + T_RFS_DIR f_dir; + UINT16 curDir_uc[FM_MAX_DIR_PATH_LENGTH]; + T_RFS_RET result; + T_RFS_STAT f_stat; +#else + T_FFS_DIR f_dir; +#endif + int iCount=0; + + TRACE_FUNCTION("mfw_fm_readDir"); + + *num_objs = 0; + memset(curDir, 0, FM_MAX_DIR_PATH_LENGTH); +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + sprintf(curDir,"%s%s%s","/FFS",dir_path,dir_name); + TRACE_EVENT_P1("Current Dir %s",curDir); + break; + case FM_NORMS_FLASH: + sprintf(curDir,"%s%s%s","/NOR",dir_path,dir_name); + TRACE_EVENT_P1("Current Dir %s",curDir); + break; + case FM_NAND_FLASH: + sprintf(curDir,"%s%s%s","/NAND",dir_path,dir_name); + TRACE_EVENT_P1("Current Dir %s",curDir); + break; + case FM_T_FLASH: + sprintf(curDir,"%s%s%s","/MMC",dir_path,dir_name); + TRACE_EVENT_P1("Current Dir %s",curDir); + break; + default: + TRACE_EVENT("Default: Invalid value"); + break; + } + + convert_u8_to_unicode((const char *)curDir, curDir_uc); + if (rfs_opendir (curDir_uc, &f_dir) < 0) + { + TRACE_EVENT_P1("Opening dir %s Failed",curDir); + return FM_DIR_DOESNOTEXISTS; + } + + for (iCount = 0; rfs_readdir (&f_dir, objName_uc, FM_MAX_OBJ_NAME_LENGTH) > 0x0; ) + { + if (objName_uc[0] == '\0') + { + return FM_READDIR_ERROR; + } + if( objName_uc[0] != '.' ) + { + /* x0083025 - OMAPS00156759 - Jan 29, 2008 */ + wstrcpy(curObj_uc, curDir_uc); + { // append '/' char to the end of string + T_WCHAR *tmp = curObj_uc; + while (*tmp) ++tmp; + *tmp++ = '/'; + *tmp = 0; + } + wstrcat(curObj_uc, objName_uc); + + result= rfs_stat(curObj_uc, &f_stat); + + if(result == RFS_EOK) + { + if(f_stat.file_dir.mode & RFS_IXUSR) + { + obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ)); + + /* x0083025 - OMAPS00156759 - Jan 29, 2008 */ + #ifdef FF_MMI_UNICODE_SUPPORT + wstrcpy(obj_list[iCount]->name_uc, objName_uc); + TRACE_EVENT_P1("%s", obj_list[iCount]->name_uc); + #endif + convert_unicode_to_u8(objName_uc, obj_list[iCount]->name); + TRACE_EVENT_P1("%s", obj_list[iCount]->name); + (*num_objs)++; + iCount++; + if((*num_objs) >= FM_MAX_OBJ ) + { + TRACE_EVENT("MAX COUNT Reached"); + if(source == FM_NOR_FLASH) + rfs_closedir(&f_dir); + return FM_NO_ERROR; + } + } + else + { + /* x0083025 - OMAPS00156759 - Jan 29, 2008 */ + convert_unicode_to_u8(wstrchr(objName_uc,'.')+1, ext1); + + if(ext1) + { + switch(app) + { + case FM_IMAGE: + if(strcmp(ext1, "jpg") == 0) + { + obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ)); + + /* x0083025 - OMAPS00156759 - Jan 29, 2008 */ + convert_unicode_to_u8(objName_uc, obj_list[iCount]->name); + + TRACE_EVENT_P1("%s", obj_list[iCount]->name); + (*num_objs)++; + iCount++; + if((*num_objs) >= FM_MAX_OBJ ) + { + TRACE_EVENT("MAX COUNT Reached"); + if(source == FM_NOR_FLASH) + rfs_closedir(&f_dir); + return FM_NO_ERROR; + } + } + break; + case FM_AUDIO: + if( + +#ifdef FF_MP3_RINGER + (strcmp(ext1, "mp3") == 0) +#else + (0) +#endif +#ifdef FF_AAC_RINGER + || (strcmp(ext1, "aac") == 0) +#else + || (0) +#endif + +#ifdef FF_MMI_MIDI_FORMAT + +#ifdef PAL_ENABLE_XMF + || (strcmp(ext1, "xmf") == 0) +#else + || (0) +#endif +#ifdef PAL_ENABLE_IMELODY + || (strcmp(ext1, "imy") == 0) +#else + || (0) +#endif +#ifdef PAL_ENABLE_SMAF_MA3 + || (strcmp(ext1, "mmf") == 0) +#else + || (0) +#endif +#ifdef PAL_ENABLE_XMF + || (strcmp(ext1, "mxmf") == 0) +#else + || (0) +#endif +#ifdef PAL_ENABLE_SMS + || (strcmp(ext1, "sms") == 0) +#else + || (0) +#endif +#ifdef PAL_ENABLE_DIGITAL_AUDIO + || (strcmp(ext1, "wav") == 0) +#else + || (0) +#endif +#ifdef PAL_ENABLE_MIDI_NORMALIZER + || (strcmp(ext1, "mid") == 0) +#else + || (0) +#endif + +#endif + ) + + { + obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ)); + /* x0083025 - OMAPS00156759 - Jan 29, 2008 */ + #ifdef FF_MMI_UNICODE_SUPPORT + wstrcpy(obj_list[iCount]->name_uc, objName_uc); + TRACE_EVENT_P1("%s", obj_list[iCount]->name_uc); + #else + convert_unicode_to_u8(objName_uc, obj_list[iCount]->name); + TRACE_EVENT_P1("%s", obj_list[iCount]->name); + #endif + (*num_objs)++; + iCount++; + if((*num_objs) >= FM_MAX_OBJ ) + { + TRACE_EVENT("MAX COUNT Reached"); + if(source == FM_NOR_FLASH) + rfs_closedir(&f_dir); + return FM_NO_ERROR; + } + } + break; + } + } + } + } + } + } + TRACE_EVENT_P2("Dir %s contains %d Objects",curDir,iCount); + if(source == FM_NOR_FLASH) + rfs_closedir(&f_dir); +#else + sprintf(curDir,"%s%s",dir_path,dir_name); + TRACE_EVENT_P1("Current Dir %s",curDir); + + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + if (ffs_opendir (curDir, &f_dir) < 0) + { + TRACE_EVENT_P1("Opening dir %s Failed",curDir); + return FM_DIR_DOESNOTEXISTS; + } + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + for (iCount = 0; ffs_readdir (&f_dir, objName_u8, FM_MAX_OBJ_NAME_LENGTH) > 0x0; iCount++) + { + if (objName_u8[0] == '\0') + { + return FM_READDIR_ERROR; + } + if( objName_u8[0] != '.' ) + { + obj_list[iCount] = (T_FM_OBJ*)mfwAlloc(sizeof(T_FM_OBJ)); + strcpy(obj_list[iCount]->name, objName_u8); + TRACE_EVENT_P1("%s", obj_list[iCount]->name); + (*num_objs)++; + if((*num_objs) >= FM_MAX_OBJ ) + { + TRACE_EVENT("MAX COUNT Reached"); + break; + } + } + } + TRACE_EVENT_P2("Dir %s contains %d Objects",curDir,iCount); +#endif + + + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_rename + + $Description: Renames the selcted object with the new name + + $Returns: FM_RENAME_ERROR/FM_NO_ERROR + + $Arguments: old_filename : Old filename + new_filename : New filename + source : Current Drive +*******************************************************************************/ +#ifdef FF_MMI_UNICODE_SUPPORT +T_MFW_FM_STATUS mfw_fm_rename(T_WCHAR* old_filename, T_WCHAR* new_filename, T_FM_DEVICE_TYPE source) +#else +T_MFW_FM_STATUS mfw_fm_rename(char* old_filename, char * new_filename, T_FM_DEVICE_TYPE source) +#endif +{ + +#ifdef FF_MMI_RFS_ENABLED + T_RFS_RET rfsResult; + char old_filename_mt[FM_MAX_DIR_PATH_LENGTH]; + char new_filename_mt[FM_MAX_DIR_PATH_LENGTH]; + UINT16 new_filename_uc[FM_MAX_DIR_PATH_LENGTH]; + UINT16 old_filename_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + +#if defined(FF_MMI_UNICODE_SUPPORT) && !defined(FF_MMI_RFS_ENABLED) + char old_filename_u8[FM_MAX_DIR_PATH_LENGTH]; + char new_filename_u8[FM_MAX_DIR_PATH_LENGTH]; +#endif + + T_FFS_RET ffsResult; +#endif + + TRACE_FUNCTION("mfw_fm_rename"); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + strcpy(old_filename_mt, "/FFS"); + strcpy(new_filename_mt, "/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(old_filename_mt, "/NOR"); + strcpy(new_filename_mt, "/NOR"); + break; + case FM_NAND_FLASH: + strcpy(old_filename_mt, "/NAND"); + strcpy(new_filename_mt, "/NAND"); + break; + case FM_T_FLASH: + strcpy(old_filename_mt, "/MMC"); + strcpy(new_filename_mt, "/MMC"); + break; + } + +#ifdef FF_MMI_UNICODE_SUPPORT + convert_u8_to_unicode(old_filename_mt,old_filename_uc); + convert_u8_to_unicode(new_filename_mt, new_filename_uc); + wstrcat(old_filename_uc, old_filename); + wstrcat(new_filename_uc, new_filename); +#else + strcat(old_filename_mt, old_filename); + strcat(new_filename_mt, new_filename); + convert_u8_to_unicode(old_filename_mt,old_filename_uc); + convert_u8_to_unicode(new_filename_mt, new_filename_uc); +#endif + + rfsResult = rfs_rename(old_filename_uc, new_filename_uc); + if(rfsResult != RFS_EOK) + { + return FM_RENAME_ERROR; + } +#else + +#ifdef FF_MMI_UNICODE_SUPPORT + convert_unicode_to_u8(old_filename, old_filename_u8); + convert_unicode_to_u8(new_filename, new_filename_u8; + + ffsResult = ffs_rename(old_filename_u8,new_filename_u8); +#else + ffsResult = ffs_rename(old_filename,new_filename); +#endif + if(ffsResult != EFFS_OK) + { + return FM_RENAME_ERROR; + } +#endif + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_rename_image + + $Description: Renames the selected image and its thumbnail with the new name + + $Returns: FM_RENAME_ERROR/FM_NO_ERROR + + $Arguments: path : Current directory path + dirname : Current Directory name + old_filename : Old filename + new_filename : New filename + source : Current Drive +*******************************************************************************/ +T_MFW_FM_STATUS mfw_fm_rename_image(char * path, char * dirname, char* old_filename, char * new_filename, T_FM_DEVICE_TYPE source) +{ + T_MFW_FM_STATUS ffsResult; + char t_oldfilename[FM_MAX_DIR_PATH_LENGTH]; + char t_newfilename[FM_MAX_DIR_PATH_LENGTH]; + +#ifdef FF_MMI_UNICODE_SUPPORT + T_WCHAR oldfilename_uc[FM_MAX_DIR_PATH_LENGTH]; + T_WCHAR newfilename_uc[FM_MAX_DIR_PATH_LENGTH]; +#endif + + TRACE_FUNCTION("mfw_fm_rename_image"); + +#ifdef FF_MMI_RFS_ENABLED + + sprintf(t_oldfilename,"%s%s/%s.jpg",path,dirname,old_filename); + sprintf(t_newfilename,"%s%s/%s.jpg",path,dirname,new_filename); +/* February 8, 2008 DRT:OMAPS00156759 (x0083025) For Unicode Support--> Start*/ + +#ifdef FF_MMI_UNICODE_SUPPORT + convert_u8_to_unicode(t_oldfilename, oldfilename_uc); + convert_u8_to_unicode(t_newfilename, newfilename_uc); + ffsResult = mfw_fm_rename(oldfilename_uc,newfilename_uc,source); +#else + ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source); +#endif + if(ffsResult != FM_NO_ERROR) + { + return FM_RENAME_ERROR; + } + switch(source) + { + case FM_NOR_FLASH: + sprintf(t_oldfilename,"%s%s/%s.tmb",NORDIR,THUMB,old_filename); + sprintf(t_newfilename,"%s%s/%s.tmb",NORDIR,THUMB,new_filename); + break; + case FM_NORMS_FLASH: + sprintf(t_oldfilename,"%s%s/%s.tmb",NORMSDIR,THUMB,old_filename); + sprintf(t_newfilename,"%s%s/%s.tmb",NORMSDIR,THUMB,new_filename); + break; + case FM_NAND_FLASH: + sprintf(t_oldfilename,"%s%s/%s.tmb",NANDDIR,THUMB,old_filename); + sprintf(t_newfilename,"%s%s/%s.tmb",NANDDIR,THUMB,new_filename); + break; + case FM_T_FLASH: + sprintf(t_oldfilename,"%s%s/%s.tmb",TFLASHDIR,THUMB,old_filename); + sprintf(t_newfilename,"%s%s/%s.tmb",TFLASHDIR,THUMB,new_filename); + break; + } + +#ifdef FF_MMI_UNICODE_SUPPORT + convert_u8_to_unicode(t_oldfilename, oldfilename_uc); + convert_u8_to_unicode(t_newfilename, newfilename_uc); + ffsResult = mfw_fm_rename(oldfilename_uc,newfilename_uc,source); +#else + ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source); +#endif + if(ffsResult != FM_NO_ERROR) + { + return FM_RENAME_ERROR; + } +#else + sprintf(t_oldfilename,"%s%s/%s.jpg",path,dirname,old_filename); + sprintf(t_newfilename,"%s%s/%s.jpg",path,dirname,new_filename); + + ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source); + if(ffsResult != FM_NO_ERROR) + { + return FM_RENAME_ERROR; + } + sprintf(t_oldfilename,"%s%s/%s.tmb",NORDIR,THUMB,old_filename); + sprintf(t_newfilename,"%s%s/%s.tmb",NORDIR,THUMB,new_filename); + + ffsResult = mfw_fm_rename(t_oldfilename,t_newfilename,source); + + if(ffsResult != FM_NO_ERROR) + { + return FM_RENAME_ERROR; + } +#endif + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_createRootDir + + $Description: Creates the root jpeg, tones directory + + $Returns: FM_NO_ERROR + + $Arguments: source : Current Drive +*******************************************************************************/ +T_MFW_FM_STATUS mfw_fm_createRootDir(T_FM_DEVICE_TYPE source) +{ +#ifdef FF_MMI_RFS_ENABLED + T_RFS_RET ffsResult; + T_RFS_DIR f_dir; + UINT16 dir_path_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + T_FFS_RET ffsResult; + T_FFS_DIR f_dir; +#endif + char dir_path[FM_MAX_DIR_PATH_LENGTH]; + + TRACE_FUNCTION("mfw_fm_createRootDir"); + +#ifdef FF_MMI_RFS_ENABLED + TRACE_EVENT_P1("Source %d",source); + switch (source) + { + case FM_NOR_FLASH: + sprintf(dir_path,"%s%s%s","/FFS",NORDIR,NORDIR_IMG); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + if(ffsResult > 0) + rfs_closedir(&f_dir); + else if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/FFS",NORDIR,THUMB); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + if(ffsResult > 0) + rfs_closedir(&f_dir); + else if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/FFS",NORDIR,NORDIR_AUD); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + if(ffsResult > 0) + rfs_closedir(&f_dir); + else if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + break; + case FM_NORMS_FLASH: + sprintf(dir_path,"%s%s%s","/NOR",NORMSDIR,NORMSDIR_IMG); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/NOR",NORMSDIR,THUMB); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/NOR",NORMSDIR,NORMSDIR_AUD); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + break; + case FM_NAND_FLASH: + /**********************NOTE*************************** + FS Abstraction API to be added + ******************************************************/ + sprintf(dir_path,"%s%s%s","/NAND",NANDDIR,NANDDIR_IMG); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); +// else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/NAND",NANDDIR,THUMB); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/NAND",NANDDIR,NANDDIR_AUD); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + break; + case FM_T_FLASH: + /**********************NOTE*************************** + FS Abstraction API to be added + ******************************************************/ + sprintf(dir_path,"%s%s%s","/MMC",TFLASHDIR,TFLASHDIR_IMG); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/MMC",TFLASHDIR,THUMB); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + sprintf(dir_path,"%s%s%s","/MMC",TFLASHDIR,TFLASHDIR_AUD); + convert_u8_to_unicode(dir_path, dir_path_uc); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_opendir(dir_path_uc,&f_dir); + TRACE_EVENT_P2("Opendir - ffsResult %d Dir path %s", ffsResult,dir_path); + // if(ffsResult > 0) + // rfs_closedir(&f_dir); + // else + if(RFS_ENOENT == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = rfs_mkdir(dir_path_uc, RFS_IRWXU); + TRACE_EVENT_P2("Makedir - ffsResult %d Dir path %s", ffsResult,dir_path); + } + break; + } +#else + sprintf(dir_path,"%s%s",NORDIR,NORDIR_IMG); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = ffs_opendir(dir_path,&f_dir); + if(EFFS_NOTFOUND == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = ffs_mkdir(dir_path); + } + sprintf(dir_path,"%s%s",NORDIR,THUMB); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = ffs_opendir(dir_path,&f_dir); + if(EFFS_NOTFOUND == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = ffs_mkdir(dir_path); + } + sprintf(dir_path,"%s%s",NORDIR,NORDIR_AUD); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = ffs_opendir(dir_path,&f_dir); + if(EFFS_NOTFOUND == ffsResult) + { + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffsResult = ffs_mkdir(dir_path); + } +#endif + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_newdir + + $Description: creates a new direcotry with the given name + + $Returns: FM_DIR_EXISTS/FM_NO_ERROR + + $Arguments: dirname : new directory name + source : Current Drive +*******************************************************************************/ +T_MFW_FM_STATUS mfw_fm_newdir(char *dirname, T_FM_DEVICE_TYPE source) +{ +#ifdef FF_MMI_RFS_ENABLED + T_RFS_RET ffsResult; + T_RFS_DIR f_dir; + char pathname[FM_MAX_DIR_PATH_LENGTH]; + UINT16 pathname_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + T_FFS_RET ffsResult; + T_FFS_DIR f_dir; +#endif + + TRACE_FUNCTION("mfw_fm_newdir"); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + strcpy(pathname,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(pathname,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(pathname,"/NAND"); + break; + case FM_T_FLASH: + strcpy(pathname,"/MMC"); + break; + } + strcat(pathname,dirname); + convert_u8_to_unicode(pathname,pathname_uc); + + ffsResult = rfs_opendir(pathname_uc,&f_dir); + if(RFS_ENOENT == ffsResult) + { + ffsResult = rfs_mkdir(pathname_uc,RFS_IRWXU); + } + else + { + return FM_DIR_EXISTS; + } +#else + + ffsResult = ffs_opendir(dirname,&f_dir); + if(EFFS_NOTFOUND == ffsResult) + { + ffsResult = ffs_mkdir(dirname); + } + else + { + return FM_DIR_EXISTS; + } +#endif + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_readProperties + + $Description: Reads the properties of all the objects in the given directory + + $Returns: None + + $Arguments: dir_path : Current Directory Path + dir_name : Current Directory Name + num_objs : num of obejcts + obj_list : object list + obj_properties: Object properties + source : Current Drive +*******************************************************************************/ +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) +{ + /* January 16, 2008 DRT:OMAPS00156759 (x0082844) Shubhro -> For Unicode Support--> Start*/ + #if defined(FF_MMI_UNICODE_SUPPORT)||defined (FF_MMI_RFS_ENABLED) + T_WCHAR curObj_uc[FM_MAX_DIR_PATH_LENGTH]; + #else + char curObj_u8[FM_MAX_DIR_PATH_LENGTH]; + #endif + /* January 16, 2008 DRT:OMAPS00156759 (x0082844) Shubhro --> End*/ + + char curPath[FM_MAX_DIR_PATH_LENGTH]; + int iCount=0; + +#ifdef FF_MMI_RFS_ENABLED + T_RFS_RET result; + T_RFS_STAT f_stat; + T_RTC_DATE_TIME time_and_date; +#else + T_FFS_RET result; + T_FFS_STAT f_stat; +#endif + + TRACE_FUNCTION("mfw_fm_readProperties"); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + sprintf(curPath,"%s%s%s/","/FFS",dir_path,dir_name); + break; + case FM_NORMS_FLASH: + sprintf(curPath,"%s%s%s/","/NOR",dir_path,dir_name); + break; + case FM_NAND_FLASH: + sprintf(curPath,"%s%s%s/","/NAND",dir_path,dir_name); + break; + case FM_T_FLASH: + sprintf(curPath,"%s%s%s/","/MMC",dir_path,dir_name); + break; + } + + + for (iCount = 0;iCount<num_objs; iCount++) + { + + /* February 8, 2008 DRT:OMAPS00156759 (x0083025) For Unicode Support--> Start*/ + convert_u8_to_unicode(curPath, curObj_uc); + + #ifdef FF_MMI_UNICODE_SUPPORT + // If it's an image it's stored as char + if (app == FM_AUDIO) + { + wstrcat(curObj_uc, obj_list[iCount]->name_uc); + } + else + #endif + { + T_WCHAR filename_uc[FM_MAX_OBJ_NAME_LENGTH]; + convert_u8_to_unicode(obj_list[iCount]->name, filename_uc); + wstrcat(curObj_uc, filename_uc); + } + result= rfs_stat(curObj_uc, &f_stat); + if(result == RFS_EOK) + { + if(f_stat.file_dir.mode & RFS_IXUSR) + obj_list[iCount]->type=OBJECT_TYPE_FOLDER; + else + obj_list[iCount]->type=OBJECT_TYPE_FILE; + } + TRACE_EVENT_P2("Object %s type %d",curObj_uc, obj_list[iCount]->type); + + obj_properties[iCount] = (T_FM_OBJ_PROPERTIES *)mfwAlloc(sizeof(T_FM_OBJ_PROPERTIES)); + obj_properties[iCount]->size = f_stat.file_dir.size; + result = rfs_getdatetime(curObj_uc,NULL /* creation date and time */,&time_and_date /* last modified date and time */); + sprintf(obj_properties[iCount]->date,"%d-%d-%d", time_and_date.day, time_and_date.month, 2000 + time_and_date.year); + sprintf(obj_properties[iCount]->time,"%d.%d.%d", time_and_date.hour, time_and_date.minute, time_and_date.second); + } + +#else + sprintf(curPath,"%s%s/",dir_path,dir_name); + for (iCount = 0;iCount<num_objs; iCount++) + { + sprintf(curObj_u8,"%s%s",curPath,obj_list[iCount]->name); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + result= ffs_stat( curObj_u8, (void *)&f_stat ); + if(result == EFFS_OK) + { + switch(f_stat.type) + { + case OT_FILE: + obj_list[iCount]->type=OBJECT_TYPE_FILE; + break; + case OT_DIR: + obj_list[iCount]->type=OBJECT_TYPE_FOLDER; + break; + default: + obj_list[iCount]->type=OBJECT_TYPE_NONE; + break; + } + } + TRACE_EVENT_P2("name %s, Object type %d", obj_list[iCount]->name,obj_list[iCount]->type); + obj_properties[iCount] = (T_FM_OBJ_PROPERTIES*)mfwAlloc(sizeof(T_FM_OBJ_PROPERTIES)); + obj_properties[iCount]->size=f_stat.size; + } +#endif +} + +/******************************************************************************* + $Function: mfw_fm_readFIleFolders + + $Description: Classifies all the objects as either File or Directory + + $Returns: None + + $Arguments: fm_curr_dir : Current directory + source : Current Drive +*******************************************************************************/ +void mfw_fm_readFileFolders(char *dir_path, char *dir_name, UBYTE num_objs, T_FM_OBJ **obj_list, T_FM_DEVICE_TYPE source) +{ + char curObj[FM_MAX_DIR_PATH_LENGTH]; + char curPath[FM_MAX_DIR_PATH_LENGTH]; + int iCount=0; +#ifdef FF_MMI_RFS_ENABLED + T_RFS_RET result; + T_RFS_STAT f_stat; + UINT16 curObj_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + T_FFS_RET result; + T_FFS_STAT f_stat; +#endif + +TRACE_FUNCTION("mfw_fm_readFileFolders"); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + sprintf(curPath,"%s%s%s/","/FFS",dir_path,dir_name); + break; + case FM_NORMS_FLASH: + sprintf(curPath,"%s%s%s/","/NOR",dir_path,dir_name); + break; + case FM_NAND_FLASH: + sprintf(curPath,"%s%s%s/","/NAND",dir_path,dir_name); + break; + case FM_T_FLASH: + sprintf(curPath,"%s%s%s/","/MMC",dir_path,dir_name); + break; + } + for (iCount = 0;iCount<num_objs; iCount++) + { + sprintf(curObj,"%s%s",curPath,obj_list[iCount]->name); + convert_u8_to_unicode(curObj, curObj_uc); + result= rfs_stat(curObj_uc, &f_stat); + if(result == RFS_EOK) + { + if(f_stat.file_dir.mode & RFS_IXUSR) + obj_list[iCount]->type=OBJECT_TYPE_FOLDER; + else + obj_list[iCount]->type=OBJECT_TYPE_FILE; + } + TRACE_EVENT_P2("Object %s type %d",curObj, obj_list[iCount]->type); + } +#else + sprintf(curPath,"%s%s/",dir_path,dir_name); + + for (iCount = 0;iCount<num_objs; iCount++) + { + sprintf(curObj,"%s%s",curPath,obj_list[iCount]->name); + + result= ffs_stat( curObj, (void *)&f_stat ); + if(result == EFFS_OK) + { + switch(f_stat.type) + { + case OT_FILE: + obj_list[iCount]->type=OBJECT_TYPE_FILE; + break; + case OT_DIR: + obj_list[iCount]->type=OBJECT_TYPE_FOLDER; + break; + default: + obj_list[iCount]->type=OBJECT_TYPE_NONE; + break; + } + } + TRACE_EVENT_P2("Object %s type %d",curObj, obj_list[iCount]->type); + } +#endif +} +/******************************************************************************* + $Function: mfw_fm_getMemStat + + $Description: Extracts the memory usage details of a given drive + + $Returns: None + + $Arguments: nfree : free bytes + nused : used bytes + source : Current Drive +*******************************************************************************/ +void mfw_fm_getMemStat(int *nfree, int *nused,T_FM_DEVICE_TYPE source) +{ + + T_RFS_STAT f_stat; + char curObj[FM_MAX_DIR_PATH_LENGTH]; + UINT16 curObj_uc[FM_MAX_DIR_PATH_LENGTH]; + TRACE_FUNCTION("mfw_fm_getMemStat"); + + memset(curObj, 0, FM_MAX_DIR_PATH_LENGTH); + switch (source) + { + case FM_NOR_FLASH: + strcpy(curObj,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(curObj,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(curObj,"/NAND"); + break; + case FM_T_FLASH: + strcpy(curObj,"/MMC"); + break; + } + convert_u8_to_unicode(curObj, curObj_uc); + rfs_stat(curObj_uc, &f_stat); /* warning fix */ + *nfree = f_stat.mount_point.free_space; + *nused = f_stat.mount_point.used_size; + +} + +/******************************************************************************* + $Function: mfw_fm_format + + $Description: Formats the given drive + + $Returns: FM_NO_ERROR/FM_FORMAT_ERROR + + $Arguments: source : Current Drive +*******************************************************************************/ +T_MFW_FM_STATUS mfw_fm_format(T_FM_DEVICE_TYPE source) +{ + T_RFS_RET result; + UINT16 mount_point_uc[6]; + TRACE_FUNCTION("mfw_fm_format"); + memset(mount_point_uc, 0x00,6); + switch (source) + { + case FM_NORMS_FLASH: + convert_u8_to_unicode("/NOR", mount_point_uc); + break; + case FM_NAND_FLASH: + convert_u8_to_unicode("/NAND", mount_point_uc); + break; + case FM_T_FLASH: + convert_u8_to_unicode("/MMC", mount_point_uc); + break; + } + + result = rfs_preformat(mount_point_uc, 0xDEAD); + if(result < RFS_EOK) + return FM_FORMAT_ERROR; + else + { + result = rfs_format(mount_point_uc, NULL, 0x2BAD); + if (result < RFS_EOK) + return FM_FORMAT_ERROR; + else + { + /* Mar 15, 2007 DRT: OMAPS00120201 x0039928 */ + /* Fix: Creating the default directories for the selected device after format */ + mfw_fm_createRootDir(source); + return FM_NO_ERROR; + } + } +} + +/******************************************************************************* + $Function: mfw_fm_remove + + $Description: Deletes the selected object + + $Returns: FM_DELETE_DIRNOTEMPTY/FM_DELETE_ERROR/FM_NO_ERROR + + $Arguments: source : Current Drive +*******************************************************************************/ +#ifdef FF_MMI_UNICODE_SUPPORT +T_MFW_FM_STATUS mfw_fm_remove(T_WCHAR* objname_u16,T_FM_DEVICE_TYPE source) +#else +T_MFW_FM_STATUS mfw_fm_remove(char* objname,T_FM_DEVICE_TYPE source) +#endif +{ +#ifdef FF_MMI_RFS_ENABLED + T_RFS_RET rfsResult; + char objname_mt[FM_MAX_DIR_PATH_LENGTH]; + T_WCHAR objname_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + T_FFS_RET ffsResult; +#endif + + + TRACE_FUNCTION("mfw_fm_remove"); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + strcpy(objname_mt,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(objname_mt,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(objname_mt,"/NAND"); + break; + case FM_T_FLASH: + strcpy(objname_mt,"/MMC"); + break; + } + #ifdef FF_MMI_UNICODE_SUPPORT + convert_u8_to_unicode(objname_mt, objname_uc); + wstrcat(objname_uc, objname_u16); + #else + strcat(objname_mt,objname); + convert_u8_to_unicode(objname_mt, objname_uc); + #endif + TRACE_EVENT_P1("objname %s",objname_uc); + rfsResult = rfs_remove(objname_uc); + if(rfsResult != RFS_EOK) + { + return FM_DELETE_ERROR; + } +#else + { + #ifdef FF_MMI_UNICODE_SUPPORT + char objname[FM_MAX_DIR_PATH_LENGTH]; + convert_unicode_to_u8(objname_u16, objname); + #endif + TRACE_EVENT_P1("objname %s",objname); + ffsResult = ffs_remove(objname); + } + if(ffsResult != EFFS_OK) + { + if(ffsResult == EFFS_DIRNOTEMPTY) + return FM_DELETE_DIRNOTEMPTY; + else + return FM_DELETE_ERROR; + } + +#endif + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_remove_image + + $Description: Deletes the selcted image and its thumbnail + + $Returns: FM_DELETE_ERROR/FM_NO_ERROR + + $Arguments: path : Current directory path + dirname : Current Directory name + old_filename : Old filename + new_filename : New filename + source : Current Drive +*******************************************************************************/ +T_MFW_FM_STATUS mfw_fm_remove_image(char * path, char * dirname, char* objname,T_FM_DEVICE_TYPE source) +{ + char obj[FM_MAX_DIR_PATH_LENGTH]; + T_MFW_FM_STATUS ffsResult; + + TRACE_FUNCTION("mfw_fm_delete_image"); + + sprintf(obj,"%s%s/%s.jpg",path,dirname,objname); + TRACE_EVENT_P1("obj %s",obj); +#ifdef FF_MMI_UNICODE_SUPPORT + { + T_WCHAR obj_uc[FM_MAX_DIR_PATH_LENGTH]; + convert_u8_to_unicode(obj, obj_uc); + ffsResult = mfw_fm_remove(obj_uc,source); + } +#else + ffsResult = mfw_fm_remove(obj,source); +#endif + if(ffsResult != FM_NO_ERROR) + { + return FM_DELETE_ERROR; + } + switch(source) + { + case FM_NOR_FLASH: + sprintf(obj,"%s%s/%s.tmb",NORDIR,THUMB,objname); + break; + case FM_NORMS_FLASH: + sprintf(obj,"%s%s/%s.tmb",NORMSDIR,THUMB,objname); + break; + case FM_NAND_FLASH: + sprintf(obj,"%s%s/%s.tmb",NANDDIR,THUMB,objname); + break; + case FM_T_FLASH: + sprintf(obj,"%s%s/%s.tmb",TFLASHDIR,THUMB,objname); + break; + } +#ifdef FF_MMI_UNICODE_SUPPORT + { + T_WCHAR obj_uc[FM_MAX_DIR_PATH_LENGTH]; + convert_u8_to_unicode(obj, obj_uc); + ffsResult = mfw_fm_remove(obj_uc,source); + } +#else + ffsResult = mfw_fm_remove(obj,source); +#endif + if(ffsResult != FM_NO_ERROR) + { + return FM_DELETE_ERROR; + } + return FM_NO_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_copy_start + + $Description: starts copying the give file + + $Returns: FM_COPY_ERROR/FM_COPY_DONE/FM_COPY_PROGRESS + + $Arguments: data : Copy/Move operation related structure +*******************************************************************************/ +T_FM_COPY_STATE mfw_fm_copy_start(T_MFW_FM_COPYMOVE_STRUCT *data) +{ + char *ext2; + T_RFS_STAT f_stat; + T_RFS_SIZE iResult = 0; + UINT16 source_file_uc[FM_MAX_DIR_PATH_LENGTH]; + UINT16 destination_file_uc[FM_MAX_DIR_PATH_LENGTH]; + char source_file[FM_MAX_DIR_PATH_LENGTH]; + char destination_file[FM_MAX_DIR_PATH_LENGTH]; + + TRACE_FUNCTION("mfw_fm_copy_start"); + + switch (data->source_type) + { + case FM_NOR_FLASH: + strcpy(source_file,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(source_file,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(source_file,"/NAND"); + break; + case FM_T_FLASH: + strcpy(source_file,"/MMC"); + break; + } + + switch (data->destination_type) + { + case FM_NOR_FLASH: + strcpy(destination_file,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(destination_file,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(destination_file,"/NAND"); + break; + case FM_T_FLASH: + strcpy(destination_file,"/MMC"); + break; + } +#ifdef FF_MMI_UNICODE_SUPPORT + convert_u8_to_unicode(source_file, source_file_uc); + convert_u8_to_unicode(destination_file, destination_file_uc); + wstrcat(source_file_uc, data->sourceFile); + wstrcat(destination_file_uc, data->destinationFile); +#else + strcat(source_file, data->sourceFile); + strcat(destination_file, data->destinationFile); + + convert_u8_to_unicode(source_file, source_file_uc); + convert_u8_to_unicode(destination_file, destination_file_uc); +#endif + + ext2=(char *)mmi_fm_get_ext(source_file);//April 27, 2007 DRT:OMAPS00128836 x0073106 + + if( ( (rfs_stat(destination_file_uc, &f_stat)) != RFS_ENOENT)//April 27, 2007 DRT:OMAPS00128836 x0073106 + && (strcmp((const char*)ext2, "jpg") ==0 )) + { + return FM_COPY_NONE; + } + + data->sourceFileID = (T_RFS_FD)rfs_open( source_file_uc, RFS_O_RDONLY, NULL); + data->destFileID= (T_RFS_FD)rfs_open( destination_file_uc, RFS_O_WRONLY|RFS_O_CREAT, RFS_IRUSR|RFS_IWUSR); + data->bytesRead = 0; + + if(data->sourceFileSize > FM_COPY_BUFFER_SIZE ) + { + data->buf_size = FM_COPY_BUFFER_SIZE; + data->bytesRead = data->buf_size; + } + else + { + data->buf_size = data->sourceFileSize; + data->bytesRead = data->buf_size; + } + + iResult = (T_RFS_SIZE)rfs_read(data->sourceFileID, data->buf, data->buf_size ); + TRACE_EVENT_P1("iResult %d",iResult); + if(iResult < 0) + { + //Error Reading + rfs_close( data->sourceFileID); + rfs_close(data->destFileID ); + return FM_COPY_ERROR; + } + iResult = (T_RFS_SIZE)rfs_write( data->destFileID, data->buf, data->buf_size); + TRACE_EVENT_P1("iResult %d",iResult); + if(iResult < 0) + { + //Error writing + rfs_close( data->sourceFileID); + rfs_close(data->destFileID ); + return FM_COPY_ERROR; + } + if(data->bytesRead < data->sourceFileSize) + { + return FM_COPY_PROGRESS; + } + else + { + rfs_close( data->sourceFileID); + rfs_close(data->destFileID ); + return FM_COPY_DONE; + } + +// return FM_COPY_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_copy_continue + + $Description: resumes copying the give file + + $Returns: FM_COPY_ERROR/FM_COPY_DONE/FM_COPY_PROGRESS + + $Arguments: data : Copy/Move operation related structure +*******************************************************************************/ +T_FM_COPY_STATE mfw_fm_copy_continue(T_MFW_FM_COPYMOVE_STRUCT *data) +{ + T_RFS_SIZE iResult = 0; + +/* + UINT16 source_file_uc[FM_MAX_DIR_PATH_LENGTH]; + UINT16 destination_file_uc[FM_MAX_DIR_PATH_LENGTH]; + char source_file[FM_MAX_DIR_PATH_LENGTH]; + char destination_file[FM_MAX_DIR_PATH_LENGTH]; + + TRACE_FUNCTION("mfw_fm_copy_continue"); + + + switch (data->source_type) + { + case FM_NOR_FLASH: + strcpy(source_file,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(source_file,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(source_file,"/NAND"); + break; + case FM_T_FLASH: + strcpy(source_file,"/MMC"); + break; + } + + switch (data->destination_type) + { + case FM_NOR_FLASH: + strcpy(destination_file,"/FFS"); + break; + case FM_NORMS_FLASH: + strcpy(destination_file,"/NOR"); + break; + case FM_NAND_FLASH: + strcpy(destination_file,"/NAND"); + break; + case FM_T_FLASH: + strcpy(destination_file,"/MMC"); + break; + } + + strcat(source_file, data->sourceFile); + strcat(destination_file, data->destinationFile); + + convert_u8_to_unicode(source_file, source_file_uc); + convert_u8_to_unicode(destination_file, destination_file_uc); + +*/ + if( (data->bytesRead+ FM_COPY_BUFFER_SIZE) < data->sourceFileSize) + { + //More blocks to be read + data->buf_size = FM_COPY_BUFFER_SIZE; + data->bytesRead = data->bytesRead + data->buf_size; + } + else + { + //Last chunk to be read + data->buf_size = data->sourceFileSize - data->bytesRead; + data->bytesRead = data->bytesRead + FM_COPY_BUFFER_SIZE; + } + + iResult = (T_RFS_SIZE)rfs_read(data->sourceFileID, data->buf, data->buf_size ); + TRACE_EVENT_P1("iResult %d",iResult); + if(iResult < 0) + { + //Error Reading + rfs_close( data->sourceFileID); + rfs_close(data->destFileID ); + return FM_COPY_ERROR; + } + iResult = (T_RFS_SIZE)rfs_write( data->destFileID, data->buf, data->buf_size); + TRACE_EVENT_P1("iResult %d",iResult); + if(iResult < 0) + { + //Error Writing + rfs_close( data->sourceFileID); + rfs_close(data->destFileID ); + return FM_COPY_ERROR; + } + + if(data->bytesRead < data->sourceFileSize) + { + return FM_COPY_PROGRESS; + } + else + { + rfs_close(data->sourceFileID); + rfs_close(data->destFileID ); + return FM_COPY_DONE; + } +// return FM_COPY_ERROR; +} + +//Image List +/******************************************************************************* + $Function: mfw_fm_checkThumbnail + + $Description: Checks for thumbnail + + $Returns: FM_FILE_DOESNOTEXISTS/FM_NO_ERROR + + $Arguments: obj : Current image + source : Current Drive +*******************************************************************************/ +T_MFW_FM_STATUS mfw_fm_checkThumbnail( char * obj,T_FM_DEVICE_TYPE source) +{ + + char filename[FM_MAX_DIR_PATH_LENGTH]; +#ifdef FF_MMI_RFS_ENABLED + T_RFS_FD fd = 0; + UINT16 filename_uc[FM_MAX_DIR_PATH_LENGTH]; +#else + T_FFS_FD fd = 0; +#endif + TRACE_FUNCTION("mfw_fm_check_thumbnail"); + + TRACE_EVENT_P1("File %s",obj); + +#ifdef FF_MMI_RFS_ENABLED + memset(filename, 0, FM_MAX_DIR_PATH_LENGTH); + switch(source) + { + case FM_NOR_FLASH: + sprintf(filename,"%s%s%s/%s.tmb","/FFS",NORDIR,THUMB,obj); + break; + case FM_NORMS_FLASH: + sprintf(filename,"%s%s%s/%s.tmb","/NOR",NORMSDIR,THUMB,obj); + break; + case FM_NAND_FLASH: + sprintf(filename,"%s%s%s/%s.tmb","/NAND",NANDDIR,THUMB,obj); + break; + case FM_T_FLASH: + sprintf(filename,"%s%s%s/%s.tmb","/MMC",TFLASHDIR,THUMB,obj); + break; + } + convert_u8_to_unicode(filename, filename_uc); + if ((fd = rfs_open (filename_uc, RFS_O_RDONLY, NULL)) == RFS_ENOENT) + { + TRACE_EVENT("Create the thmbnail."); + return FM_FILE_DOESNOTEXISTS; + } + else + { + TRACE_EVENT_P1("Error %d",fd); + rfs_close(fd); + return FM_FILE_EXISTS; + } +#else + sprintf(filename,"%s%s/%s.tmb",NORDIR,THUMB,obj); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + if ((fd = ffs_open (filename, FFS_O_RDONLY)) <= EFFS_NOTFOUND) + { + TRACE_EVENT("Create the thmbnail."); + return FM_FILE_DOESNOTEXISTS; + } + else + { + TRACE_EVENT_P1("Error %d",fd); + /**********************NOTE*************************** + FFS API To be replaced with FS Abstraction API + ******************************************************/ + ffs_close(fd); + return FM_FILE_EXISTS; + } +#endif +// return FM_FILE_DOESNOTEXISTS; +} +/******************************************************************************* + $Function: mfw_fm_imgViewer_create + + $Description: This function will create the handle of imageviewer UCP + + $Returns: Result of the UCP creation + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_create(void) +{ + MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgViewer_create()"); + + mslResult = MSL_ImgView_Create(&msl_handle); + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgViewer_init + + $Description: This function will initialise the imageviewer UCP + + $Returns: Result of the UCP initialization + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_init(void) +{ + MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgViewer_init()"); + + mslResult = MSL_ImgView_Init(msl_handle); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgViewer_destroy + + $Description: This function destroy the imageviewer UCP + + $Returns: Result of the UCP destroy + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_destroy(void) +{ + MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgViewer_destroy()"); + mslResult = MSL_ImgView_Destroy(msl_handle); + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgViewer_deinit + + $Description: This function will deinit the imageviewer UCP + + $Returns: Result of the UCP de-initialization + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_deinit(void) +{ + MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgViewer_deinit()"); + + mslResult = MSL_ImgView_Deinit(msl_handle); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + + +/******************************************************************************* + $Function: mfw_fm_imgViewer_pause + + $Description: This function will pause the imageviewer UCP. + + $Returns: Result of the UCP pause + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_pause(void) +{ + MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgViewer_pause()"); + mslResult = MSL_ImgView_Pause((MSL_HANDLE)msl_handle); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + + +/******************************************************************************* + $Function: mfw_fm_imgViewer_view + + $Description: This function will start the rendering of the image on LCD. + + $Returns: Result of the drawing the image + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_view(void) +{ + MSL_IMGVIEW_STATUS mslResult = MSL_IMGVIEW_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgViewer_view()"); + mslResult = MSL_ImgView_View((MSL_HANDLE)msl_handle); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR;} +/******************************************************************************* + $Function: mfw_fm_imgViewer_setImageProperty + + $Description: This function will set the parameters for the imageviewer UCP + + $Returns: Result of the UCP updation of configurations + + $Arguments: filepath : Image path + filename : Image name + width : Image width + height : Image height + xoffset : Image x offset + yoffset : Image y offset + source : Current drive +*******************************************************************************/ +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) +{ + + MSL_IMGVIEW_STATUS mslResult; + //The fullpath will be included. + char tmb_name_p[FM_MAX_OBJ_NAME_LENGTH]; + MSL_DISPLAY_CONFIGTYPE mfw_fm_dspl_config; + MSL_FILE_CONFIGTYPE mfw_fm_file_config ; + int rotation_degree = 0; + int zoom_factor = 0; + + TRACE_FUNCTION ("mfw_fm_imgViewer_setImageProperty()"); + + mfw_fm_dspl_config.tImgFormat = MSL_COLOR_RGB565; + mfw_fm_dspl_config.unDisplayImgHeight = height; + mfw_fm_dspl_config.unDisplayImgWidth = width; + mfw_fm_dspl_config.unDisplayXOffset = xoffset; + mfw_fm_dspl_config.unDisplayYOffset = yoffset; + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DISPLAY_CONFIGINDEX,&mfw_fm_dspl_config); + if(mslResult == MSL_IMGVIEW_STATUS_OK) + mslResult = MSL_ImgView_SetConfig (msl_handle,MSL_ROTATE_CONFIGINDEX,&rotation_degree); + if(mslResult == MSL_IMGVIEW_STATUS_OK) + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_ZOOM_CONFIGINDEX,&zoom_factor); + mfw_fm_file_config.sFileName = (char *) mfwAlloc(FM_MAX_OBJ_NAME_LENGTH); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/FFS",NORDIR,THUMB, filename); + // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS; + break; + case FM_NORMS_FLASH: + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NOR",NORMSDIR,THUMB, filename); + // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS; + break; + case FM_NAND_FLASH: + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NAND",NANDDIR,THUMB, filename); + /**********************NOTE*************************** + Drive type to be updated + ******************************************************/ + // mfw_fm_file_config.tFileType = MSL_FILETYPE_RFS; + break; + case FM_T_FLASH: + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/MMC",TFLASHDIR,THUMB, filename); + /**********************NOTE*************************** + Drive type to be updated + ******************************************************/ + //mfw_fm_file_config.tFileType = MSL_FILETYPE_TFLASH; + break; + default: + sprintf(tmb_name_p,"/%s/%s.tmb",THUMB, filename); + } + strcat(mfw_fm_file_config.sFileName,tmb_name_p); +#else + strcpy(mfw_fm_file_config.sFileName,tmb_name_p); +#endif + if(mslResult == MSL_IMGVIEW_STATUS_OK) + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DECFILE_CONFIGINDEX,&mfw_fm_file_config); + mfwFree((U8 *)mfw_fm_file_config.sFileName,FM_MAX_OBJ_NAME_LENGTH); + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; + +} + +/******************************************************************************* + $Function: mfw_fm_imgViewer_setConfigs + + $Description: This function will set the parameters for the imageviewer UCP + + $Returns: Result of the UCP updation of configurations + + $Arguments: filepath : Image path + filename : Image name + width : Image width + height : Image height + xoffset : Image x offset + yoffset : Image y offset + zFactor : Zoom factor + rotation_degree : Rotate factor + source : Current drive +*******************************************************************************/ +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) +{ + MSL_IMGVIEW_STATUS mslResult; + MSL_DISPLAY_CONFIGTYPE mfw_fm_dspl_config; + MSL_FILE_CONFIGTYPE mfw_fm_file_config ; + int zoom_factor = zFactor; + int rAngle = rotation_degree; + + TRACE_FUNCTION ("mfw_fm_imgViewer_setRotationConfigs()"); + + mfw_fm_dspl_config.unDisplayImgHeight = height; + mfw_fm_dspl_config.unDisplayImgWidth = width; + mfw_fm_dspl_config.unDisplayXOffset = xoffset; + mfw_fm_dspl_config.unDisplayYOffset = yoffset; + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DISPLAY_CONFIGINDEX,&mfw_fm_dspl_config); + + mfw_fm_file_config.sFileName = (char *) mfwAlloc(FM_MAX_OBJ_NAME_LENGTH); + +#ifdef FF_MMI_RFS_ENABLED + switch (source) + { + case FM_NOR_FLASH: + strcpy(mfw_fm_file_config.sFileName,"/FFS"); + // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS; + break; + case FM_NORMS_FLASH: + strcpy(mfw_fm_file_config.sFileName,"/NOR"); + // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS; + break; + case FM_NAND_FLASH: + strcpy(mfw_fm_file_config.sFileName,"/NAND"); + /**********************NOTE*************************** + Drive type to be updated + ******************************************************/ + // mfw_fm_file_config.tFileType = MSL_FILETYPE_RFS; + break; + case FM_T_FLASH: + strcpy(mfw_fm_file_config.sFileName,"/MMC"); + /**********************NOTE*************************** + Drive type to be updated + ******************************************************/ + //mfw_fm_file_config.tFileType = MSL_FILETYPE_TFLASH; + break; + } + strcat(mfw_fm_file_config.sFileName,filename); +#else + strcpy(mfw_fm_file_config.sFileName,filename); +#endif + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_DECFILE_CONFIGINDEX,&mfw_fm_file_config); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_ZOOM_CONFIGINDEX,&zoom_factor); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + mslResult = MSL_ImgView_SetConfig (msl_handle,MSL_ROTATE_CONFIGINDEX,&rAngle); + + mfwFree((U8 *)mfw_fm_file_config.sFileName,FM_MAX_OBJ_NAME_LENGTH); + + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_imgView_setcallback + + $Description: This function will set the callback for viewer UCP + + $Returns: Result of the updating the callback function + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgViewer_setcallback(void) +{ + MSL_IMGVIEW_STATUS mslResult; + + TRACE_FUNCTION("mfw_fm_imgViewer_setcallback"); + + mslResult = MSL_ImgView_SetConfig(msl_handle,MSL_CALLBACKSET_CONFIGINDEX,(MSL_CALLBACK)Msl_mslil_Callback); + if(mslResult == MSL_IMGVIEW_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgThmb_create + + $Description: This function will create the handle of thumbnail UCP + + $Returns: Result of the UCP create + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_create(void) +{ + MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgThmb_create()"); + + mslResult = MSL_ImgThmb_Create(&msl_handle); + + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgThmb_init + + $Description: This function will initialise of thumbnail UCP + + $Returns: Result of the UCP initialization + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_init(void) +{ + MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK; + + TRACE_FUNCTION ("mfw_fm_imgThmb_init()"); + + mslResult = MSL_ImgThmb_Init(msl_handle); + + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgThmb_destroy + + $Description: This function will destroy the thumbnail UCP. + + $Returns: Result of the UCP destroy + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_destroy(void) +{ + MSL_IMGTHMB_STATUS mslResult; + + TRACE_FUNCTION ("mfw_fm_imgThmb_destroy()"); + + mslResult = MSL_ImgThmb_Destroy(msl_handle); + if (mslResult != MSL_IMGTHMB_STATUS_OK) + { + MSL_ImgThmb_Destroy(msl_handle); + msl_handle=0; + return FM_UCP_ERROR; + } + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgThmb_deinit + + $Description: This function will deinit the thumbnail UCP. + + $Returns: Result of the UCP de-initialization + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_deinit(void) +{ + MSL_IMGTHMB_STATUS mslResult; + + TRACE_FUNCTION ("mfw_fm_imgThmb_deinit()"); + + mslResult = MSL_ImgThmb_Deinit(msl_handle); + + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + + $Function: mfw_fm_imgThmb_pause + + $Description: This function will pasue the thumbnail UCP. + + $Returns: Result of the UCP pause + + $Arguments: None + +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_pause(void) +{ + MSL_IMGTHMB_STATUS mslResult; + + TRACE_FUNCTION ("mfw_fm_imgThmb_pause()"); + mslResult = MSL_ImgThmb_Pause((MSL_HANDLE)msl_handle); + + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgThmb_generate + + $Description: This function will generate the thumbnail file in filesystem. + + $Returns: Result of the thumbanil generation + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_generate(void) +{ + MSL_IMGTHMB_STATUS mslResult; + + TRACE_FUNCTION ("mfw_fm_imgThmb_generate()"); + + mslResult = MSL_ImgThmb_Generate((MSL_HANDLE)msl_handle); + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + + +/******************************************************************************* + $Function: mfw_fm_imgThmb_setparams + + $Description: This function will set the parameters for thumbnail UCP + + $Returns: Result of the UCP updation of configurations + + $Arguments: inFilepath : Image path + inFilename : Image name + width : Image width + height : Image height + source : Current drive +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_setparams(char * inFilepath, char* inFilename, int width,int height, T_FM_DEVICE_TYPE source) +{ + MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK; + char tmb_name_p[FM_MAX_DIR_PATH_LENGTH]; + + MSL_RESCALE_CONFIGTYPE mfw_fm_rescaleconfig ; + MSL_FILE_CONFIGTYPE mfw_fm_file_config ; + + TRACE_FUNCTION ("mfw_fm_imgThmb_setparams()"); + + mfw_fm_rescaleconfig.unRescaledImgHeight = height; + mfw_fm_rescaleconfig.unRescaledImgWidth =width ; + mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_RESCALE_CONFIGINDEX,&mfw_fm_rescaleconfig); + mfw_fm_file_config.sFileName = (char *) mfwAlloc(FM_MAX_DIR_PATH_LENGTH); + switch (source) + { + case FM_NOR_FLASH: + sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/FFS",inFilepath,inFilename); + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/FFS",NORDIR,THUMB, inFilename); + // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS; + break; + case FM_NORMS_FLASH: + sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/NOR",inFilepath,inFilename); + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NOR",NORMSDIR,THUMB, inFilename); + // mfw_fm_file_config.tFileType = MSL_FILETYPE_FFS; + break; + case FM_NAND_FLASH: + /**********************NOTE*************************** + Drive type to be updated + ******************************************************/ + sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/NAND",inFilepath,inFilename); + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/NAND",NANDDIR,THUMB, inFilename); + mfw_fm_file_config.tFileType = MSL_FILETYPE_RFS; + break; + case FM_T_FLASH: + /**********************NOTE*************************** + Drive type to be updated + ******************************************************/ + sprintf(mfw_fm_file_config.sFileName,"%s%s%s.jpg","/MMC",inFilepath,inFilename); + sprintf(tmb_name_p,"%s%s%s/%s.tmb","/MMC",TFLASHDIR,THUMB, inFilename); + //mfw_fm_file_config.tFileType = MSL_FILETYPE_TFLASH; + break; + } + if(mslResult == MSL_IMGTHMB_STATUS_OK) + { + mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_DECFILE_CONFIGINDEX,&mfw_fm_file_config); + } + sprintf(mfw_fm_file_config.sFileName,"%s",tmb_name_p); + if(mslResult == MSL_IMGTHMB_STATUS_OK) + { + mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_ENCFILE_CONFIGINDEX,&mfw_fm_file_config); + } + mfwFree((U8 *)mfw_fm_file_config.sFileName,FM_MAX_DIR_PATH_LENGTH); + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_imgThmb_setcallback + + $Description: This function will set the callback for thumbnail UCP + + $Returns: Result of the UCP updation of configurations + + $Arguments: None +*******************************************************************************/ +T_FM_IMG_STATE mfw_fm_imgThmb_setcallback() +{ + MSL_IMGTHMB_STATUS mslResult = MSL_IMGTHMB_STATUS_OK; + + TRACE_FUNCTION("mfw_fm_imgThmb_setcallback"); + + mslResult = MSL_ImgThmb_SetConfigs(msl_handle,MSL_CALLBACKSET_CONFIGINDEX,(MSL_CALLBACK)Msl_mslil_Callback); + if(mslResult == MSL_IMGTHMB_STATUS_OK) + return FM_UCP_NO_ERROR; + else + return FM_UCP_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_thmb_mslcb + + $Description: This function is the callback for the thumbnail UCP + + $Returns: None + + $Arguments: tCMd : Current command being executed by the MSL + tStatus : Status of the current command +*******************************************************************************/ +void mfw_fm_thmb_mslcb( U32 tCMd,U32 tStatus) +{ + T_MFW_FM_PARA para; + + TRACE_FUNCTION("mfw_fm_thmb_mslcb()"); + switch(tCMd) + { + case MSL_CMD_INIT: + TRACE_EVENT_P1("MSL_CMD_INIT %d",tStatus); + if(tStatus ==MSL_IMGTHMB_STATUS_OK) + { + para.img_state=FM_UCP_NO_ERROR; + } + else + { + para.img_state=FM_UCP_ERROR; + } + mfw_fm_signal(E_FM_THMB_INIT, ¶); + break; + case MSL_CMD_GENERATE: + TRACE_EVENT_P1("MSL_CMD_GENERATE %d",tStatus); + switch(tStatus) + { + case MSL_IMGTHMB_STATUS_OK: + para.img_state = FM_UCP_NO_ERROR; + break; + case MSL_IMGTHMB_ERROR_BAD_STREAM: + para.img_state = FM_UCP_ERROR_BAD_STREAM; + break; + case MSL_IMGTHMB_ERROR_UNKNOWN: + para.img_state = FM_UCP_ERROR_UNKNOWN; + break; + case MSL_IMGTHMB_ERROR_IOWRITE: + para.img_state = FM_UCP_ERROR_NO_MEM; + break; + case MSL_IMGTHMB_ERROR_INVALID_ARGUMENT: + para.img_state = FM_UCP_ERROR_INVALID_ARGUMENT; + break; + default : + para.img_state = FM_UCP_ERROR; + } + mfw_fm_signal(E_FM_THMB_GEN, ¶); + break; + case MSL_CMD_DEINIT: + TRACE_EVENT_P1("MSL_CMD_DEINIT %d",tStatus); + if(tStatus ==MSL_IMGTHMB_STATUS_OK) + { + para.img_state=FM_UCP_NO_ERROR; + } + else + { + para.img_state=FM_UCP_ERROR; + } + mfw_fm_signal(E_FM_THMB_DEINIT, ¶); + break; + } +} + +/******************************************************************************* + $Function: mfw_fm_view_mslcb + + $Description: This function is the callback for the Viewer UCP + + $Returns: None + + $Arguments: tCMd : Current command being executed by the MSL + tStatus : Status of the current command +*******************************************************************************/ +void mfw_fm_view_mslcb( U32 tCMd,U32 tStatus) +{ + T_MFW_FM_PARA para; + + TRACE_FUNCTION("mfw_fm_view_mslcb()"); + + switch(tCMd) + { + case MSL_CMD_INIT: + TRACE_EVENT_P1("MSL_CMD_INIT %d",tStatus); + if(tStatus ==MSL_IMGVIEW_STATUS_OK) + { + para.img_state=FM_UCP_NO_ERROR; + } + else + { + para.img_state=FM_UCP_ERROR; + } + mfw_fm_signal(E_FM_IMG_INIT, ¶); + break; + case MSL_CMD_VIEW: + TRACE_EVENT_P1("MSL_CMD_VIEW %d",tStatus); + switch(tStatus ) + { + case MSL_IMGVIEW_STATUS_OK: + para.img_state = FM_UCP_NO_ERROR; + break; + case MSL_IMGVIEW_ERROR_BAD_STREAM: + para.img_state = FM_UCP_ERROR_BAD_STREAM; + break; + case MSL_IMGVIEW_ERROR_UNKNOWN: + para.img_state = FM_UCP_ERROR_UNKNOWN; + break; + case MSL_IMGVIEW_ERROR_IOREAD: + para.img_state = FM_UCP_ERROR_READ_FAILED; + break; + case MSL_IMGVIEW_ERROR_INVALID_ARGUMENT: + para.img_state = FM_UCP_ERROR_INVALID_ARGUMENT; + break; + default : + para.img_state = FM_UCP_ERROR; + } + mfw_fm_signal(E_FM_IMG_DRAW,¶); + break; + case MSL_CMD_DEINIT: + TRACE_EVENT_P1("MSL_CMD_DEINIT %d",tStatus); + if(tStatus ==MSL_IMGVIEW_STATUS_OK) + { + para.img_state=FM_UCP_NO_ERROR; + } + else + { + para.img_state=FM_UCP_ERROR; + } + mfw_fm_signal(E_FM_IMG_DEINIT, ¶); + break; + + } +} + + +//Audio List + +/******************************************************************************* + $Function: mfw_fm_audPlay_cb + + $Description: Callback fundtion for auio play/stop + + $Returns: None + + $Arguments: parameter : The structure conveying the stop indication data +*******************************************************************************/ +void mfw_fm_audPlay_cb(void *parameter) +{ + T_MFW_FM_PARA para; + T_AS_STOP_IND *stop_ind = (T_AS_STOP_IND *)parameter; + + /* OMAPS00151698, x0056422 */ + T_AS_START_IND *start_ind = ( T_AS_START_IND *)parameter; + + /* OMAPS00151698, x0056422 */ + + T_AS_PROBAR_IND_MP3 *mp3_pb = (T_AS_PROBAR_IND_MP3 *)parameter; + + TRACE_FUNCTION("mfw_fm_audPlay_cb"); + + + + if(mmi_get_aud_state_status() == FM_AUD_NONE) + { + + TRACE_EVENT_P1("AS_START_IND status %d ",start_ind->status); + mmi_set_aud_state_status(FM_AUD_PLAY); + + /* OMAPS00151698, x0056422 */ + #ifdef FF_MMI_A2DP_AVRCP + + //if BT connected and aud is initialized, and the command wasnt from BT, then send callback + tGlobalBmiBtStruct.tAudioState = FM_AUD_PLAY; + if((tGlobalBmiBtStruct.bConnected != BMI_BT_NOTCONNECTED) + && (start_ind->status == AS_OK)) + { + + + if( NULL != tGlobalBmiBtStruct.BmiEventCallback) + tGlobalBmiBtStruct.BmiEventCallback(BMI_EVENT_USER_PLAY); + tGlobalBmiBtStruct.tCmdSrc == BMI_BT_COMMAND_NONE; + } + #endif // FF_MMI_A2DP_AVRCP + } + + switch(stop_ind->header.msg_id ) + { + /* OMAPS00151698, x0056422 */ + case AS_PAUSE_IND: + TRACE_EVENT_P1("AS_PAUSE_IND status %d",stop_ind->status); + mmi_set_aud_state_status( FM_AUD_PAUSE); + /* OMAPS00151698, x0056422 */ + #ifdef FF_MMI_A2DP_AVRCP + tGlobalBmiBtStruct.tAudioState = FM_AUD_PAUSE; + if(tGlobalBmiBtStruct.bConnected != BMI_BT_NOTCONNECTED) + { + if(NULL != tGlobalBmiBtStruct.BmiEventCallback) + tGlobalBmiBtStruct.BmiEventCallback(BMI_EVENT_USER_PAUSE); + tGlobalBmiBtStruct.tCmdSrc = BMI_BT_COMMAND_NONE; + } + #endif//FF_MMI_A2DP_AVRCP + break; + /* OMAPS00151698, x0056422 */ + + case AS_STOP_IND: + TRACE_EVENT_P2("AS_STOP_IND status %d end %d",stop_ind->status, stop_ind->end_of_media); + mfw_unset_stereo_path(mfw_get_current_audioDevice()); + //Daisy tang added for Real Resume feature 20071107 + if(isPlayer_Real_Pause) + { + last_file_size_played = stop_ind->file_size; + last_para_aud_pt = para_aud.aud_pt; + } + + switch((int)(stop_ind->status)) + { + case AS_NOT_SUPPORTED: + para.aud_state = FM_AUD_ERROR_NOTSUPPORTED; + break; + case AS_MEMORY_ERR: + para.aud_state = FM_AUD_ERROR_MEM; + break; + case AS_INTERNAL_ERR: + para.aud_state = FM_AUD_ERROR_INTERNAL; + break; + case AS_INVALID_PARAM: + para.aud_state = FM_AUD_ERROR_INVALIDPARAM; + break; + case AS_NOT_READY: + para.aud_state = FM_AUD_ERROR_NOTREADY; + break; + case AS_MESSAGING_ERR: + para.aud_state = FM_AUD_ERROR_MSGING; + break; + case AS_FFS_ERR: + para.aud_state = FM_AUD_ERROR_FFS; + break; + case AS_PLAYER_ERR: + para.aud_state = FM_AUD_ERROR_PLAYER; + break; + case AS_DENIED: + para.aud_state = FM_AUD_ERROR_DENIED; + break; + case AS_AUDIO_ERR: + para.aud_state = FM_AUD_ERROR_AUDIO; + break; + case AS_NOT_ALLOWED: + para.aud_state = FM_AUD_ERROR_NOTALLOWED; + break; + default: + para.aud_state = FM_AUD_NONE; + } + /* June 28, 2007 DRT: OMAPS00135749 x0062174 */ + mmi_set_aud_state_status( FM_AUD_NONE); + + /* OMAPS00151698, x0056422 */ + #ifdef FF_MMI_A2DP_AVRCP + tGlobalBmiBtStruct.tAudioState = FM_AUD_NONE; + /* x0056422, updated changes from this ID */ + /*OMAPS001448610 : This callback code is removed since L1 sends the callback to BT for + stop playback irrespective of whether the stop is due to end of media or is user prompted. */ + tGlobalBmiBtStruct.tCmdSrc = BMI_BT_COMMAND_NONE; + + #endif//FF_MMI_A2DP_AVRCP + /* OMAPS00151698, x0056422 */ + mfw_fm_signal(E_FM_AUDIO_STOP, ¶); + break; + + case AS_PROBAR_IND: + TRACE_EVENT_P2("pt %d tt %d",mp3_pb->u32TotalTimePlayed, mp3_pb->u32totalTimeEst); + para_aud.aud_pt = mp3_pb->u32TotalTimePlayed + last_para_aud_pt; //Daisy tang added for Real Resume feature 20071107 + para_aud.aud_tt = mp3_pb->u32totalTimeEst; + mfw_fm_signal(E_FM_AUDIO_PROG, NULL); + break; + } + return; + +} + +/******************************************************************************* + $Function: mfw_fm_aud_get_type + + $Description: Deduces the type of audio file + + $Returns: audio file type + + $Arguments: file_name : audio file +*******************************************************************************/ +T_FM_OBJ_TYPE mfw_fm_aud_get_type(char * file_name) +{ + T_AS_PLAYER_TYPE player_type; + UINT16 filename_uc[47]; + TRACE_FUNCTION("mfw_fm_aud_get_type"); + + convert_u8_to_unicode(file_name, filename_uc); + as_deduce_player_type(filename_uc,&player_type); + switch(player_type) + { + case AS_PLAYER_TYPE_MIDI: + TRACE_EVENT("AS_PLAYER_TYPE_MIDI"); + return OBJECT_TYPE_AUDIO_MIDI; + case AS_PLAYER_TYPE_MP3: + TRACE_EVENT("AS_PLAYER_TYPE_MP3"); + return OBJECT_TYPE_AUDIO_MP3; + case AS_PLAYER_TYPE_AAC: + TRACE_EVENT("AS_PLAYER_TYPE_AAC"); + return OBJECT_TYPE_AUDIO_AAC; + default: + TRACE_EVENT("Default"); + return OBJECT_TYPE_FILE; + } +} + +/******************************************************************************* + $Function: mfw_fm_audPlay + + $Description: Plays the selected audio file + + $Returns: None + + $Arguments: file_name : audio file + file_type : audio file type +*******************************************************************************/ +#ifdef FF_MMI_UNICODE_SUPPORT +T_FM_AUD_STATE mfw_fm_audPlay(T_WCHAR * filename_uc, T_FM_OBJ_TYPE file_type, BOOL play_bar) +{ + +#else +T_FM_AUD_STATE mfw_fm_audPlay(char * file_name, T_FM_OBJ_TYPE file_type, BOOL play_bar) +{ + UINT16 filename_uc[FM_MAX_DIR_PATH_LENGTH]; + + convert_u8_to_unicode(file_name, filename_uc); +#endif + T_AS_RET status; + T_AS_PLAYER_TYPE player_type; + int i=0; + + TRACE_FUNCTION("mfw_fm_audPlay"); + + //Daisy tang added for Real Resume feature 20071107 + //start + #ifdef FF_MMI_UNICODE_SUPPORT + for(i==0;i<FM_MAX_DIR_PATH_LENGTH;i++) + { + last_inputFileName_uc[i]=filename_uc[i]; + } + + #else + strcpy(last_inputFileName, file_name); + #endif + last_file_type = file_type; + last_play_bar = play_bar; + last_file_size_played = 0; + last_para_aud_pt = 0; + //end + switch(file_type) + { + case OBJECT_TYPE_AUDIO_MIDI: + TRACE_EVENT("AS_PLAYER_TYPE_MIDI"); + + /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */ + /* Voice Limit parameter should be saved to a temp var before playing + MP3 or AAC file */ + player_para.midi.voice_limit = mfw_player_midi_get_voice_limit(); + /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */ + /* MONO is 1 and STEREO is 2 for midi player*/ + player_para.midi.output_channels = player_channel; + player_type = AS_PLAYER_TYPE_MIDI; + break; + case OBJECT_TYPE_AUDIO_MP3: + TRACE_EVENT("AS_PLAYER_TYPE_MP3"); + + /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */ + /* Voice Limit parameter should be saved to a temp var before playing + MP3 or AAC file */ + mfw_player_set_voice_limit (player_para.midi.voice_limit); + /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */ + /* MONO is 0 and STEREO is 1 for mp3 player*/ + player_para.mp3.mono_stereo = player_channel - 1; + player_para.mp3.size_file_start = 0; + player_type = AS_PLAYER_TYPE_MP3; + break; + case OBJECT_TYPE_AUDIO_AAC: + TRACE_EVENT("AS_PLAYER_TYPE_AAC"); + + /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */ + /* Voice Limit parameter should be saved to a temp var before playing + MP3 or AAC file */ + mfw_player_set_voice_limit (player_para.midi.voice_limit); + /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */ + /* MONO is 0 and STEREO is 1 for aac player*/ + player_para.aac.mono_stereo = player_channel - 1 ; + player_para.aac.size_file_start= 0; + player_type = AS_PLAYER_TYPE_AAC; + break; + default: + /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */ + /* Voice Limit parameter should be saved to a temp var before playing + MP3 or AAC file */ + player_para.midi.voice_limit = mfw_player_midi_get_voice_limit(); + /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */ + /* MONO is 1 and STEREO is 2 for midi player*/ + player_para.midi.output_channels = player_channel; + player_type = AS_PLAYER_TYPE_MIDI; + break; + } + as_player_set_params(player_type,&player_para); + + mfw_set_stereo_path(mfw_get_current_audioDevice()); + fm_aud_return_path.addr_id = 0; + fm_aud_return_path.callback_func = mfw_fm_audPlay_cb; + + status=as_play_file(player_type,filename_uc,AS_VOLUME_HIGH,mfw_player_playback_loop_flag,play_bar,&fm_aud_return_path); + if(status == AS_OK) + return FM_AUD_NO_ERROR; + else + return FM_AUD_ERROR; +} + +/******************************************************************************* + $Function: mfw_fm_audStop + + $Description: Stops playing the selected audio file + + $Returns: None + + $Arguments: file_name : audio file + file_type : audio file type +*******************************************************************************/ +T_FM_AUD_STATE mfw_fm_audStop(void) +{ + T_AS_RET status; + TRACE_EVENT("mfw_fm_audStop"); + fm_aud_return_path.addr_id = 0; + fm_aud_return_path.callback_func = mfw_fm_audPlay_cb; + status=as_stop(&fm_aud_return_path); + if(status == AS_OK) + return FM_AUD_NO_ERROR; + else + return FM_AUD_ERROR; +} + +T_FM_AUD_STATE mfw_fm_audPause(void) +{ + T_AS_RET status; + TRACE_EVENT("mfw_fm_audPause"); + fm_aud_return_path.addr_id = 0; + fm_aud_return_path.callback_func = mfw_fm_audPlay_cb; + status=as_pause(&fm_aud_return_path); + if(status == AS_OK) + return FM_AUD_NO_ERROR; + else + return FM_AUD_ERROR; +} + +T_FM_AUD_STATE mfw_fm_audResume(void) +{ + T_AS_RET status; + TRACE_EVENT("mfw_fm_audResume"); + fm_aud_return_path.addr_id = 0; + fm_aud_return_path.callback_func = mfw_fm_audPlay_cb; + mmi_set_aud_state_status( FM_AUD_PLAY); + + + /* OMAPS00151698, x0056422 */ + #ifdef FF_MMI_A2DP_AVRCP + tGlobalBmiBtStruct.tAudioState = FM_AUD_PLAY; + if(tGlobalBmiBtStruct.bConnected != BMI_BT_NOTCONNECTED) + { + /*OMAPS001448610 : This check for Headset/handset command is to be removed since the handling is now exactly the same. */ + if(NULL != tGlobalBmiBtStruct.BmiEventCallback) + tGlobalBmiBtStruct.BmiEventCallback(BMI_EVENT_USER_RESUME); + tGlobalBmiBtStruct.tCmdSrc = BMI_BT_COMMAND_NONE; + + } + #endif//FF_MMI_A2DP_AVRCP + + /* OMAPS00151698, x0056422 */ + status=as_resume(&fm_aud_return_path); + if(status == AS_OK) + return FM_AUD_NO_ERROR; + else + return FM_AUD_ERROR; +} +//Daisy tang added for Real Resume feature 20071107 +//start +T_FM_AUD_STATE mfw_fm_audRealPause(void) +{ + T_AS_RET status; + TRACE_EVENT("mfw_fm_audRealPause"); + isPlayer_Real_Pause = TRUE; + + fm_aud_return_path.addr_id = 0; + fm_aud_return_path.callback_func = mfw_fm_audPlay_cb; + status=as_stop(&fm_aud_return_path); + if(status == AS_OK) + return FM_AUD_NO_ERROR; + else + return FM_AUD_ERROR; +} + +T_FM_AUD_STATE mfw_fm_audRealResume(void) +{ + T_AS_RET status; + T_AS_PLAYER_TYPE player_type; + UINT16 filename_uc[FM_MAX_DIR_PATH_LENGTH]; + int i=0; + + + TRACE_FUNCTION("mfw_fm_audRealResume"); + + if(!isPlayer_Real_Pause) + return FM_AUD_ERROR; + if((last_file_type NEQ OBJECT_TYPE_AUDIO_MP3) AND (last_file_type NEQ OBJECT_TYPE_AUDIO_AAC)) + return FM_AUD_ERROR; + + isPlayer_Real_Pause = FALSE; + + switch(last_file_type) + { + case OBJECT_TYPE_AUDIO_MP3: + TRACE_EVENT("AS_PLAYER_TYPE_MP3"); + + /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */ + /* Voice Limit parameter should be saved to a temp var before playing + MP3 or AAC file */ + mfw_player_set_voice_limit (player_para.midi.voice_limit); + /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */ + /* MONO is 0 and STEREO is 1 for mp3 player*/ + player_para.mp3.mono_stereo = player_channel - 1; + player_para.mp3.size_file_start = last_file_size_played;//Daisy tang added for MP3 feature 20071107 + player_type = AS_PLAYER_TYPE_MP3; + break; + case OBJECT_TYPE_AUDIO_AAC: + TRACE_EVENT("AS_PLAYER_TYPE_AAC"); + + /* Aug 27, 2007 DRT: OMAPS00137370 x0045876 */ + /* Voice Limit parameter should be saved to a temp var before playing + MP3 or AAC file */ + mfw_player_set_voice_limit (player_para.midi.voice_limit); + /* Apr 10, 2007 DRT: OMAPS00125309 x0039928 */ + /* MONO is 0 and STEREO is 1 for aac player*/ + player_para.aac.mono_stereo = player_channel - 1 ; + player_para.aac.size_file_start= last_file_size_played;//Daisy tang added for MP3 feature 20071107 + + player_type = AS_PLAYER_TYPE_AAC; + break; + } + as_player_set_params(player_type,&player_para); + + mfw_set_stereo_path(mfw_get_current_audioDevice()); + fm_aud_return_path.addr_id = 0; + fm_aud_return_path.callback_func = mfw_fm_audPlay_cb; +#ifdef FF_MMI_UNICODE_SUPPORT + for(i==0;i<FM_MAX_DIR_PATH_LENGTH;i++) + { + filename_uc[i]=last_inputFileName_uc[i]; + } +#else + convert_u8_to_unicode(last_inputFileName, filename_uc); +#endif + status=as_play_file(player_type,filename_uc,AS_VOLUME_HIGH,mfw_player_playback_loop_flag,last_play_bar,&fm_aud_return_path); + if(status == AS_OK) + return FM_AUD_NO_ERROR; + else + return FM_AUD_ERROR; +} +//end + + +#endif + +