int fb_ls_ext(const char *ext){
int CurrentNavId = -1;
// if no navigator available, return an error
if ((CurrentNavId = fsaccess_alloc_nav_id()) < 0) return ERROR_NO_NAV_ID;
// select the navigator
nav_select( CurrentNavId );
// navigate to folder
if(nav_setcwd((FS_STRING)currentDirectory, FALSE, FALSE) == FALSE){
fsaccess_free_nav_id(CurrentNavId);
return ERROR_NOT_A_DIRECTORY;
}
if(nav_filelist_first(FS_FILE)==FALSE){
fsaccess_free_nav_id(CurrentNavId);
return ERROR_UNKNOWN;
}
char filename[255];
if(nav_file_getname(filename,sizeof(filename))==FALSE){
fsaccess_free_nav_id(CurrentNavId);
return ERROR_UNKNOWN;
}
seprintf("Contents of folder %s:\n\n",currentDirectory);
nav_filelist_single_enable( FS_DIR );
int filecount = nav_filelist_nb(FS_DIR);
short a;
for(a=0; a < filecount; a++){
if(nav_filelist_goto(a)==FALSE)return ERROR_UNKNOWN;
char filename[255];
if(nav_file_getname(filename,sizeof(filename))==FALSE){
fsaccess_free_nav_id(CurrentNavId);
return ERROR_UNKNOWN;
}
seprintf("%d: %s\n",a,filename);
}
nav_filelist_single_enable( FS_FILE );
filecount = nav_filelist_nb(FS_FILE);
for(a=0; a < filecount; a++){
if(nav_filelist_goto(a)==FALSE)return ERROR_UNKNOWN;
if(!nav_file_checkext(ext))continue;
char filename[255];
if(nav_file_getname(filename,sizeof(filename))==FALSE){
fsaccess_free_nav_id(CurrentNavId);
return ERROR_UNKNOWN;
}
seprintf("%d: %s\n",a,filename);
}
fsaccess_free_nav_id(CurrentNavId);
return 0;
}
int fb_iterator_init(Bool type){
file_or_dir = type;
fb_iterator_reset();
// if no navigator available, return an error
if ((iterator_navid = fsaccess_alloc_nav_id()) < 0) return ERROR_NO_NAV_ID;
fsaccess_take_mutex();
// select the navigator
nav_select( iterator_navid );
// navigate to folder
if(nav_setcwd((FS_STRING)currentDirectory, FALSE, FALSE) == FALSE){
fsaccess_free_nav_id(iterator_navid);
return ERROR_NOT_A_DIRECTORY;
}
//select top of list
if(nav_filelist_first(type)==FALSE){
fsaccess_free_nav_id(iterator_navid);
return ERROR_UNKNOWN;
}
nav_filelist_single_enable( type );
filecount = nav_filelist_nb(file_or_dir);
return 0;
}
//! This function jumps to the next or previous file in file list included in directories
//!
//! @param b_direction jump direction (FS_FIND_NEXT or FS_FIND_PREV)
//! @param options define extra modes for this function
//!
//! @return the status of the action
//!
//! @verbatim
//! This routine is not authorized then a play list file is opened
//! When the random is ON, the direction is ignored
//! @endverbatim
//!
Navauto_mov_state navauto_mov_explorer( bool b_direction, navauto_mov_options_t options )
{
Navauto_mov_state state;
uint16_t u16_mov_pos = 0;
size_t nb_loops = 1;
// Reset the bitfield status
memset(&bitfield_status, 0, sizeof(bitfield_status));
// Random implementation
if (g_navauto_rand == NAVAUTO_RAND_ON)
{
u16_mov_pos = navauto_rand_choose();
if (!u16_mov_pos)
{
navauto_rand_init();
// navauto_mov_explorer_reset();
u16_mov_pos = navauto_rand_choose();
if(!u16_mov_pos)
{
state.bitfield.all = bitfield_status.all;
state.status = NAVAUTO_MOV_EMPTY;
return state; // Error system
}
}
// To avoid end of loop (NAVAUTO_MOV_OK_LOOP state)
b_direction = (u16_mov_pos > g_navauto_u16_pos)?FS_FIND_NEXT:FS_FIND_PREV;
nb_loops = (u16_mov_pos > g_navauto_u16_pos)?(u16_mov_pos-g_navauto_u16_pos):(g_navauto_u16_pos-u16_mov_pos);
// Approximation used for the "stay in current directory" bit,
// it reduces the number of loops in large file systems.
if ( (options & NAVAUTO_MOV_OPTS_STAY_CURRENT_DIR)
|| (g_navauto_exp_mode == NAVAUTO_MODE_DIRONLY))
nb_loops %= nav_filelist_nb(FS_FILE);
// Set u16_mov_pos to the current position to compare it with current and to make sure the
// new file selected is not the same as the last one.
u16_mov_pos = g_navauto_u16_pos;
}
// This loop is done, so that the random method is not a problem once a NAVAUTO_MOV_OPTS_STAY_CURRENT_DIR option is set to 1.
while(nb_loops--)
{
// Compute the recursive function
state.status = navauto_mov_explorer_rec(b_direction, options);
// Check its returning state
switch(state.status)
{
// If the function is at the end of the loop
case NAVAUTO_MOV_OK_LOOP:
// Update g_navauto_u16_pos counter
if (b_direction == FS_FIND_NEXT)
{
g_navauto_u16_nb = g_navauto_u16_pos + 1;
g_navauto_u16_pos = 0;
}
else
g_navauto_u16_pos = g_navauto_u16_nb - 1;
// Means it reached the tail or the beginning of the playlist.
// Then set the pointer to a limit of the "playlist"
// should be at the beginning for a NEXT and at end for a PREVIOUS command.
switch(limit_process_fct[(b_direction == FS_FIND_NEXT)?1:0](b_direction))
{
case NAVAUTO_MOV_EXPLORER_RECURSIVE:
// If it returns NAVAUTO_MOV_OK_LOOP, it means it reached two times a row the end of the playlist,
// therefore, this is an empty disk!
if (navauto_mov_explorer_rec(b_direction, options) == NAVAUTO_MOV_OK_LOOP)
{
state.bitfield.all = bitfield_status.all;
state.status = NAVAUTO_MOV_EMPTY;
return state;
}
break;
default:
break;
}
state.bitfield.all = bitfield_status.all;
state.status = NAVAUTO_MOV_OK_LOOP;
return state;
// If a file is correctly selected
case NAVAUTO_MOV_OK:
// Update g_navauto_u16_pos counter
g_navauto_u16_pos += (b_direction == FS_FIND_NEXT)?(1):(-1);
// if the selection is the same as last one, then get next file
if (g_navauto_rand == NAVAUTO_RAND_ON && u16_mov_pos == g_navauto_u16_pos && !nb_loops)
{
state.status = navauto_mov_explorer_rec(b_direction, options);
state.bitfield.all = bitfield_status.all;
return state;
}
break;
default:
state.bitfield.all = bitfield_status.all;
return state;
}
}
state.status = NAVAUTO_MOV_OK;
state.bitfield.all = bitfield_status.all;
return state;
}
//!
//! @brief Synchronize the contents of two directories (limited to files).
//!
//! @param dst_fs_idx Fs_index *: File system index for destination navigation path
//! @param dst_dir const char *: Pointer to destination directory name
//! @param src_fs_idx Fs_index *: File system index for source navigation path
//! @param src_dir const char *: Pointer to source directory name
//!
//! @return bool: true on success
//!
//! @todo Do recursive directory copy...
//!
bool host_mass_storage_task_sync_dir(Fs_index *dst_fs_idx, const char *dst_dir, Fs_index *src_fs_idx, const char *src_dir)
{
uint8_t nb_file;
uint8_t i;
uint32_t free_space;
uint16_t file_size;
// First, check the host controller is in full operating mode with the
// B-device attached and enumerated
if (!Is_host_ready()) return false;
// Go to source navigation
nav_gotoindex(src_fs_idx);
if (!goto_code_name(src_dir)) return false; // Check that source directory exists
nav_dir_cd(); // Source directory exists, so go to it
*src_fs_idx = nav_getindex(); // Save navigation position
nav_filelist_first(FS_FILE); // Go to first file
nb_file = nav_filelist_nb(FS_FILE); // Get the number of files in this directory
// Go to destination navigation
nav_gotoindex(dst_fs_idx);
if (!goto_code_name(dst_dir)) // Destination directory does not exist, so create it
{
str_code_to_unicode_ram(dst_dir, ms_str_unicode);
nav_dir_make(ms_str_unicode);
if (!goto_code_name(dst_dir)) return false; // Check that destination directory has been created
}
nav_dir_cd();
*dst_fs_idx = nav_getindex();
// Get available free space
free_space = nav_partition_space();
nav_gotoindex(src_fs_idx);
nav_filelist_first(FS_FILE);
// For all files in directory
for (i = 0; i < nb_file; i++)
{
// Get source name to be used as destination name
nav_file_name(ms_str_unicode, MAX_FILE_PATH_LENGTH, FS_NAME_GET);
file_size = nav_file_lgtsector(); // Get file size
if (file_size > free_space) return false; // Check that there is enough free space left
// Update free space (to save time, do no call nav_partition_space() again)
free_space -= file_size;
// Mark source
nav_file_copy();
// Save current source position
*src_fs_idx = nav_getindex();
// Go to destination navigation
nav_gotoindex(dst_fs_idx);
if (goto_unicode_name(ms_str_unicode)) // If file already exists
{
nav_file_del(); // Delete it
}
// Paste
nav_file_paste_start(ms_str_unicode);
// Restore previous navigation position
nav_gotoindex(src_fs_idx);
// Copy
while (nav_file_paste_state(false) == COPY_BUSY);
// Restore previous navigation position
nav_gotoindex(src_fs_idx);
nav_filelist_set(0, FS_FIND_NEXT);
}
return true;
}