Implement Project Manager 'build' button for Mac and Linux(#4248)

Signed-off-by: Steve Pham <spham@amazon.com>

Code/Tools/ProjectManager/Platform/Mac/ProjectBuilderWorker_mac.cpp

@@ -7,14 +7,82 @@
  */
 
 #include <ProjectBuilderWorker.h>
+#include <ProjectManagerDefs.h>
+#include <ProjectUtils.h>
+
+#include <QDir>
+#include <QString>
 
 namespace O3DE::ProjectManager
 {
-    AZ::Outcome<void, QString> ProjectBuilderWorker::BuildProjectForPlatform()
+    namespace Internal
     {
-        QString error = tr("Automatic building on MacOS not currently supported!");
-        QStringToAZTracePrint(error);
-        return AZ::Failure(error);
+        AZ::Outcome<QString, QString> QueryInstalledCmakeFullPath()
+        {
+            auto environmentRequest = ProjectUtils::GetCommandLineProcessEnvironment();
+            if (!environmentRequest.IsSuccess())
+            {
+                return AZ::Failure(environmentRequest.GetError());
+            }
+            auto currentEnvironment = environmentRequest.GetValue();
+
+            auto queryCmakeInstalled = ProjectUtils::ExecuteCommandResult("which",
+                                                                          QStringList{ProjectCMakeCommand}, 
+                                                                          currentEnvironment);
+            if (!queryCmakeInstalled.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to detect CMake on this host."));
+            }
+            QString cmakeInstalledPath = queryCmakeInstalled.GetValue().split("\n")[0];
+            return AZ::Success(cmakeInstalledPath);
+        }
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeGenerateProjectArguments(const QString& thirdPartyPath) const
+    {
+        // For Mac, we need to resolve the full path of cmake and use that in the process request. For
+        // some reason, 'which' will resolve the full path, but when you just specify cmake with the same
+        // environment, it is unable to resolve. To work around this, we will use 'which' to resolve the 
+        // full path and then use it as the command argument
+        auto cmakeInstalledPathQuery = Internal::QueryInstalledCmakeFullPath();
+        if (!cmakeInstalledPathQuery.IsSuccess())
+        {
+            return AZ::Failure(cmakeInstalledPathQuery.GetError());
+        }
+        QString cmakeInstalledPath = cmakeInstalledPathQuery.GetValue();
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+
+        return AZ::Success(QStringList{cmakeInstalledPath,
+                                       "-B", targetBuildPath,
+                                       "-S", m_projectInfo.m_path,
+                                       "-GXcode"});
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeBuildCommandArguments() const
+    {
+        // For Mac, we need to resolve the full path of cmake and use that in the process request. For
+        // some reason, 'which' will resolve the full path, but when you just specify cmake with the same
+        // environment, it is unable to resolve. To work around this, we will use 'which' to resolve the
+        // full path and then use it as the command argument
+        auto cmakeInstalledPathQuery = Internal::QueryInstalledCmakeFullPath();
+        if (!cmakeInstalledPathQuery.IsSuccess())
+        {
+            return AZ::Failure(cmakeInstalledPathQuery.GetError());
+        }
+
+        QString cmakeInstalledPath = cmakeInstalledPathQuery.GetValue();
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+        QString launcherTargetName = m_projectInfo.m_projectName + ".GameLauncher";
+
+        return AZ::Success(QStringList{cmakeInstalledPath,
+                                        "--build", targetBuildPath,
+                                        "--config", "profile",
+                                        "--target", launcherTargetName, ProjectCMakeBuildTargetEditor});
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructKillProcessCommandArguments(const QString& pidToKill) const
+    {
+        return AZ::Success(QStringList{"kill", "-9", pidToKill});
     }
     
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Platform/Mac/ProjectUtils_mac.cpp

@@ -7,15 +7,59 @@
 
 #include <ProjectUtils.h>
 
+#include <QProcess>
+
 namespace O3DE::ProjectManager
 {
     namespace ProjectUtils
     {
-        AZ::Outcome<void, QString> FindSupportedCompilerForPlatform()
+        AZ::Outcome<QProcessEnvironment, QString> GetCommandLineProcessEnvironment()
         {
-            // Compiler detection not supported on platform
-            return AZ::Success();
+            // For CMake on Mac, if its installed through home-brew, then it will be installed
+            // under /usr/local/bin, which may not be in the system PATH environment. 
+            // Add that path for the command line process so that it will be able to locate
+            // a home-brew installed version of CMake
+            QProcessEnvironment currentEnvironment(QProcessEnvironment::systemEnvironment());
+            QString pathValue = currentEnvironment.value("PATH");
+            pathValue += ":/usr/local/bin";
+            currentEnvironment.insert("PATH", pathValue);
+            return AZ::Success(currentEnvironment);
         }
-        
+
+        AZ::Outcome<QString, QString> FindSupportedCompilerForPlatform()
+        {
+            QProcessEnvironment currentEnvironment(QProcessEnvironment::systemEnvironment());
+            QString pathValue = currentEnvironment.value("PATH");
+            pathValue += ":/usr/local/bin";
+            currentEnvironment.insert("PATH", pathValue);
+
+            // Validate that we have cmake installed first
+            auto queryCmakeInstalled = ExecuteCommandResult("which", QStringList{ProjectCMakeCommand}, currentEnvironment);
+            if (!queryCmakeInstalled.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to detect CMake on this host."));
+            }
+            QString cmakeInstalledPath = queryCmakeInstalled.GetValue().split("\n")[0];
+
+            // Query the version of the installed cmake
+            auto queryCmakeVersionQuery = ExecuteCommandResult(cmakeInstalledPath, QStringList{"-version"}, currentEnvironment);
+            if (!queryCmakeVersionQuery.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to determine the version of CMake on this host."));
+            }
+            AZ_TracePrintf("Project Manager", "Cmake version %s detected.", queryCmakeVersionQuery.GetValue().split("\n")[0].toUtf8().constData());
+
+            // Query for the version of xcodebuild (if installed)
+            auto queryXcodeBuildVersion = ExecuteCommandResult("xcodebuild", QStringList{"-version"}, currentEnvironment);
+            if (!queryCmakeInstalled.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to detect XCodeBuilder on this host."));
+            }
+            QString xcodeBuilderVersionNumber = queryXcodeBuildVersion.GetValue().split("\n")[0];
+            AZ_TracePrintf("Project Manager", "XcodeBuilder version %s detected.", xcodeBuilderVersionNumber.toUtf8().constData());
+
+
+            return AZ::Success(xcodeBuilderVersionNumber);
+        }       
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager