PluginManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "PluginDescriptor.h"
#include "Interfaces/IPluginManager.h"
 
struct FProjectDescriptor;
class FJsonObject;
 
class FPlugin final : public IPlugin
{
public:
    FString Name;
 
    FString FileName;
 
    TArray<FString> PluginExtensionFileNameList;
 
    FPluginDescriptor Descriptor;
 
    EPluginType Type;
 
    bool bEnabled : 1;
 
    bool bIsMounted : 1;
 
    uint8 ExplicitlyLoadedLocalizationDataMountedRefCount = 0;
 
    FPlugin(const FString &FileName, const FPluginDescriptor& InDescriptor, EPluginType InType);
 
    virtual ~FPlugin();
 
    /* IPlugin interface */
    virtual const FString& GetName() const override
    {
        return Name;
    }
 
    virtual const FString& GetFriendlyName() const override
    {
        return GetDescriptor().FriendlyName.IsEmpty() ? GetName() : GetDescriptor().FriendlyName;
    }
 
    virtual const FString& GetDescriptorFileName() const override
    {
        return FileName;
    }
 
    virtual FString GetBaseDir() const override;
    virtual TArray<FString> GetExtensionBaseDirs() const override;
    virtual FString GetContentDir() const override;
    virtual FString GetMountedAssetPath() const override;
 
    virtual bool IsEnabled() const override
    {
        return bEnabled;
    }
 
    virtual bool IsEnabledByDefault(bool bAllowEnginePluginsEnabledByDefault) const override;
 
    virtual bool IsMounted() const override
    {
        return bIsMounted;
    }
 
    virtual bool IsHidden() const override
    {
        return Descriptor.bIsHidden;
    }
 
    virtual bool CanContainContent() const override
    {
        return Descriptor.bCanContainContent;
    }
 
    virtual bool CanContainVerse() const override
    {
        return Descriptor.bCanContainVerse;
    }
 
    virtual const FString& GetVersePath() const override
    {
        return Descriptor.VersePath;
    }
 
    virtual TOptional<uint32> GetVerseVersion() const override
    {
        return Descriptor.VerseVersion;
    }
 
    virtual const FString& GetDeprecatedEngineVersion() const override
    {
        return Descriptor.DeprecatedEngineVersion;
    }
        
    virtual bool IsSceneGraphEnabled() const override
    {
        return Descriptor.bEnableSceneGraph;
    }
 
    virtual EPluginType GetType() const override
    {
        return Type;
    }
 
    virtual EPluginLoadedFrom GetLoadedFrom() const override;
    virtual const FPluginDescriptor& GetDescriptor() const override;
    virtual bool UpdateDescriptor(const FPluginDescriptor& NewDescriptor, FText& OutFailReason) override;
#if WITH_EDITOR
    virtual const TSharedPtr<FJsonObject>& GetDescriptorJson() override;
#endif // WITH_EDITOR
 
    void SetIsMounted(bool bInIsMounted) { bIsMounted = bInIsMounted; }
};
 
class FPluginManager final : public IPluginManager
{
public:
    FPluginManager();
 
    ~FPluginManager();
 
    virtual void RefreshPluginsList() override;
    virtual bool AddToPluginsList(const FString& PluginFilename, FText* OutFailReason = nullptr) override;
    virtual bool RemoveFromPluginsList(const FString& PluginFilename, FText* OutFailReason = nullptr) override;
    virtual bool LoadModulesForEnabledPlugins( const ELoadingPhase::Type LoadingPhase ) override;
    virtual FLoadingModulesForPhaseEvent& OnLoadingPhaseComplete() override;
    virtual ELoadingPhase::Type GetLastCompletedLoadingPhase() const override;
    virtual void GetLocalizationPathsForEnabledPlugins( TArray<FString>& OutLocResPaths ) override;
    virtual void SetRegisterMountPointDelegate( const FRegisterMountPointDelegate& Delegate ) override;
    virtual void SetUnRegisterMountPointDelegate( const FRegisterMountPointDelegate& Delegate ) override;
    virtual bool AreRequiredPluginsAvailable() override;
    virtual FGetExplanationForUnavailablePackageWithPluginInfoDelegate& GetExplanationForUnavailablePackageWithPluginInfoDelegate() override;
 
