VFSEntry.h

/*
 *  Copyright (C) 2013 Arne Morten Kvarving
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "FileItem.h"
#include "addons/binary-addons/AddonDll.h"
#include "addons/binary-addons/AddonInstanceHandler.h"
#include "addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h"
#include "filesystem/IDirectory.h"
#include "filesystem/IFile.h"
#include "filesystem/IFileDirectory.h"

#include <utility>

namespace ADDON
{
struct AddonEvent;

class CVFSEntry;
typedef std::shared_ptr<CVFSEntry> VFSEntryPtr;

class CVFSAddonCache : public CAddonDllInformer
{
public:
  virtual ~CVFSAddonCache();
  void Init();
  void Deinit();
  const std::vector<VFSEntryPtr> GetAddonInstances();
  VFSEntryPtr GetAddonInstance(const std::string& strId);

protected:
  void Update(const std::string& id);
  void OnEvent(const AddonEvent& event);
  bool IsInUse(const std::string& id) override;

  CCriticalSection m_critSection;
  std::vector<VFSEntryPtr> m_addonsInstances;
};

  class CVFSEntry : public IAddonInstanceHandler
  {
  public:
    struct ProtocolInfo
    {
      bool supportPath;      
      bool supportUsername;  
      bool supportPassword;  
      bool supportPort;      
      bool supportBrowsing;  
      bool supportWrite;     
      int defaultPort;       
      std::string type;      
      int label;             

      ProtocolInfo(const AddonInfoPtr& addonInfo);
    };

    explicit CVFSEntry(const AddonInfoPtr& addonInfo);
    ~CVFSEntry() override;

    // Things that MUST be supplied by the child classes
    void* Open(const CURL& url);
    void* OpenForWrite(const CURL& url, bool bOverWrite);
    bool Exists(const CURL& url);
    int Stat(const CURL& url, struct __stat64* buffer);
    ssize_t Read(void* ctx, void* lpBuf, size_t uiBufSize);
    ssize_t Write(void* ctx, const void* lpBuf, size_t uiBufSize);
    int64_t Seek(void* ctx, int64_t iFilePosition, int iWhence = SEEK_SET);
    int Truncate(void* ctx, int64_t size);
    void Close(void* ctx);
    int64_t GetPosition(void* ctx);
    int64_t GetLength(void* ctx);
    int GetChunkSize(void* ctx);
    int IoControl(void* ctx, XFILE::EIoControl request, void* param);
    bool Delete(const CURL& url);
    bool Rename(const CURL& url, const CURL& url2);

    bool GetDirectory(const CURL& url, CFileItemList& items, void* ctx);
    bool DirectoryExists(const CURL& url);
    bool RemoveDirectory(const CURL& url);
    bool CreateDirectory(const CURL& url);
    void ClearOutIdle();
    void DisconnectAll();

    bool ContainsFiles(const CURL& url, CFileItemList& items);

    const std::string& GetProtocols() const { return m_protocols; }
    const std::string& GetExtensions() const { return m_extensions; }
    bool HasFiles() const { return m_files; }
    bool HasDirectories() const { return m_directories; }
    bool HasFileDirectories() const { return m_filedirectories; }
    const std::string& GetZeroconfType() const { return m_zeroconf; }
    const ProtocolInfo& GetProtocolInfo() const { return m_protocolInfo; }
  protected:
    std::string m_protocols;  
    std::string m_extensions; 
    std::string m_zeroconf;   
    bool m_files;             
    bool m_directories;       
    bool m_filedirectories;   
    ProtocolInfo m_protocolInfo; 
  };

  class CVFSEntryIFileWrapper : public XFILE::IFile
  {
  public:
    explicit CVFSEntryIFileWrapper(VFSEntryPtr ptr);

    ~CVFSEntryIFileWrapper() override;

    bool Open(const CURL& url) override;

    bool OpenForWrite(const CURL& url, bool bOverWrite) override;

    bool Exists(const CURL& url) override;

    int  Stat(const CURL& url, struct __stat64* buffer) override;

    ssize_t Read(void* lpBuf, size_t uiBufSize) override;

    ssize_t Write(const void* lpBuf, size_t uiBufSize) override;

    int64_t Seek(int64_t iFilePosition, int whence = SEEK_SET) override;

    int Truncate(int64_t size) override;

    void Close() override;

    int64_t GetPosition() override;

    int64_t GetLength() override;

    int GetChunkSize() override;

    int IoControl(XFILE::EIoControl request, void* param) override;

    bool Delete(const CURL& url) override;

    bool Rename(const CURL& url, const CURL& url2) override;
  protected:
    void* m_context; 
    VFSEntryPtr m_addon; 
  };

  class CVFSEntryIDirectoryWrapper : public XFILE::IDirectory
  {
  public:
    explicit CVFSEntryIDirectoryWrapper(VFSEntryPtr ptr);

    ~CVFSEntryIDirectoryWrapper() override = default;

    bool GetDirectory(const CURL& url, CFileItemList& items) override;

    bool Exists(const CURL& url) override;

    bool Remove(const CURL& url) override;

    bool Create(const CURL& url) override;

    static bool DoGetKeyboardInput(void* context, const char* heading,
                                   char** input, bool hidden_input);

    bool GetKeyboardInput2(const char* heading, char** input, bool hidden_input);

    static void DoSetErrorDialog(void* ctx, const char* heading,
                                 const char* line1, const char* line2,
                                 const char* line3);

    void SetErrorDialog2(const char* heading, const char* line1,
                         const char* line2, const char* line3);

    static void DoRequireAuthentication(void* ctx, const char* url);

    void RequireAuthentication2(const CURL& url);
  protected:
    VFSEntryPtr m_addon; 
  };

  class CVFSEntryIFileDirectoryWrapper : public XFILE::IFileDirectory,
                                         public CVFSEntryIDirectoryWrapper
  {
  public:
    explicit CVFSEntryIFileDirectoryWrapper(VFSEntryPtr ptr)
      : CVFSEntryIDirectoryWrapper(std::move(ptr))
    {
    }

    ~CVFSEntryIFileDirectoryWrapper() override = default;

    bool ContainsFiles(const CURL& url) override
    {
      return m_addon->ContainsFiles(url, m_items);
    }

    bool GetDirectory(const CURL& url, CFileItemList& items) override
    {
      return CVFSEntryIDirectoryWrapper::GetDirectory(url, items);
    }

    bool Exists(const CURL& url) override
    {
      return CVFSEntryIDirectoryWrapper::Exists(url);
    }

    bool Remove(const CURL& url) override
    {
      return CVFSEntryIDirectoryWrapper::Remove(url);
    }

    bool Create(const CURL& url) override
    {
      return CVFSEntryIDirectoryWrapper::Create(url);
    }

    CFileItemList m_items; 
  };

} /*namespace ADDON*/