ModuleManager.h

#pragma once
#include "DLLInfo.h"
#if defined(_WIN32)
// On Windows, NDEVR commands use the stdcall convention
#define NDEVRAPI_ATTR
#define NDEVRAPI_CALL __stdcall
#define NDEVRAPI_PTR  NDEVRAPI_CALL
#elif !QT_BUILD && defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
#error "NDEVR isn't supported for the 'armeabi' NDK ABI"
#elif !QT_BUILD && defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
// On Android 32-bit ARM targets, NDEVR functions use the "hardfloat"
// calling convention, i.e. float parameters are passed in registers. This
// is true even if the rest of the application passes floats on the stack,
// as it does by default when compiling for the armeabi-v7a NDK ABI.
#define NDEVRAPI_ATTR __attribute__((pcs("aapcs-vfp")))
#define NDEVRAPI_CALL
#define NDEVRAPI_PTR  VKAPI_ATTR
#else
// On other platforms, use the default calling convention
#define NDEVRAPI_ATTR
#define NDEVRAPI_CALL
#define NDEVRAPI_PTR
#endif
#include <NDEVR/SoftwareService.h>
#include <NDEVR/String.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/File.h>
#include <NDEVR/TranslatedString.h>
typedef void (NDEVRAPI_PTR* PFN_NDEVRVoidFunction)(void);
namespace NDEVR
{
    struct Module;
    class QTModelManager;
    class QTWindowManager;
    class Exception;
    class ModuleResourceManager;
}
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_InitializeForNDEVR)(Module& module);//InitializeForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupRegistrationForNDEVR)();//SetupRegistrationForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupMetatypesForNDEVR)();//SetupMetatypesForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_RegisterUserSettingsForNDEVR)();//RegisterUserSettingsForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupFileStructureForNDEVR)();//SetupFileStructureForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupFactoriesForNDEVR)();//SetupFileStructureForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetUpdateCheckerForNDEVR)();//SetupFileStructureForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupManualsForNDEVR)();//SetupManualsForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupUIThemesForNDEVR)();//SetupUIThemesForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_FactoryResetNDEVR)();//FactoryReset
typedef void(*PFN_SetupUIForNDEVR)(QTModelManager* model_manager, QTWindowManager* window_manager);
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_DefineModuleResourcesForNDEVR)(ModuleResourceManager* resources);
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_OnNDEVRExit)();//
 
namespace NDEVR
{
    struct NDEVR_BASE_API Module : public SoftwareService
    {
        enum ModuleType : uint04
        {
              e_application         
            , e_utility             
            , e_library_dependency  
            , e_undefined           
        };
        mutable Dictionary<String, void*> loaded_functions; 
        String name;                    
        String version;                 
        File library;                   
        TranslatedString display_name;  
        String icon;                    
        TranslatedString description;   
        String license_agreement;       
        String website;                 
        String activation_id;           
        bool allow_user_toggle_active = false; 
        bool allow_deferred_loading = false; 
        bool is_active = true;          
        ModuleType type = ModuleType::e_undefined; 

        Module();

        Module(const StringView& name);

        Module(const StringView& name, const File& library);

        bool isValid() const;

        void initialize();

        void callModuleFunction(const StringView& function) const;

        void callModuleFunction(const StringView& function, QTModelManager* model_manager, QTWindowManager* window_manager) const;

        void defineModuleResources(ModuleResourceManager* resources) const;
    protected:
        void* module_ptr = nullptr; 
    };
    
    class NDEVR_BASE_API ModuleManager : public SoftwareServiceManager
    {
    public:
        static File MainModuleFolder();

        static void SetMainProgramModuleName(const StringView& name);

        static void FindModules(const File& module_folder);

        static void FindModules(const Buffer<String>& module_list, const File& module_folder);

        static void FindModules(const File& module_list, const File& module_folder);

        static void AddModule(const File& module_file);

        static void CallModuleFunction(const StringView& function);

        static void CallModuleFunction(const StringView& function, QTModelManager* model_manager, QTWindowManager* window_manager);

        static void DefineModuleResources(const StringView& module_name, ModuleResourceManager* resources);

        static void AddModule(const Module& module);

        static void SaveModuleSettings();

        static void SetupModuleRegistration();

        static void OnExit();

        static bool HasActiveModule(const StringView& module_name);

        static bool IsModuleActive(const StringView& module_name);

        static void ReadModuleSettings();

        static void SetErrorCallback(const std::function<void(const Exception& e)>& callback);

        static void* LoadDynamicLibrary(const StringView& library);

        static void* LoadFromDynamicLibrary(void* library, const StringView& function);

        static void* LoadFromDynamicLibrary(const StringView& library, const StringView& function);

        static void SetInitialized(QTModelManager* model_manager, QTWindowManager* window_manager);

        static bool IsInitialized();
 
        static Buffer<String> ordered_modules;                          
        static Dictionary<String, Module> modules;                      
        static Dictionary<String, bool> module_active_list;             
        static Dictionary<String, Dictionary<String, void*>> functions; 
        static String main_program_module_name;                         
    private:
        static bool s_initialized;                                      
        static QTModelManager* s_model_manager;                         
        static QTWindowManager* s_window_manager;                       
    };
    template class NDEVR_BASE_API StringStream<Module::ModuleType>;
}