nuttx-apps/graphics/lvgl/lv_fs_interface.c

/****************************************************************************
 * graphics/lvgl/lv_fs_interface.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <fcntl.h>
#include <errno.h>
#include <dirent.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/statfs.h>
#include "lv_fs_interface.h"

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define LV_FS_LETTER '/'

/****************************************************************************
 * Private Type Declarations
 ****************************************************************************/

/* Create a type to store the required data about your file. */

typedef int file_t;

/* Similarly to `file_t` create a type for directory reading too */

typedef DIR *dir_t;

/****************************************************************************
 * Private Function Prototypes
 ****************************************************************************/

static lv_fs_res_t fs_open(lv_fs_drv_t *drv, void *file_p,
                           const char *path, lv_fs_mode_t mode);
static lv_fs_res_t fs_close(lv_fs_drv_t *drv, void *file_p);
static lv_fs_res_t fs_read(lv_fs_drv_t *drv, void *file_p,
                           void *buf, uint32_t btr, uint32_t *br);
static lv_fs_res_t fs_write(lv_fs_drv_t *drv, void *file_p,
                            const void *buf, uint32_t btw, uint32_t *bw);
static lv_fs_res_t fs_seek(lv_fs_drv_t *drv, void *file_p,
                           uint32_t pos);
static lv_fs_res_t fs_size(lv_fs_drv_t *drv, void *file_p,
                           uint32_t *size_p);
static lv_fs_res_t fs_tell(lv_fs_drv_t *drv, void *file_p,
                           uint32_t *pos_p);
static lv_fs_res_t fs_remove(lv_fs_drv_t *drv, const char *path);
static lv_fs_res_t fs_trunc(lv_fs_drv_t *drv, void *file_p);
static lv_fs_res_t fs_rename(lv_fs_drv_t *drv, const char *oldname,
                             const char *newname);
static lv_fs_res_t fs_free(lv_fs_drv_t *drv, uint32_t *total_p,
                           uint32_t *free_p);
static lv_fs_res_t fs_dir_open(lv_fs_drv_t *drv, void *dir_p,
                               const char *path);
