plugin_loader.h

/***************************************************************************
 *
 *
 * Project:  OpenCPN
 * Purpose:  PlugIn Manager Object
 * Author:   David Register
 *
 ***************************************************************************
 *   Copyright (C) 2010-2023 by David S. Register                          *
 *   Copyright (C) 2023 Alec Leamas
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,  USA.         *
 **************************************************************************/
 
#ifndef PLUGIN_LOADER_H_GUARD
#define PLUGIN_LOADER_H_GUARD
 
#include <functional>
 
#include <wx/wx.h>
#include <wx/bitmap.h>
#include <wx/dynarray.h>
#include <wx/dynlib.h>
 
#include "config.h"
 
#include "model/catalog_parser.h"
#include "model/plugin_blacklist.h"
#include "model/semantic_vers.h"
#include "observable_evtvar.h"
#include "ocpn_plugin.h"
 
enum class PluginStatus {
  System,     
  Managed,    
  Unmanaged,  
  Ghost,      
  Unknown,
  LegacyUpdateAvailable,
  ManagedInstallAvailable,
  ManagedInstalledUpdateAvailable,
  ManagedInstalledCurrentVersion,
  ManagedInstalledDowngradeAvailable,
  PendingListRemoval
};
 
class PlugInContainer;  // forward
class PlugInData;       // forward
 
class PlugInData {
public:
  explicit PlugInData(const PluginMetadata& md);
 
  PlugInData();
 
  bool m_has_setup_options;          
  bool m_enabled;
  bool m_init_state;
  bool m_toolbox_panel;
  int m_cap_flag;                    
  wxString m_plugin_file;            
  wxString m_plugin_filename;        
  wxDateTime m_plugin_modification;  
  wxString m_common_name;            
  wxString m_short_description;
  wxString m_long_description;
  int m_api_version;
  int m_version_major;
  int m_version_minor;
  PluginStatus m_status;
  PluginMetadata m_managed_metadata;
  wxBitmap m_bitmap;
  wxString m_version_str;          
  std::string m_manifest_version;  
 
  std::string Key() const;
};
 
class PlugInContainer : public PlugInData {
public:
  PlugInContainer();
 
  ~PlugInContainer() = default;
 
  opencpn_plugin* m_pplugin;
  wxDynamicLibrary m_library;
  destroy_t* m_destroy_fn;
};
 
class LoadError {
public:
  enum class Type {
    Unloadable,  //<! wrong magic, wrong type of binary...
    Unreadable,
    Incompatible,
    NoCreate,   //<! Missing linkage (is this a plugin?)
    NoDestroy,  //<! Missing linkage (is this a plugin?)
    Blacklisted
  } type;
  const std::string lib_path;  //<! Complete path to failing library
  //<! As determined from plugin API
  const SemanticVersion plugin_version;  //<! As determined from plugin API
 
  LoadError(Type t, const std::string& l, SemanticVersion pv)
      : type(t), lib_path(l), plugin_version(pv) {}
 
  LoadError(Type t, std::string l)
      : type(t), lib_path(std::move(l)), plugin_version(SemanticVersion()) {}
};
 
//    Declare an array of PlugIn Containers
WX_DEFINE_ARRAY_PTR(PlugInContainer*, ArrayOfPlugIns);
 
class PluginLoader {
public:
  static PluginLoader* getInstance();
  virtual ~PluginLoader() = default;
  static void UpdatePlugin(PlugInContainer* plugin, const PluginMetadata& md);
 
  static std::string GetPluginVersion(
      const PlugInData pd,
      std::function<const PluginMetadata(const std::string&)> get_metadata);
 
  static PluginMetadata MetadataByName(const std::string& name);
 
  EventVar evt_blacklisted_plugin;
 
  EventVar evt_load_directory;
  EventVar evt_load_plugin;
  EventVar evt_plugin_unload;
  EventVar evt_pluglist_change;
  EventVar evt_unreadable_plugin;
 
  EventVar evt_deactivate_plugin;
 
  EventVar evt_update_chart_types;
 
  EventVar evt_plugin_loadall_finalize;
 
  EventVar evt_version_incompatible_plugin;
 
  bool LoadAllPlugIns(bool enabled_plugins, bool keep_orphans = false);
 
  const wxBitmap* GetPluginDefaultIcon();
  void SetPluginDefaultIcon(const wxBitmap* bitmap);
 
  void SetOnDeactivateCb(std::function<void(const PlugInContainer*)> cb) {
    m_on_deactivate_cb = cb;
  }
  void ShowPreferencesDialog(const PlugInData& pd, wxWindow* parent);
 
  void NotifySetupOptionsPlugin(const PlugInData* pic);
 
  void RemovePlugin(const PlugInData& pd);
 
  void SortPlugins(int (*cmp_func)(PlugInContainer**, PlugInContainer**));
 
  bool UnLoadPlugIn(size_t ix);
 
  bool UnLoadAllPlugIns();
  bool DeactivateAllPlugIns();
  bool DeactivatePlugIn(PlugInContainer* pic);
  bool DeactivatePlugIn(const PlugInData& pic);
  bool UpdatePlugIns();
  void UpdateManagedPlugins(bool keep_orphans);
  PlugInContainer* LoadPlugIn(const wxString& plugin_file);
  PlugInContainer* LoadPlugIn(const wxString& plugin_file,
                              PlugInContainer* pic);
 
  const ArrayOfPlugIns* GetPlugInArray() { return &plugin_array; }
  bool IsPlugInAvailable(const wxString& commonName);
  bool CheckPluginCompatibility(const wxString& plugin_file);
 
  void SetEnabled(const wxString& common_name, bool enabled);
 
  void SetToolboxPanel(const wxString& common_name, bool value);
 
private:
  PluginLoader();
  bool LoadPlugInDirectory(const wxString& plugin_dir, bool load_enabled);
  bool LoadPluginCandidate(const wxString& file_name, bool load_enabled);
  std::unique_ptr<AbstractBlacklist> m_blacklist;
  ArrayOfPlugIns plugin_array;
  wxString m_last_error_string;
  wxString m_plugin_location;
 
#ifdef __WXMSW__
  wxString m_module_name;
  bool m_found_wxwidgets;
#endif
 
  const wxBitmap* m_default_plugin_icon;
  std::function<void(const PlugInContainer*)> m_on_deactivate_cb;
 
  std::vector<LoadError> load_errors;
};
 
#endif  // PLUGIN_LOADER_H_GUARD