C++ SdFile::isDir方法代码示例

idigi_callback_status_t iDigiFileSystem::app_process_file_stat(idigi_file_stat_request_t * const request_data,
                                                     idigi_file_stat_response_t * const response_data)
{
    idigi_file_stat_t *pstat = &response_data->statbuf;
    idigi_callback_status_t status = idigi_callback_continue;

    SdFile entry = DigiSD.open(request_data->path);

    if (!entry.isOpen())
    {
     	APP_DEBUG("stat cannot open: %s\n", request_data->path);
        goto done;   	
    }

    pstat->last_modified = 0;					// Last modified date unsupported:
    pstat->hash_alg = idigi_file_hash_none;	// File hash not supported
    pstat->file_size = (size_t) entry.fileSize();
    pstat->flags = 0;
    if (entry.isDir())
    	pstat->flags |= IDIGI_FILE_IS_DIR;
    else
    	pstat->flags |= IDIGI_FILE_IS_REG;

    entry.close();

done:
    return status;
}

/*
  Description:
    Requrest for a specific file at a specified position within the directory
    The path argument is identical to the path which was provided to last
    call to "mas_sdfat_move_to_pwd"
*/
uint8_t mas_sdfat_get_nth_file(const char *path, uint16_t n, char *buf, uint8_t *is_dir)
{
  uint16_t c = 0;

  if ( mas_sdfat_move_to_pwd(path) == 0 )
    return 0;
  
  if ( mas_sdfat_file_is_open != 0 )
  {
    mas_sdfat_file.close();
    mas_sdfat_file_is_open = 0;
  }
  
  mas_sdfat_sd->vwd()->rewind();
  while (mas_sdfat_file.openNext(mas_sdfat_sd->vwd(), O_READ)) 
  {
    if ( n == c )
    {
      mas_sdfat_file.getFilename(buf);
      buf[12] = '\0';
      *is_dir = mas_sdfat_file.isDir();
      mas_sdfat_file.close();
      return 1;
    }
    c++;
    mas_sdfat_file.close();
  }
  return 0;
}

idigi_callback_status_t iDigiFileSystem::app_process_file_opendir(idigi_file_path_request_t * const request_data,
                                                        idigi_file_open_response_t * const response_data)
{
    idigi_callback_status_t status = idigi_callback_continue;
    SdFile *dir = new SdFile;

    if (dir == NULL)
    {
    	response_data->error->error_status = idigi_file_out_of_memory;
    }

    *dir = DigiSD.open(request_data->path);

    if (!dir->isOpen() || !dir->isDir())
    {
    	response_data->error->error_status = idigi_file_path_not_found;
    	return status;
    }

    dir->rewind();

    response_data->handle = dir;
    APP_DEBUG("opendir for %s returned %p\n", request_data->path, (void *) dir);

    return status;
}

/** Change current working directory
 *
 * Changes the current working directory to the \a path subdirectory.
 *
 * Example: Executing chdir("SUB") in the "/DIR" directory will change the
 * current working directory from "/DIR" to "/DIR/SUB".
 *
 * \param[in] path The name of the subdirectory.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 */
bool SdFat::chdir(const char *path) {
  SdFile dir;
  if (path[0] == '/' && path[1] == '\0') return chdir();
  if (!dir.open(path, O_READ)) goto fail;
  if (!dir.isDir()) goto fail;
  cwd_ = dir;
  return true;

 fail:
  return false;
}

  boolean get_handler(AtMegaWebServer& web_server){
	const char* filename = web_server.get_path();
#if DEBUG
	Serial << F("file_handler path: ") << filename << '\n';
#endif

  if (!filename) {
    web_server.sendHttpResult(404);
#if DEBUG
    Serial << F("Could not parse URL");
#endif
    return true;
  }

  if(filename[0] == '/' && filename[1] == 0){ // root dir, file.open() will fail
    listDirectory(web_server, SdBaseFile::cwd());
	return true;
  }

  SdFile file;
  if(file.open(filename, O_READ)){
#if DEBUG
     Serial << "file isOpen: " << filename << '\n';
#endif
	  if (file.isDir())
	  {
		listDirectory(web_server, &file);
	  }
	  else
	  {
		AtMegaWebServer::MimeType mime_type
		  = AtMegaWebServer::get_mime_type_from_filename(filename);

  // If you want to send a file with a non-supported MimeType you can:
  // web_server.sendHttpResult(200, 0, "Content-Type: image/tiff" CRLF);

        web_server.sendHttpResult(200, mime_type);
#if DEBUG
		Serial << F("Read file ");
		Serial.println(filename);
#endif
		web_server.send_file(file);
	  }
	  file.close();
    }else{
      web_server.sendHttpResult(404);
    }
    return true;
}

void SD_ListFiles(void)
{

    Serial.begin(9600);
    while (!Serial) {}
    delay(1000);
    Serial.println();
    while (file.openNext(sdf.vwd(), O_READ)) {
        file.printFileSize(&Serial);
        Serial.write(' ');
        file.printModifyDateTime(&Serial);
        Serial.write(' ');
        file.printName(&Serial);
        if (file.isDir()) {
            // Indicate a directory.
            Serial.write('/');
        }
        Serial.println();
        file.close();
    }
}

void MP3Player::PlayTrack(const char* dirName,int track_no,const char* track_name)
{	
	if(!PLAY)
	{
	 finishSearch = false;
	 int count=0;
	 //if(track_no>0)
		 //counter = track_no;
	
	if(!isPlayAll)
	{
		char temp[20];
		isPlayAll = true;
		sd.chdir();delayMicroseconds(100000);
		sd.chdir(dirName,true);
		sd.vwd()->rewind();
		sd.vwd()->getName(temp,20);
		currentDir = temp;
		counter = 0;
	}

	while(true)
	{
		if(myFile.openNext(myFile.cwd(), O_READ))
		{
			char FileName[80];
			myFile.getName(FileName,80);
			#if DEBUG
				//myFile.printName(&Serial);
				Serial.print(FileName);
				if (myFile.isDir()) 
				{
					// Indicate a directory.
					Serial.write('/');
				}
				Serial.println();
			#endif
			
			if (!(myFile.isDir()||(String(FileName).indexOf(".mp3")==-1&&String(FileName).indexOf(".MP3")==-1))) 
			{
				counter++;
				
				if(ls_flag)
				{
					Serial.print(counter);
					Serial.print(". ");
					Serial.print(FileName);
					Serial.print("     ");
					Serial.print(myFile.fileSize());
					Serial.println(" bytes");
					myFile.close();
					continue;
				}
				
				//Play(FileName);
				if(!String(track_name).equals(""))
				{
					//counter++;
					if(String(track_name).equals(FileName))
					{
						Play(FileName);
						//name = track_name;
						isPlayAll = false;
						break;
					}
				}
				
				else if(track_no==0)
				{
					//counter++;
					Play(FileName);
					break;
				}
				else if(track_no>0)
				{
					count++;
					if(count==track_no)
					{
						counter = track_no;
						Play(FileName);
						isPlayAll = false;
						break;
					}
				}
				

			}
	
		}

		else
		{
			isPlayAll = false;
			finishSearch = true;
			ls_flag = false;
			break;
		}
		//myFile.getFilename(FileName);
		myFile.close();
	}
//.........这里部分代码省略.........