    virtual void SuppressPluginUnloadGC() override;
    virtual void ResumePluginUnloadGC() override;
 
#if !IS_MONOLITHIC
    virtual bool CheckModuleCompatibility(TArray<FString>& OutIncompatibleModules, TArray<FString>& OutIncompatibleEngineModules) override;
#endif
    virtual TSharedPtr<IPlugin> FindPlugin(const FStringView Name) override;
    virtual TSharedPtr<IPlugin> FindPlugin(const ANSICHAR* Name) override
    {
        FString NameString(Name);
        return FindPlugin(FStringView(NameString));
    }
    virtual TSharedPtr<IPlugin> FindPluginFromPath(const FString& PluginPath) override;
    virtual TSharedPtr<IPlugin> FindPluginFromDescriptor(const FPluginReferenceDescriptor& PluginDesc) override;
 
    virtual TSharedPtr<IPlugin> FindEnabledPlugin(const FStringView Name) override;
    virtual TSharedPtr<IPlugin> FindEnabledPlugin(const ANSICHAR* Name) override
    {
        FString NameString(Name);
        return FindEnabledPlugin(FStringView(NameString));
    }
    virtual TSharedPtr<IPlugin> FindEnabledPluginFromPath(const FString& PluginPath) override;
    virtual TSharedPtr<IPlugin> FindEnabledPluginFromDescriptor(const FPluginReferenceDescriptor& PluginDesc) override;
 
    virtual bool CanEnablePluginInCurrentTarget(const FStringView Name) override;
    virtual bool CanEnablePluginInCurrentTarget(const ANSICHAR* Name) override
    {
        FString NameString(Name);
        return CanEnablePluginInCurrentTarget(FStringView(NameString));
    }
 
    virtual void FindPluginsUnderDirectory(const FString& Directory, TArray<FString>& OutPluginFilePaths) override;
 
    virtual TArray<TSharedRef<IPlugin>> GetEnabledPlugins() override;
    virtual TArray<TSharedRef<IPlugin>> GetEnabledPluginsWithContent() const override;
    virtual TArray<TSharedRef<IPlugin>> GetEnabledPluginsWithVerse() const override;
    virtual TArray<TSharedRef<IPlugin>> GetEnabledPluginsWithContentOrVerse() const override;
    virtual TArray<TSharedRef<IPlugin>> GetDiscoveredPlugins() override;
 
    virtual const TSet<FString>& GetPluginsEnabledAtStartup() const override;
#if WITH_EDITOR
    virtual const TSet<FString>& GetBuiltInPluginNames() const override;
    virtual TSharedPtr<IPlugin> GetModuleOwnerPlugin(FName ModuleName) const override;
#endif //WITH_EDITOR
 
    virtual bool AddPluginSearchPath(const FString& ExtraDiscoveryPath, bool bRefresh = true) override;
    virtual bool RemovePluginSearchPath(const FString& PathToRemove, bool bRefresh = true) override;
    virtual const TSet<FString>& GetAdditionalPluginSearchPaths() const override;
    virtual void GetExternalPluginSources(TSet<FExternalPluginPath>& OutPluginSources) const override;
    virtual TArray<TSharedRef<IPlugin>> GetPluginsWithPakFile() const override;
    virtual FNewPluginMountedEvent& OnNewPluginCreated() override;
    virtual FNewPluginMountedEvent& OnNewPluginMounted() override;
    virtual FNewPluginMountedEvent& OnNewPluginContentMounted() override;
    virtual FNewPluginMountedEvent& OnPluginEdited() override;
    virtual FNewPluginMountedEvent& OnPluginUnmounted() override;
    virtual void MountNewlyCreatedPlugin(const FString& PluginName) override;
    virtual bool MountExplicitlyLoadedPlugin(const FString& PluginName, ELoadingPhase::Type MaxLoadingPhase = ELoadingPhase::Max) override;
    virtual bool MountExplicitlyLoadedPlugin_FromFileName(const FString& PluginFileName) override;
    virtual bool MountExplicitlyLoadedPlugin_FromDescriptor(const FPluginReferenceDescriptor& PluginDescriptor) override;
    virtual bool MountExplicitlyLoadedPluginLocalizationData(const FString& PluginName, TUniqueFunction<void(bool bLoadedLocalization, const FString& PluginName)>&& Notification = nullptr) override;
    virtual bool UnmountExplicitlyLoadedPluginLocalizationData(const FString& PluginName, TUniqueFunction<void(bool bUnloadedLocalization, const FString& PluginName)>&& Notification = nullptr) override;
    virtual bool UnmountExplicitlyLoadedPlugin(const FString& PluginName, FText* OutReason) override { return UnmountExplicitlyLoadedPlugin(PluginName, OutReason, true); }
    virtual bool UnmountExplicitlyLoadedPlugin(const FString& PluginName, FText* OutReason, bool bAllowUnloadCode) override;
    virtual bool GetPluginDependencies(const FString& PluginName, TArray<FPluginReferenceDescriptor>& PluginDependencies) override;
    virtual bool GetPluginDependencies_FromFileName(const FString& PluginFileName, TArray<FPluginReferenceDescriptor>& PluginDependencies) override;
    virtual bool GetPluginDependencies_FromDescriptor(const FPluginReferenceDescriptor& PluginDescriptor, TArray<FPluginReferenceDescriptor>& PluginDependencies) override;
    virtual FName PackageNameFromModuleName(FName ModuleName) override;
    virtual void EnumerateVersePathMountPoints(const UE::Core::FVersePath& VersePath, TFunctionRef<bool(FStringView /*MountedAssetPath*/, FStringView /*LeafPath*/)> Callback) override;
    virtual bool RequiresTempTargetForCodePlugin(const FProjectDescriptor* ProjectDescriptor, const FString& Platform, EBuildConfiguration Configuration, EBuildTargetType TargetType, FText& OutReason) override;
 
