ExporterHelper.h

/*
 * GDevelop JS Platform
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "GDCore/IDE/CaptureOptions.h"
#include "GDCore/String.h"
namespace gd {
class Project;
class Layout;
class ExternalLayout;
class SerializerElement;
class AbstractFileSystem;
class ResourcesManager;
class SourceFileMetadata;
class WholeProjectDiagnosticReport;
class CaptureOptions;
class Screenshot;
}  // namespace gd
 
namespace gdjs {
 
struct PreviewExportOptions {
  PreviewExportOptions(gd::Project &project_, const gd::String &exportPath_)
      : project(project_),
        exportPath(exportPath_),
        useWindowMessageDebuggerClient(false),
        useMinimalDebuggerClient(false),
        nativeMobileApp(false),
        projectDataOnlyExport(false),
        fullLoadingScreen(false),
        isDevelopmentEnvironment(false),
        nonRuntimeScriptsCacheBurst(0),
        inAppTutorialMessageInPreview(""),
        inAppTutorialMessagePositionInPreview(""),
        fallbackAuthorId(""),
        fallbackAuthorUsername(""),
        playerId(""),
        playerUsername(""),
        playerToken(""),
        allowAuthenticationUsingIframeForPreview(false) {};
 
  PreviewExportOptions &UseWebsocketDebuggerClientWithServerAddress(
      const gd::String &address, const gd::String &port) {
    websocketDebuggerServerAddress = address;
    websocketDebuggerServerPort = port;
    return *this;
  }
 
  PreviewExportOptions &SetInAppTutorialMessageInPreview(
      const gd::String &message, const gd::String &position) {
    inAppTutorialMessageInPreview = message;
    inAppTutorialMessagePositionInPreview = position;
    return *this;
  }
 
  PreviewExportOptions &SetFallbackAuthor(const gd::String &id,
                                          const gd::String &username) {
    fallbackAuthorId = id;
    fallbackAuthorUsername = username;
    return *this;
  }
 
  PreviewExportOptions &SetAuthenticatedPlayer(const gd::String &id,
                                               const gd::String &username,
                                               const gd::String &token) {
    playerId = id;
    playerUsername = username;
    playerToken = token;
    return *this;
  }
 
  PreviewExportOptions &UseWindowMessageDebuggerClient() {
    useWindowMessageDebuggerClient = true;
    return *this;
  }
 
  PreviewExportOptions &UseMinimalDebuggerClient() {
    useMinimalDebuggerClient = true;
    return *this;
  }
 
  PreviewExportOptions &SetNativeMobileApp(bool enable) {
    nativeMobileApp = enable;
    return *this;
  }
 
  PreviewExportOptions &SetLayoutName(const gd::String &layoutName_) {
    layoutName = layoutName_;
    return *this;
  }
 
  PreviewExportOptions &SetExternalLayoutName(
      const gd::String &externalLayoutName_) {
    externalLayoutName = externalLayoutName_;
    return *this;
  }
 
  PreviewExportOptions &SetIncludeFileHash(const gd::String &includeFile,
                                           int hash) {
    includeFileHashes[includeFile] = hash;
    return *this;
  }
 
  PreviewExportOptions &SetProjectDataOnlyExport(bool enable) {
    projectDataOnlyExport = enable;
    return *this;
  }
 
  PreviewExportOptions &SetFullLoadingScreen(bool enable) {
    fullLoadingScreen = enable;
    return *this;
  }
 
  PreviewExportOptions &SetIsDevelopmentEnvironment(bool enable) {
    isDevelopmentEnvironment = enable;
    return *this;
  }
 
  PreviewExportOptions &SetNonRuntimeScriptsCacheBurst(unsigned int value) {
    nonRuntimeScriptsCacheBurst = value;
    return *this;
  }
 
  PreviewExportOptions &SetElectronRemoteRequirePath(
      const gd::String &electronRemoteRequirePath_) {
    electronRemoteRequirePath = electronRemoteRequirePath_;
    return *this;
  }
 
  PreviewExportOptions &SetGDevelopResourceToken(
      const gd::String &gdevelopResourceToken_) {
    gdevelopResourceToken = gdevelopResourceToken_;
    return *this;
  }
 
  PreviewExportOptions &SetAllowAuthenticationUsingIframeForPreview(
      bool allowAuthenticationUsingIframeForPreview_) {
    allowAuthenticationUsingIframeForPreview =
        allowAuthenticationUsingIframeForPreview_;
    return *this;
  }
 
  PreviewExportOptions &SetCrashReportUploadLevel(
      const gd::String &crashReportUploadLevel_) {
    crashReportUploadLevel = crashReportUploadLevel_;
    return *this;
  }
 
  PreviewExportOptions &SetPreviewContext(const gd::String &previewContext_) {
    previewContext = previewContext_;
    return *this;
  }
 
  PreviewExportOptions &SetGDevelopVersionWithHash(
      const gd::String &gdevelopVersionWithHash_) {
    gdevelopVersionWithHash = gdevelopVersionWithHash_;
    return *this;
  }
 
  PreviewExportOptions &SetProjectTemplateSlug(
      const gd::String &projectTemplateSlug_) {
    projectTemplateSlug = projectTemplateSlug_;
    return *this;
  }
 
  PreviewExportOptions &SetSourceGameId(const gd::String &sourceGameId_) {
    sourceGameId = sourceGameId_;
    return *this;
  }
 
  PreviewExportOptions &AddScreenshotCapture(int delayTimeInSeconds,
                                             const gd::String &signedUrl,
                                             const gd::String &publicUrl) {
    gd::Screenshot screenshot;
    screenshot.SetDelayTimeInSeconds(delayTimeInSeconds);
    screenshot.SetSignedUrl(signedUrl);
    screenshot.SetPublicUrl(publicUrl);
    captureOptions.AddScreenshot(screenshot);
    return *this;
  }
 
  gd::Project &project;
  gd::String exportPath;
  gd::String websocketDebuggerServerAddress;
  gd::String websocketDebuggerServerPort;
  bool useWindowMessageDebuggerClient;
  bool useMinimalDebuggerClient;
  gd::String layoutName;
  gd::String externalLayoutName;
  gd::String fallbackAuthorUsername;
  gd::String fallbackAuthorId;
  gd::String playerId;
  gd::String playerUsername;
  gd::String playerToken;
  gd::String inAppTutorialMessageInPreview;
  gd::String inAppTutorialMessagePositionInPreview;
  bool nativeMobileApp;
  std::map<gd::String, int> includeFileHashes;
  bool projectDataOnlyExport;
  bool fullLoadingScreen;
  bool isDevelopmentEnvironment;
  unsigned int nonRuntimeScriptsCacheBurst;
  gd::String electronRemoteRequirePath;
  gd::String gdevelopResourceToken;
  bool allowAuthenticationUsingIframeForPreview;
  gd::String crashReportUploadLevel;
  gd::String previewContext;
  gd::String gdevelopVersionWithHash;
  gd::String projectTemplateSlug;
  gd::String sourceGameId;
  gd::CaptureOptions captureOptions;
};
 
struct ExportOptions {
  ExportOptions(gd::Project &project_, const gd::String &exportPath_)
      : project(project_),
        exportPath(exportPath_),
        target(""),
        fallbackAuthorId(""),
        fallbackAuthorUsername("") {};
 
  ExportOptions &SetFallbackAuthor(const gd::String &id,
                                   const gd::String &username) {
    fallbackAuthorId = id;
    fallbackAuthorUsername = username;
    return *this;
  }
 
  ExportOptions &SetTarget(const gd::String &target_) {
    target = target_;
    return *this;
  }
 
  gd::Project &project;
  gd::String exportPath;
  gd::String target;
  gd::String fallbackAuthorUsername;
  gd::String fallbackAuthorId;
};
 
class ExporterHelper {
 public:
  ExporterHelper(gd::AbstractFileSystem &fileSystem,
                 gd::String gdjsRoot_,
                 gd::String codeOutputDir);
  virtual ~ExporterHelper() {};
 
  const gd::String &GetLastError() const { return lastError; };
 
  static gd::String ExportProjectData(
      gd::AbstractFileSystem &fs,
      gd::Project &project,
      gd::String filename,
      const gd::SerializerElement &runtimeGameOptions,
      std::set<gd::String> &projectUsedResources,
      std::unordered_map<gd::String, std::set<gd::String>>
          &layersUsedResources);
 
  static void ExportResources(gd::AbstractFileSystem &fs,
                              gd::Project &project,
                              gd::String exportDir);
 
  void AddLibsInclude(bool pixiRenderers,
                      bool pixiInThreeRenderers,
                      bool includeWebsocketDebuggerClient,
                      bool includeWindowMessageDebuggerClient,
                      bool includeMinimalDebuggerClient,
                      bool includeCaptureManager,
                      bool includeInAppTutorialMessage,
                      gd::String gdevelopLogoStyle,
                      std::vector<gd::String> &includesFiles);
 
  void RemoveIncludes(bool pixiRenderers,
                      std::vector<gd::String> &includesFiles);
 
  bool ExportIncludesAndLibs(const std::vector<gd::String> &includesFiles,
                             gd::String exportDir,
                             bool exportSourceMaps);
 
  bool ExportEventsCode(
      const gd::Project &project,
      gd::String outputDir,
      std::vector<gd::String> &includesFiles,
      gd::WholeProjectDiagnosticReport &wholeProjectDiagnosticReport,
      bool exportForPreview);
 
  bool ExportEffectIncludes(gd::Project &project,
                            std::vector<gd::String> &includesFiles);
 
  bool ExportIndexFile(const gd::Project &project,
                       gd::String source,
                       gd::String exportDir,
                       const std::vector<gd::String> &includesFiles,
                       const std::vector<gd::SourceFileMetadata> &sourceFiles,
                       unsigned int nonRuntimeScriptsCacheBurst,
                       gd::String additionalSpec = "");
 
  bool CompleteIndexFile(gd::String &indexFileContent,
                         gd::String exportDir,
                         const std::vector<gd::String> &includesFiles,
                         unsigned int nonRuntimeScriptsCacheBurst,
                         gd::String additionalSpec);
 
  const gd::String GenerateWebManifest(const gd::Project &project);
 
  bool ExportCordovaFiles(const gd::Project &project,
                          gd::String exportDir,
                          std::set<gd::String> usedExtensions);
 
  bool ExportElectronFiles(const gd::Project &project,
                           gd::String exportDir,
                           std::set<gd::String> usedExtensions);
 
  bool ExportBuildResourcesElectronFiles(const gd::Project &project,
                                         gd::String exportDir);
 
  bool ExportFacebookInstantGamesFiles(const gd::Project &project,
                                       gd::String exportDir);
 
  bool ExportHtml5Files(const gd::Project &project, gd::String exportDir);
 
  bool ExportProjectForPixiPreview(const PreviewExportOptions &options);
 
  gd::String GetExportedIncludeFilename(
      const gd::String &include, unsigned int nonRuntimeScriptsCacheBurst = 0);
 
  void SetCodeOutputDirectory(gd::String codeOutputDir_) {
    codeOutputDir = codeOutputDir_;
  }
 
  static void AddDeprecatedFontFilesToFontResources(
      gd::AbstractFileSystem &fs,
      gd::ResourcesManager &resourcesManager,
      const gd::String &exportDir,
      gd::String urlPrefix = "");
 
  gd::AbstractFileSystem
      &fs;  
  gd::String lastError;  
  gd::String
      gdjsRoot;  
  gd::String codeOutputDir;  
 
 private:
  static void SerializeUsedResources(
      gd::SerializerElement &rootElement,
      std::set<gd::String> &projectUsedResources,
      std::unordered_map<gd::String, std::set<gd::String>>
          &layersUsedResources);
};
 
}  // namespace gdjs