static lv_fs_res_t fs_dir_read(lv_fs_drv_t *drv, void *dir_p, char *fn);
static lv_fs_res_t fs_dir_close(lv_fs_drv_t *drv, void *dir_p);

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: fs_open
 *
 * Description:
 *   Open a file.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *   path   - path to the file beginning with the driver letter.
 *            (e.g. /folder/file.txt)
 *   mode   - read: FS_MODE_RD, write: FS_MODE_WR,
 *            both: FS_MODE_RD | FS_MODE_WR
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_open(lv_fs_drv_t *drv, void *file_p,
                           const char *path, lv_fs_mode_t mode)
{
  uint32_t flags = 0;
  if (mode == LV_FS_MODE_WR)
    {
      flags = O_WRONLY | O_CREAT;
    }
  else if (mode == LV_FS_MODE_RD)
    {
      flags = O_RDONLY;
    }
  else if (mode == (LV_FS_MODE_WR | LV_FS_MODE_RD))
    {
      flags = O_RDWR | O_CREAT;
    }
  else
    {
      return LV_FS_RES_UNKNOWN;
    }

  file_t f = open(--path, flags);
  if (f < 0)
    {
      return LV_FS_RES_FS_ERR;
    }

  /* 'file_p' is pointer to a file descriptor and
   * we need to store our file descriptor here
   */

  file_t *fp = file_p;        /* Just avoid the confusing casings */
  *fp = f;

  return LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_close
 *
 * Description:
 *   Close an opened file.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *
 * Returned Value:
 *   LV_FS_RES_OK: no error, the file is read
 *   any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_close(lv_fs_drv_t *drv, void *file_p)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  return close(*fp) < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_read
 *
 * Description:
 *   Read data from an opened file.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *   buf    - pointer to a memory block where to store the read data.
 *   btr    - number of Bytes To Read.
 *   br     - the real number of read bytes (Byte Read).
 *
 * Returned Value:
 *   LV_FS_RES_OK: no error, the file is read
 *   any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_read(lv_fs_drv_t *drv, void *file_p,
                           void *buf, uint32_t btr, uint32_t *br)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  *br = read(*fp, buf, btr);

  return (int32_t)*br < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_write
 *
 * Description:
 *   Write into a file.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *   buf    - pointer to a buffer with the bytes to write.
 *   btw    - Bytes To Write.
 *   bw     - the number of real written bytes (Bytes Written).
 *            NULL if unused.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_write(lv_fs_drv_t *drv, void *file_p,
                            const void *buf, uint32_t btw, uint32_t *bw)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  *bw = write(*fp, buf, btw);

  return (int32_t)*bw < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_seek
 *
 * Description:
 *   Set the read write pointer. Also expand the file size if necessary.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *   pos    - the new position of read write pointer.
 *
 * Returned Value:
 *   LV_FS_RES_OK: no error, the file is read
 *   any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_seek(lv_fs_drv_t *drv, void *file_p, uint32_t pos)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  off_t offset = lseek(*fp, pos, SEEK_SET);

  return offset < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_size
 *
 * Description:
 *   Give the size of a file bytes.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *   size   - pointer to a variable to store the size.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_size(lv_fs_drv_t *drv, void *file_p,
                           uint32_t *size_p)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  off_t cur = lseek(*fp, 0, SEEK_CUR);

  *size_p = lseek(*fp, 0L, SEEK_END);

  /* Restore file pointer */

  lseek(*fp, cur, SEEK_SET);

  return (int32_t)*size_p < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_tell
 *
 * Description:
 *   Give the position of the read write pointer.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *   pos_p  - pointer to to store the result.
 *
 * Returned Value:
 *   LV_FS_RES_OK: no error, the file is read
 *   any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_tell(lv_fs_drv_t *drv, void *file_p,
                           uint32_t *pos_p)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  *pos_p = lseek(*fp, 0, SEEK_CUR);

  return (int32_t)*pos_p < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_remove
 *
 * Description:
 *   Delete a file.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   path   - path of the file to delete.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_remove(lv_fs_drv_t *drv, const char *path)
{
  return remove(--path) < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_trunc
 *
 * Description:
 *   Truncate the file size to the current position of
 *   the read write pointer.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   file_p - pointer to a file_t variable.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_trunc(lv_fs_drv_t *drv, void *file_p)
{
  /* Just avoid the confusing casings */

  file_t *fp = file_p;

  off_t p = lseek(*fp, 0, SEEK_CUR);

  return ftruncate(*fp, p) < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_rename
 *
 * Description:
 *   Rename a file.
 *
 * Input Parameters:
 *   drv     - pointer to a driver where this function belongs.
 *   oldname - path to the file.
 *   newname - path with the new name
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_rename(lv_fs_drv_t *drv, const char *oldname,
                             const char *newname)
{
  return rename(--oldname, --newname) < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_free
 *
 * Description:
 *   Get the free and total size of a driver in kB.
 *
 * Input Parameters:
 *   drv     - pointer to a driver where this function belongs.
 *   total_p - pointer to store the total size [kB].
 *   free_p  - pointer to store the free size [kB]
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_free(lv_fs_drv_t *drv, uint32_t *total_p,
                           uint32_t *free_p)
{
  struct statfs sfs;

  if (statfs(CONFIG_LV_FILESYSTEM_MOUNTPOINT, &sfs) < 0)
    {
      return LV_FS_RES_FS_ERR;
    }
  else
    {
      *total_p = sfs.f_blocks * sfs.f_bsize / 1024;
      *free_p = sfs.f_bfree * sfs.f_bsize / 1024;
      return LV_FS_RES_OK;
    }
}

/****************************************************************************
 * Name: fs_dir_open
 *
 * Description:
 *   Initialize a 'fs_read_dir_t' variable for directory reading.
 *
 * Input Parameters:
 *   drv     - pointer to a driver where this function belongs.
 *   dir_p   - pointer to a 'fs_read_dir_t' variable.
 *   path    - path to a directory.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_dir_open(lv_fs_drv_t *drv, void *dir_p,
                               const char *path)
{
  dir_t d;

  /* Make the path relative to the current directory
   * (the projects root folder)
   */

  if ((d = opendir(--path)) == NULL)
    {
      return LV_FS_RES_FS_ERR;
    }
  else
    {
      /* 'dir_p' is pointer to a file descriptor and
       * we need to store our file descriptor here
       */

      /* Just avoid the confusing casings */

      dir_t *dp = dir_p;
      *dp = d;
    }

  return LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_dir_read
 *
 * Description:
 *   Read the next filename form a directory.
 *   The name of the directories will begin with '/'.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   dir_p  - pointer to an initialized 'fs_read_dir_t' variable.
 *   fn     - pointer to a buffer to store the filename.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_dir_read(lv_fs_drv_t *drv, void *dir_p, char *fn)
{
  /* Just avoid the confusing casings */

  dir_t *dp = dir_p;

  do
    {
      struct dirent *entry = readdir(*dp);

      if (entry)
        {
          if (entry->d_type == DT_DIR)
            {
              sprintf(fn, "/%s", entry->d_name);
            }
          else
            {
              strcpy(fn, entry->d_name);
            }
        }
      else
        {
          strcpy(fn, "");
        }
    }
  while (strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);

  return LV_FS_RES_OK;
}

/****************************************************************************
 * Name: fs_dir_read
 *
 * Description:
 *   Close the directory reading.
 *
 * Input Parameters:
 *   drv    - pointer to a driver where this function belongs.
 *   dir_p  - pointer to an initialized 'fs_read_dir_t' variable.
 *
 * Returned Value:
 *   LV_FS_RES_OK or any error from lv_fs_res_t enum.
 *
 ****************************************************************************/

static lv_fs_res_t fs_dir_close(lv_fs_drv_t *drv, void *dir_p)
{
  dir_t *dp = dir_p;

  return closedir(*dp) < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: lv_fs_interface_init
 *
 * Description:
 *   Register a driver for the File system interface.
 *
 ****************************************************************************/

void lv_fs_interface_init(void)
{
  /* Add a simple drive to open images */

  lv_fs_drv_t fs_drv; /* A driver descriptor */

  lv_fs_drv_init(&fs_drv);

  /* Set up fields... */

  fs_drv.file_size = sizeof(file_t);
  fs_drv.letter = LV_FS_LETTER;
  fs_drv.open_cb = fs_open;
  fs_drv.close_cb = fs_close;
  fs_drv.read_cb = fs_read;
  fs_drv.write_cb = fs_write;
  fs_drv.seek_cb = fs_seek;
  fs_drv.tell_cb = fs_tell;
  fs_drv.free_space_cb = fs_free;
  fs_drv.size_cb = fs_size;
  fs_drv.remove_cb = fs_remove;
  fs_drv.rename_cb = fs_rename;
  fs_drv.trunc_cb = fs_trunc;

  fs_drv.rddir_size = sizeof(dir_t);
  fs_drv.dir_close_cb = fs_dir_close;
  fs_drv.dir_open_cb = fs_dir_open;
  fs_drv.dir_read_cb = fs_dir_read;

  lv_fs_drv_register(&fs_drv);
}