    virtual void SetBinariesRootDirectories(const FString& EngineBinariesRootDir, const FString& ProjectBinariesRootDir) override;
    virtual void SetPreloadBinaries() override;
    virtual bool GetPreloadBinaries() override;
 
    void GetExplanationForUnavailablePackage(const FName& UnavailablePackageName, FStringBuilderBase& InOutExplanation) override;
 
private:
    using FDiscoveredPluginMap = TMap<FString, TArray<TSharedRef<FPlugin>>>;
 
    struct FConfigurePluginResultInfo;
 
    void DiscoverAllPlugins();
    
    struct FPluginDiscoveryContext
    {
        // Set of all the plugins which have been enabled
        TMap<FString, FPlugin*> EnabledPlugins;
 
        // Keep a set of all the plugin names that have been configured. We read configuration data from different places, but only configure a plugin from the first place that it's referenced.
        TSet<FString> ConfiguredPluginNames;
 
        // Keep the list of newly available localization targets
        TArray<FString> AdditionalLocResPaths;
 
#if UE_BUILD_SHIPPING
        // const to ensure it to stays empty
        const TSet<FString> AllowedOptionalDependencies;
#else
        // Set of all the plugin names that are allowed to be enabled for a plugin with optional dependencies. Only read in Editor
        TSet<FString> AllowedOptionalDependencies;
#endif
 
    };
    void FindCompileTimePlugins(FPluginDiscoveryContext& Context);
    bool FindCommandLinePlugins(FPluginDiscoveryContext& Context);
    bool FindTargetPlugins(FPluginDiscoveryContext& Context);
    bool FindProgramPlugins(FPluginDiscoveryContext& Context);
    void MarkEnabledPlugins(FPluginDiscoveryContext& Context);
    void ProcessEnabledPlugins(FPluginDiscoveryContext& Context);
    void MountContentPlugins(FPluginDiscoveryContext& Context);
 
    static void ReadAllPlugins(FDiscoveredPluginMap& Plugins, const TSet<FString>& ExtraSearchPaths,
        TArray<FString>* OutPluginSources=nullptr);
 
    static void ReadPluginsInDirectory(const FString& PluginsDirectory, const EPluginType Type, FDiscoveredPluginMap& Plugins, TArray<TSharedRef<FPlugin>>& ChildPlugins);
 
    static void CreatePluginObject(const FString& FileName, const FPluginDescriptor& Descriptor, const EPluginType Type, FDiscoveredPluginMap& Plugins, TArray<TSharedRef<FPlugin>>& ChildPlugins);
 
    static void FindPluginsInDirectory(const FString& PluginsDirectory, TArray<FString>& FileNames, IPlatformFile& PlatformFile);
 
    static void FindPluginManifestsInDirectory(const FString& PluginManifestDirectory, TArray<FString>& FileNames);
 
    static bool GetCodePluginsForProject(const FProjectDescriptor* ProjectDescriptor, const FString& Platform, EBuildConfiguration Configuration, EBuildTargetType TargetType, FDiscoveredPluginMap& AllPlugins, TSet<FString>& CodePluginNames, const TSet<FString>& AllowedOptionalPluginReferences, FConfigurePluginResultInfo& OutResultInfo);
 
