Rework SPIFFS API to be more Arduino like

SD Style commands and Stream API

Author: ficeto

hardware/esp8266com/esp8266/cores/esp8266/FileSystem.cpp

@@ -1,178 +1,208 @@
-/****
- * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
- * Created 2015 by Skurydin Alexey
- * http://github.com/anakod/Sming
- * All files of the Sming Core are provided under the LGPL v3 license.
- ****/
-
+/* 
+  FileSystem.cpp - SPIFS implementation for esp8266
+
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
 #include "FileSystem.h"
-#include "WString.h"
+#include "Arduino.h"
+
+boolean FSClass::mount(){
+  if(_mounted) return true;
+  _mounted = spiffs_mount();
+  return _mounted;
+}
+
+void FSClass::unmount(){
+  if(!_mounted) return;
+  spiffs_unmount();
+  _mounted = false;
+}
+
+boolean FSClass::format(){
+  return spiffs_format();
+}
+
+boolean FSClass::exists(const char *filename){
+  spiffs_stat stat = {0};
+  if (SPIFFS_stat(&_filesystemStorageHandle, filename, &stat) < 0) return false;
+  return stat.name[0] != '\0';
+}
 
-file_t fileOpen(const String name, FileOpenFlags flags)
-{
+boolean FSClass::create(const char *filepath){
+  return SPIFFS_creat(&_filesystemStorageHandle, filepath, 0) == 0;
+}
+
+boolean FSClass::remove(const char *filepath){
+  return SPIFFS_remove(&_filesystemStorageHandle, filepath) == 0;
+}
+
+boolean FSClass::rename(const char *filename, const char *newname){
+  return SPIFFS_rename(&_filesystemStorageHandle, filename, newname) == 0;
+}
+
+FSFile FSClass::open(const char *filename, uint8_t mode){
   int repeats = 0;
   bool notExist;
-  bool canRecreate = (flags & eFO_CreateIfNotExist) == eFO_CreateIfNotExist;
+  bool canRecreate = (mode & SPIFFS_CREAT) == SPIFFS_CREAT;
   int res;
 
-  do
-  {
-	  notExist = false;
-	  res = SPIFFS_open(&_filesystemStorageHandle, name.c_str(), (spiffs_flags)flags, 0);
-	  int code = SPIFFS_errno(&_filesystemStorageHandle);
-	  if (res < 0)
-	  {
-		  debugf("open errno %d\n", code);
-		  notExist = (code == SPIFFS_ERR_NOT_FOUND || code == SPIFFS_ERR_DELETED || code == SPIFFS_ERR_FILE_DELETED || code == SPIFFS_ERR_IS_FREE);
-		  //debugf("recreate? %d %d %d", notExist, canRecreate, (repeats < 3));
-		  if (notExist && canRecreate)
-			  fileDelete(name); // fix for deleted files
-	  }
+  do{
+    notExist = false;
+    res = SPIFFS_open(&_filesystemStorageHandle, filename, (spiffs_flags)mode, 0);
+    int code = SPIFFS_errno(&_filesystemStorageHandle);
+    if (res < 0){
+      debugf("open errno %d\n", code);
+      notExist = (code == SPIFFS_ERR_NOT_FOUND || code == SPIFFS_ERR_DELETED || code == SPIFFS_ERR_FILE_DELETED || code == SPIFFS_ERR_IS_FREE);
+      if (notExist && canRecreate)
+        remove(filename); // fix for deleted files
+    }
   } while (notExist && canRecreate && repeats++ < 3);
-
-  return res;
+  
+  if(res){
+    return FSFile(res);
+  }
+  return FSFile();
 }
 
-void fileClose(file_t file)
-{
-  SPIFFS_close(&_filesystemStorageHandle, file);
+FSClass FS;
+
+FSFile::FSFile(){
+  _file = 0;
+  _stats = {0};
 }
 
-size_t fileWrite(file_t file, const void* data, size_t size)
-{
-  int res = SPIFFS_write(&_filesystemStorageHandle, file, (void *)data, size);
-  if (res < 0)
-  {
-    debugf("write errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
-    return res;
+FSFile::FSFile(file_t f){
+  _file = f;
+  if(SPIFFS_fstat(&_filesystemStorageHandle, _file, &_stats) != 0){
+    debugf("mount errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
   }
-  return res;
 }
 
-size_t fileRead(file_t file, void* data, size_t size)
-{
-  int res = SPIFFS_read(&_filesystemStorageHandle, file, data, size);
-  if (res < 0)
-  {
-    debugf("read errno %d\n", SPIFFS_errno(&_filesystemStorageHandle));
-    return res;
-  }
-  return res;
+void FSFile::close(){
+  if (! _file) return;
+  SPIFFS_close(&_filesystemStorageHandle, _file);
+  _file = 0;
 }
 
-int fileSeek(file_t file, int offset, SeekOriginFlags origin)
-{
-  return SPIFFS_lseek(&_filesystemStorageHandle, file, offset, origin);
+uint32_t FSFile::size(){
+  if(! _file) return 0;
+  uint32_t pos = SPIFFS_tell(&_filesystemStorageHandle, _file);
+  SPIFFS_lseek(&_filesystemStorageHandle, _file, 0, SPIFFS_SEEK_END);
+  uint32_t size = SPIFFS_tell(&_filesystemStorageHandle, _file);
+  SPIFFS_lseek(&_filesystemStorageHandle, _file, pos, SPIFFS_SEEK_SET);
+  return size;
 }
 
-bool fileIsEOF(file_t file)
-{
-  return SPIFFS_eof(&_filesystemStorageHandle, file);
+uint32_t FSFile::seek(uint32_t pos){
+  if (! _file) return 0;
+  return SPIFFS_lseek(&_filesystemStorageHandle, _file, pos, SPIFFS_SEEK_SET);
 }
 
-int32_t fileTell(file_t file)
-{
-  return SPIFFS_tell(&_filesystemStorageHandle, file);
+uint32_t FSFile::position(){
+  if (! _file) return 0;
+  return SPIFFS_tell(&_filesystemStorageHandle, _file);
 }
 
-int fileFlush(file_t file)
-{
-  return SPIFFS_fflush(&_filesystemStorageHandle, file);
+boolean FSFile::eof(){
+  if (! _file) return 0;
+  return SPIFFS_eof(&_filesystemStorageHandle, _file);
 }
 
-int fileStats(const String name, spiffs_stat *stat)
-{
-	return SPIFFS_stat(&_filesystemStorageHandle, name.c_str(), stat);
+boolean FSFile::isDirectory(void){
+  return false;
 }
 
-int fileStats(file_t file, spiffs_stat *stat)
-{
-	return SPIFFS_fstat(&_filesystemStorageHandle, file, stat);
+int FSFile::read(void *buf, uint16_t nbyte){
+  if (! _file) return -1;
+  return SPIFFS_read(&_filesystemStorageHandle, _file, buf, nbyte);
 }
 
-void fileDelete(const String name)
-{
-	SPIFFS_remove(&_filesystemStorageHandle, name.c_str());
+int FSFile::read(){
+  if (! _file) return -1;
+  int val;
+  if(SPIFFS_read(&_filesystemStorageHandle, _file, &val, 1) != 1) return -1;
+  return val;
 }
 
-void fileDelete(file_t file)
-{
-	SPIFFS_fremove(&_filesystemStorageHandle, file);
+int FSFile::peek() {
+  if (! _file) return 0;
+  int c = read();
+  SPIFFS_lseek(&_filesystemStorageHandle, _file, -1, SPIFFS_SEEK_CUR);
+  return c;
 }
 
-bool fileExist(const String name)
-{
-  spiffs_stat stat = {0};
-  if (fileStats(name.c_str(), &stat) < 0) return false;
-  return stat.name[0] != '\0';
+int FSFile::available() {
+  if (! _file) return 0;
+  uint32_t pos = SPIFFS_tell(&_filesystemStorageHandle, _file);
+  SPIFFS_lseek(&_filesystemStorageHandle, _file, 0, SPIFFS_SEEK_END);
+  uint32_t size = SPIFFS_tell(&_filesystemStorageHandle, _file);
+  SPIFFS_lseek(&_filesystemStorageHandle, _file, pos, SPIFFS_SEEK_SET);
+  return size - pos;
+}
+
+size_t FSFile::write(const uint8_t *buf, size_t size){
+  if (! _file) return 0;
+  return SPIFFS_write(&_filesystemStorageHandle, _file, (uint8_t *)buf, size);
+}
+
+size_t FSFile::write(uint8_t val) {
+  if (! _file) return 0;
+  return write(&val, 1);
 }
 
+void FSFile::flush(){
+  if (! _file) return;
+  SPIFFS_fflush(&_filesystemStorageHandle, _file);
+}
 
-int fileLastError(file_t fd)
-{
+uint32_t FSFile::remove(){
+  if (! _file) return 0;
+	return SPIFFS_fremove(&_filesystemStorageHandle, _file);
+  _file = 0;
+}
+
+int FSFile::lastError(){
   return SPIFFS_errno(&_filesystemStorageHandle);
 }
 
-void fileClearLastError(file_t fd)
-{
+void FSFile::clearError(){
   _filesystemStorageHandle.errno = SPIFFS_OK;
 }
 
-void fileSetContent(const String fileName, const char *content)
-{
-	file_t file = fileOpen(fileName.c_str(), eFO_CreateNewAlways | eFO_WriteOnly);
-	fileWrite(file, content, os_strlen(content));
-	fileClose(file);
-}
-
-uint32_t fileGetSize(const String fileName)
-{
-	file_t file = fileOpen(fileName.c_str(), eFO_ReadOnly);
-	// Get size
-	fileSeek(file, 0, eSO_FileEnd);
-	int size = fileTell(file);
-	fileClose(file);
-	return size;
-}
-
-String fileGetContent(const String fileName)
-{
-	file_t file = fileOpen(fileName.c_str(), eFO_ReadOnly);
-	// Get size
-	fileSeek(file, 0, eSO_FileEnd);
-	int size = fileTell(file);
-	if (size <= 0)
-	{
-		fileClose(file);
-		return "";
-	}
-	fileSeek(file, 0, eSO_FileStart);
-	char* buffer = new char[size + 1];
-	buffer[size] = 0;
-	fileRead(file, buffer, size);
-	fileClose(file);
-	String res = buffer;
-	delete[] buffer;
-	return res;
-}
-
-int fileGetContent(const String fileName, char* buffer, int bufSize)
-{
-	if (buffer == NULL || bufSize == 0) return 0;
-	*buffer = 0;
-
-	file_t file = fileOpen(fileName.c_str(), eFO_ReadOnly);
-	// Get size
-	fileSeek(file, 0, eSO_FileEnd);
-	int size = fileTell(file);
-	if (size <= 0 || bufSize <= size)
-	{
-		fileClose(file);
-		return 0;
-	}
-	buffer[size] = 0;
-	fileSeek(file, 0, eSO_FileStart);
-	fileRead(file, buffer, size);
-	fileClose(file);
-	return size;
+char * FSFile::name(){
+  return 0;
+}
+
+
+
+
+
+
+/*
+spiffs_DIR *dirOpen(spiffs_DIR *d){
+  return SPIFFS_opendir(&_filesystemStorageHandle, 0, d);
+}
+
+int dirClose(spiffs_DIR *d){
+  return SPIFFS_closedir(d);
+}
+
+file_t dirOpenFile(spiffs_dirent* entry, uint8_t flags){
+  return SPIFFS_open_by_dirent(&_filesystemStorageHandle, entry, (spiffs_flags)flags, 0);
 }
+*/