AddonManager.h

Go to the documentation of this file.

#pragma once
 
#if EDITOR
 
#include "../ProjectSelect/TemplateData.h"
#include <string>
#include <vector>
 
class AddonManager
{
public:
    static void Create();
    static void Destroy();
    static AddonManager* Get();
 
    std::string GetAddonCacheDirectory();
 
    std::string GetSettingsPath();
 
    std::string GetInstalledAddonsPath();
 
    // Repository management
    void LoadSettings();
    void SaveSettings();
    void AddRepository(const std::string& url);
    void RemoveRepository(const std::string& url);
    const std::vector<AddonRepository>& GetRepositories() const { return mRepositories; }
 
    // Addon discovery
    void RefreshAllRepositories();
    void RefreshRepository(const std::string& url);
    // True once RefreshAllRepositories has run this session. The dependency
    // resolver uses it to refresh lazily when a dependency lookup misses at
    // project load, before the Addons window has ever been opened.
    bool HasRefreshedRepositories() const { return mRepositoriesRefreshed; }
    const std::vector<Addon>& GetAvailableAddons() const { return mAvailableAddons; }
    const std::vector<AddonCategory>& GetCategories() const { return mCategories; }
 
    // Installation
    bool DownloadAddon(const Addon& addon, std::string& outError);
    // source (optional) is stamped onto the InstalledAddon record so update
    // checks and re-downloads know the repo/branch/commit the files came from.
    bool InstallAddon(const std::string& addonCachePath, const std::string& addonId, std::string& outError,
                      const AddonInstallSource* source = nullptr);
    // Dependencies declared by the most recently installed addon that are
    // still absent from Packages/ after auto-resolution. Empty on success.
    const std::vector<std::string>& GetLastInstallMissingDependencies() const { return mLastInstallMissingDeps; }
    // Deletes Packages/<id> and Intermediate/Plugins/<id>, drops the record.
    // Does not unload a native DLL or check dependents — the Addons window
    // handles both before calling this (see ProcessPendingUninstalls).
    bool UninstallAddon(const std::string& addonId);
 
    // Fetch an addon from an arbitrary URL (GitHub repo or direct .zip), unzip it,
    // and install into the current project's Packages/. Used by the dependency resolver.
    bool DownloadAndInstallFromUrl(const std::string& addonId,
                                   const std::string& url,
                                   const std::string& ref,
                                   std::string& outError);
 
    // Auto-resolve declared dependencies on install / project load.
    bool GetAutoResolveDependencies() const { return mAutoResolveDeps; }
    void SetAutoResolveDependencies(bool v) { mAutoResolveDeps = v; SaveSettings(); }
 
    // Tracking
    void LoadInstalledAddons();
    void SaveInstalledAddons();
    const std::vector<InstalledAddon>& GetInstalledAddons() const { return mInstalledAddons; }
    std::vector<InstalledAddon>& GetInstalledAddonsMutable() { return mInstalledAddons; }
    bool IsAddonInstalled(const std::string& addonId) const;
    const InstalledAddon* FindInstalled(const std::string& addonId) const;
    // True when GetUpdateStatus reports NewCommits or NewVersion.
    bool HasUpdate(const std::string& addonId) const;
    // Combines the registry version (secondary) with the branch head commit
    // recorded by the last CheckForUpdates (primary). See AddonUpdateStatus.
    AddonUpdateStatus GetUpdateStatus(const std::string& addonId) const;
    std::string GetInstalledVersion(const std::string& addonId) const;
 
    // Update checks. Synchronous network calls — run from the end-of-frame
    // dispatcher under EditorProgress, never from an ImGui draw.
    //
    // FetchLatestCommit resolves the newest commit on <branch> touching
    // <subPath> (empty = whole repo) through the GitHub API. Non-GitHub
    // hosts fail with an explanatory error.
    bool FetchLatestCommit(const std::string& repoUrl, const std::string& branch,
                           const std::string& subPath, std::string& outSha,
                           std::string& outDate, std::string& outError);
    // Refreshes the registry, then stamps mRemoteCommit / mUpdateCheckError
    // on every installed record that has a checkable source. Returns the
    // number of addons with an update available.
    int CheckForUpdates(std::string& outSummary);
    // Effective branch for downloads and update checks.
    static std::string GetAddonBranch(const Addon& addon);
    bool SetInstalledAddonNativeMode(const std::string& addonId, NativeAddonResolveMode mode);
    bool SyncNativeAddonBinary(const std::string& addonId, std::string& outError);
 
    // Find addon by ID
    const Addon* FindAddon(const std::string& addonId) const;
 
private:
    static AddonManager* sInstance;
    AddonManager();
    ~AddonManager();
 
    void EnsureCacheDirectory();
 
    bool FetchManifest(const std::string& url, const std::string& branch, bool& outFound);
 
    bool FetchRepositoryManifest(const std::string& url, AddonRepository& outRepo, const std::string& branch);
    bool FetchAddonMetadata(const std::string& repoUrl, const std::string& addonId, Addon& outAddon, const std::string& branch);
 
    bool MergeAddonIntoProject(const std::string& addonPath, std::string& outError);
 
    bool DownloadFile(const std::string& url, const std::string& destPath, std::string& outError);
 
    bool ExtractZip(const std::string& zipPath, const std::string& destDir, std::string& outError);
 
    std::string NormalizePath(const std::string& in);
 
    std::string ConvertToRawUrl(const std::string& gitHubUrl, const std::string& filePath, const std::string& branch);
 
    std::string ConvertToDownloadUrl(const std::string& gitHubUrl, const std::string& branch);
 
    std::string GetCurrentTimestamp();
 
    static bool ParseGitHubRepo(const std::string& url, std::string& outOwner, std::string& outRepo);
 
    std::vector<AddonRepository> mRepositories;
    std::vector<Addon> mAvailableAddons;
    std::vector<AddonCategory> mCategories;  // Registry categories from manifest.json
    std::vector<InstalledAddon> mInstalledAddons;
    bool mAutoResolveDeps = true;
    bool mRepositoriesRefreshed = false;
    std::vector<std::string> mLastInstallMissingDeps;
};
 
#endif