    bool ConfigureEnabledPlugins();
 
    bool ConfigureEnabledPluginForCurrentTarget(const FPluginReferenceDescriptor& FirstReference,
        TMap<FString, FPlugin*>& EnabledPlugins, FStringView SourceOfPluginRequest, const TSet<FString>& AllowedOptionalDependencies);
 
    static bool ConfigureEnabledPluginForTarget(const FPluginReferenceDescriptor& FirstReference, const FProjectDescriptor* ProjectDescriptor, const FString& TargetName, const FString& Platform, EBuildConfiguration Configuration, EBuildTargetType TargetType, bool bLoadPluginsForTargetPlatforms, FDiscoveredPluginMap& AllPlugins, TMap<FString, FPlugin*>& EnabledPlugins, const TSet<FString>& AllowedOptionalDependencies, FConfigurePluginResultInfo& OutResultInfo);
 
    static bool PromptToDownloadPlugin(const FString& PluginName, const FString& MarketplaceURL);
 
    static bool PromptToDisableSealedPlugin(const FString& PluginName, const FString& SealedPluginName);
 
    static bool PromptToDisableDisalowedPlugin(const FString& PluginName, const FString& DisallowedPluginName);
 
    static bool PromptToDisableMissingPlugin(const FString& PluginName, const FString& MissingPluginName);
 
    static bool PromptToDisableIncompatiblePlugin(const FString& PluginName, const FString& IncompatiblePluginName);
 
    static bool PromptToDisablePlugin(const FText& Caption, const FText& Message, const FString& PluginName);
 
    static bool IsPluginCompatible(const FPlugin& Plugin);
 
    static bool PromptToLoadIncompatiblePlugin(const FPlugin& Plugin);
 
    bool TryLoadModulesForPlugin(const FPlugin& Plugin, const ELoadingPhase::Type LoadingPhase) const;
 
    bool TryUnloadModulesForPlugin(const FPlugin& Plugin, const ELoadingPhase::Type LoadingPhase, FText* OutFailureMessage = nullptr, bool bSkipUnload = false, bool bAllowUnloadCode = true) const;
 
    TSharedPtr<FPlugin> FindPluginInstance(const FString& Name);
 
    bool TryMountExplicitlyLoadedPluginVersion(TSharedRef<FPlugin>* AllPlugins_PluginPtr);
 
    void MountPluginFromExternalSource(const TSharedRef<FPlugin>& Plugin, ELoadingPhase::Type MaxLoadingPhase = ELoadingPhase::Max);
 
#if WITH_EDITOR
    void AddToModuleNameToPluginMap(const TSharedRef<FPlugin>& Plugin);
    void RemoveFromModuleNameToPluginMap(const TSharedRef<FPlugin>& Plugin);
#endif //if WITH_EDITOR
 
private:
    FDiscoveredPluginMap AllPlugins;
 
    TSet<FString> PluginsToConfigure;
 
    TSet<FString> PluginsEnabledForTarget;
 
    TSet<FString> PluginsEnabledAtStartup;
 
#if WITH_EDITOR
    TSet<FString> BuiltInPluginNames;
 
    TMap<FName, TSharedRef<IPlugin>> ModuleNameToPluginMap;
#endif //if WITH_EDITOR
 
    TArray<TSharedRef<IPlugin>> PluginsWithPakFile;
 
    FRegisterMountPointDelegate RegisterMountPointDelegate;
 
    FRegisterMountPointDelegate UnRegisterMountPointDelegate;
 
    bool bHaveAllRequiredPlugins = false;
 
    bool bAllPluginsEnabledViaCommandLine = false;
 
    bool bPreloadedBinaries = false;
 
    TSet<FExternalPluginPath> ExternalPluginSources;
 
    TSet<FString> PluginDiscoveryPaths;
 
    FNewPluginMountedEvent NewPluginCreatedEvent;
    FNewPluginMountedEvent NewPluginMountedEvent;
    FNewPluginMountedEvent NewPluginContentMountedEvent;
    FNewPluginMountedEvent PluginEditedEvent;
    FNewPluginMountedEvent PluginUnmountedEvent;
 
    FLoadingModulesForPhaseEvent LoadingPhaseCompleteEvent;
 
    ELoadingPhase::Type LastCompletedLoadingPhase = ELoadingPhase::None;
 
    FString EngineBinariesRootDir;
    FString ProjectBinariesRootDir;
};