Exemple #1
0
        static public bool ExecuteCompileCommand(string Command, string RPCCommand)
        {
            switch (Command.ToLowerInvariant())
            {
            case "clean":
                Program.Log("Cleaning temporary files from PC ... ");
                Program.Log(" ... cleaning: " + Config.PCStagingRootDir);
                FileOperations.DeleteDirectory(new DirectoryInfo(Config.PCStagingRootDir));
                break;

            case "rpc":
                ExecuteRemoteCommand(RPCCommand);
                break;

            case "getipa":
            {
                Program.Log("Fetching IPA from Mac...");

                string IpaDestFilename = Config.GetIPAPath(".ipa");
                FileOperations.DownloadFile(MacName, MacStagingRootDir + "/" + Config.IPAFilenameOnMac, IpaDestFilename);

                Program.Log("... Saved IPA to '{0}'", Path.GetFullPath(IpaDestFilename));
            }
            break;

            case "getstubipa":
            {
                Program.Log("Fetching stub IPA from Mac...");

                string IpaDestFilename = Config.GetIPAPath(".stub");
                FileOperations.DownloadFile(MacName, MacStagingRootDir + "/" + Config.IPAFilenameOnMac, IpaDestFilename);

                Program.Log("... Saved stub IPA to '{0}'", Path.GetFullPath(IpaDestFilename));
            }
            break;

            case "stagemacfiles":
                Program.Log("Copying all staged files to Mac " + MacName + " ...");
                FileOperations.BatchUploadFolder(MacName, Config.PCStagingRootDir, MacStagingRootDir, false);
                FileOperations.BatchUploadFolder(MacName, Config.PCXcodeStagingDir, MacXcodeStagingDir, false);
                break;

            case "exportcertificate":
                CompileTime.ExportCertificate();
                break;

            default:
                return(false);
            }

            return(true);
        }
Exemple #2
0
        /**
         * Creates the application directory on the Mac
         */
        static public void CreateApplicationDirOnMac()
        {
            DateTime StartTime = DateTime.Now;

            // Cleans out the intermediate folders on both ends
            CompileTime.ExecuteRemoteCommand("DeleteIPA");
            CompileTime.ExecuteRemoteCommand("DeleteMacStagingFiles");
            Program.ExecuteCommand("Clean", null);
            //@TODO: mnoland 10/5/2010
            // Need to come up with a way to prevent this from causing an error on the remote machine
            // CompileTime.ExecuteRemoteCommand("Clean");

            // Stage files
            Program.Log("Staging files before copying to Mac ...");
            CopyFilesNeededForMakeApp();

            // Copy staged files from PC to Mac
            Program.ExecuteCommand("StageMacFiles", null);

            // Set the executable bit on the EXE
            CompileTime.ExecuteRemoteCommand("SetExec");

            // Install the provision (necessary for MakeApp to succeed)
            CompileTime.ExecuteRemoteCommand("EnsureProvisionDirExists");
            CompileTime.ExecuteRemoteCommand("InstallProvision");

            // strip the symbols if desired or required
            if (Config.bForceStripSymbols || Config.bForDistribution)
            {
                CompileTime.ExecuteRemoteCommand("Strip");
            }

            // sign the exe, etc...
            CompileTime.ExecuteRemoteCommand("PrePackage");
            if (!Config.bUseRPCUtil)
            {
                CompileTime.ExecuteRemoteCommand("DeleteKeyChain", true);
                CompileTime.ExecuteRemoteCommand("CreateKeyChain");
            }
            CompileTime.ExecuteRemoteCommand("MakeApp");
            if (!Config.bUseRPCUtil)
            {
                CompileTime.ExecuteRemoteCommand("DeleteKeyChain");
            }

            Program.Log(String.Format("Finished creating .app directory on Mac (took {0:0.00} s)",
                                      (DateTime.Now - StartTime).TotalSeconds));
        }
Exemple #3
0
        /**
         * Packages an IPA on the Mac
         */
        static public void PackageIPAOnMac()
        {
            // Create the .app structure on the Mac (and codesign, etc...)
            CreateApplicationDirOnMac();

            DateTime StartTime = DateTime.Now;

            // zip up
            CompileTime.ExecuteRemoteCommand("Zip");

            // fetch the IPA
            if (Config.bCreateStubSet)
            {
                Program.ExecuteCommand("GetStubIPA", null);
            }
            else
            {
                Program.ExecuteCommand("GetIPA", null);
            }

            Program.Log(String.Format("Finished packaging into IPA (took {0:0.00} s)",
                                      (DateTime.Now - StartTime).TotalSeconds));
        }
Exemple #4
0
 static public void DangerouslyFastMode()
 {
     CompileTime.ExecuteRemoteCommand("MakeApp");
 }
        static int Main(string[] args)
        {
            // remember the working directory at start, as the game path could be relative to this path
            string InitialCurrentDirectory = Environment.CurrentDirectory;

            // set the working directory to the location of the application (so relative paths always work)
            Environment.CurrentDirectory = Path.GetDirectoryName(Application.ExecutablePath);

            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);

            // A simple, top-level try-catch block
            try
            {
                if (!ParseCommandLine(ref args))
                {
                    Log("Usage: iPhonePackager <Command> <GameName> [RPCCommand &| Switch]");
                    Log("");
                    Log("Common commands:");
                    Log(" ... RepackageIPA GameName");
                    Log(" ... PackageIPA GameName");
                    Log(" ... PackageApp GameName");
                    Log(" ... Deploy PathToIPA");
                    Log(" ... RepackageFromStage GameName");
                    Log(" ... Devices");
                    Log(" ... Validate");
                    Log(" ... Install");
                    Log("");
                    Log("Configuration switches:");
                    Log("	 -stagedir <path>		  sets the directory to copy staged files from (defaults to none)");
                    Log("	 -project <path>		  path to the project being packaged");
                    Log("	 -compress=fast|best|none  packaging compression level (defaults to none)");
                    Log("	 -strip					strip symbols during packaging");
                    Log("	 -config				   game configuration (e.g., Shipping, Development, etc...)");
                    Log("	 -distribution			 packaging for final distribution");
                    Log("	 -createstub			   packaging stub IPA for later repackaging");
                    Log("	 -mac <MacName>			overrides the machine to use for any Mac operations");
                    Log("	 -arch <Architecture>	  sets the architecture to use (blank for default, -simulator for simulator builds)");
                    Log("	 -device <DeviceID>		sets the device to install the IPA on");
                    Log("");
                    Log("Commands: RPC, Clean");
                    Log("  StageMacFiles, GetIPA, Deploy, Install, Uninstall");
                    Log("");
                    Log("RPC Commands: SetExec, InstallProvision, MakeApp, DeleteIPA, Copy, Kill, Strip, Zip, GenDSYM");
                    Log("");
                    Log("Sample commandlines:");
                    Log(" ... iPhonePackager Deploy UDKGame Release");
                    Log(" ... iPhonePackager RPC SwordGame Shipping MakeApp");
                    return((int)ErrorCodes.Error_Arguments);
                }

                Log("Executing iPhonePackager " + String.Join(" ", args));
                Log("CWD: " + Directory.GetCurrentDirectory());
                Log("Initial Dir: " + InitialCurrentDirectory);
                Log("Env CWD: " + Environment.CurrentDirectory);

                // Ensure shipping configuration for final distributions
                if (Config.bForDistribution && (GameConfiguration != "Shipping"))
                {
                    Program.Warning("Distribution builds should be made in the Shipping configuration!");
                }

                // process the GamePath (if could be ..\Samples\MyDemo\ or ..\Samples\MyDemo\MyDemo.uproject
                GameName = Path.GetFileNameWithoutExtension(GamePath);
                if (GameName.Equals("UE4", StringComparison.InvariantCultureIgnoreCase) || GameName.Equals("Engine", StringComparison.InvariantCultureIgnoreCase))
                {
                    GameName = "UE4Game";
                }

                // setup configuration
                if (!Config.Initialize(InitialCurrentDirectory, GamePath))
                {
                    return((int)ErrorCodes.Error_Arguments);
                }

                switch (MainCommand.ToLowerInvariant())
                {
                case "validate":
                    // check to see if iTunes is installed
                    string dllPath = "";
                    if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix)
                    {
                        dllPath = "/Applications/Xcode.app/Contents/MacOS/Xcode";
                    }
                    else
                    {
                        dllPath = Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Apple Inc.\\Apple Mobile Device Support\\Shared", "iTunesMobileDeviceDLL", null) as string;
                        if (String.IsNullOrEmpty(dllPath) || !File.Exists(dllPath))
                        {
                            dllPath = Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Apple Inc.\\Apple Mobile Device Support\\Shared", "MobileDeviceDLL", null) as string;
                        }
                    }
                    if (String.IsNullOrEmpty(dllPath) || !File.Exists(dllPath))
                    {
                        Error("iTunes Not Found!!", (int)ErrorCodes.Error_SDKNotFound);
                    }
                    else
                    {
                        // validate there is a useable provision and cert
                        MobileProvision  Provision;
                        X509Certificate2 Cert;
                        bool             bHasOverrides;
                        bool             bNameMatch;
                        bool             foundPlist = CodeSignatureBuilder.FindRequiredFiles(out Provision, out Cert, out bHasOverrides, out bNameMatch);
                        if (!foundPlist)
                        {
                            Error("Could not find a valid plist file!!", (int)ErrorCodes.Error_InfoPListNotFound);
                        }
                        else if (Provision == null && Cert == null)
                        {
                            Error("No Provision or cert found!!", (int)ErrorCodes.Error_ProvisionAndCertificateNotFound);
                        }
                        else if (Provision == null)
                        {
                            Error("No Provision found!!", (int)ErrorCodes.Error_ProvisionNotFound);
                        }
                        else if (Cert == null)
                        {
                            Error("No Signing Certificate found!!", (int)ErrorCodes.Error_CertificateNotFound);
                        }
                    }
                    break;

                case "packageapp":
                    if (CheckArguments())
                    {
                        if (Config.bCreateStubSet)
                        {
                            Error("packageapp cannot be used with the -createstub switch");
                            Program.ReturnCode = (int)ErrorCodes.Error_Arguments;
                        }
                        else
                        {
                            // Create the .app on the Mac
                            CompileTime.CreateApplicationDirOnMac();
                        }
                    }
                    break;

                case "repackagefromstage":
                    if (CheckArguments())
                    {
                        if (Config.bCreateStubSet)
                        {
                            Error("repackagefromstage cannot be used with the -createstub switches");
                            Program.ReturnCode = (int)ErrorCodes.Error_Arguments;
                        }
                        else
                        {
                            bool bProbablyCreatedStub = Utilities.GetEnvironmentVariable("ue.IOSCreateStubIPA", true);
                            if (!bProbablyCreatedStub)
                            {
                                Warning("ue.IOSCreateStubIPA is currently FALSE, which means you may be repackaging with an out of date stub IPA!");
                            }

                            CookTime.RepackageIPAFromStub();
                        }
                    }
                    break;

                // this is the "super fast just move executable" mode for quick programmer iteration
                case "dangerouslyfast":
                    if (CheckArguments())
                    {
                        CompileTime.DangerouslyFastMode();
                    }
                    break;

                case "packageipa":
                    if (CheckArguments())
                    {
                        CompileTime.PackageIPAOnMac();
                    }
                    break;

                case "install":
                    GameName = "";
                    if (Config.bProvision)
                    {
                        ToolsHub.TryInstallingMobileProvision(Config.Provision, false);
                    }
                    if (Config.bCert)
                    {
                        ToolsHub.TryInstallingCertificate_PromptForKey(Config.Certificate, false);
                    }
                    CodeSignatureBuilder.FindCertificates();
                    CodeSignatureBuilder.FindProvisions(Config.OverrideBundleName);
                    break;

                case "certificates":
                {
                    CodeSignatureBuilder.FindCertificates();
                    CodeSignatureBuilder.FindProvisions(Config.OverrideBundleName);
                }
                break;

                case "resigntool":
                    RunInVisualMode(delegate { return(new GraphicalResignTool()); });
                    break;

                case "certrequest":
                    RunInVisualMode(delegate { return(new GenerateSigningRequestDialog()); });
                    break;

                case "gui":
                    RunInVisualMode(delegate { return(ToolsHub.CreateShowingTools()); });
                    break;

                case "devices":
                    ListDevices();
                    break;

                default:
                    // Commands by themself default to packaging for the device
                    if (CheckArguments())
                    {
                        ExecuteCommand(MainCommand, MainRPCCommand);
                    }
                    break;
                }
            }
            catch (Exception Ex)
            {
                Error("Application exception: " + Ex.ToString());
                if (ReturnCode == 0)
                {
                    Program.ReturnCode = (int)ErrorCodes.Error_Unknown;
                }
            }
            finally
            {
                if (DeploymentHelper.DeploymentServerProcess != null)
                {
                    DeploymentHelper.DeploymentServerProcess.Close();
                }
            }

            Environment.ExitCode = ReturnCode;
            return(ReturnCode);
        }
        static public void ExecuteCommand(string Command, string RPCCommand)
        {
            if (ReturnCode > 0)
            {
                Warning("Error in previous command; suppressing: " + Command + " " + RPCCommand ?? "");
                return;
            }

            if (Config.bVerbose)
            {
                Log("");
                Log("----------");
                Log(String.Format("Executing command '{0}' {1}...", Command, (RPCCommand != null) ? ("'" + RPCCommand + "' ") : ""));
            }

            try
            {
                bool bHandledCommand = CookTime.ExecuteCookCommand(Command, RPCCommand);

                if (!bHandledCommand)
                {
                    bHandledCommand = CompileTime.ExecuteCompileCommand(Command, RPCCommand);
                }

                if (!bHandledCommand)
                {
                    bHandledCommand = DeploymentHelper.ExecuteDeployCommand(Command, GamePath, RPCCommand);
                }

                if (!bHandledCommand)
                {
                    bHandledCommand = true;
                    switch (Command)
                    {
                    case "configure":
                        if (Config.bForDistribution)
                        {
                            Error("configure cannot be used with -distribution");
                            Program.ReturnCode = (int)ErrorCodes.Error_Arguments;
                        }
                        else
                        {
                            RunInVisualMode(delegate { return(new ConfigureMobileGame()); });
                        }
                        break;

                    default:
                        bHandledCommand = false;
                        break;
                    }
                }

                if (!bHandledCommand)
                {
                    Error("Unknown command");
                    Program.ReturnCode = (int)ErrorCodes.Error_UnknownCommand;
                }
            }
            catch (Exception Ex)
            {
                Error("Error while executing command: " + Ex.ToString());
                if (Program.ReturnCode == 0)
                {
                    Program.ReturnCode = (int)ErrorCodes.Error_Unknown;
                }
            }

            Console.WriteLine();
        }
Exemple #7
0
        public static bool Initialize(string InitialCurrentDirectory, string GamePath)
        {
            bool bIsEpicInternal = File.Exists(@"..\..\EpicInternal.txt");


            // if the path is a directory (relative to where the game was launched from), then get the absolute directory
            string FullGamePath = Path.GetFullPath(Path.Combine(InitialCurrentDirectory, GamePath));
            string OrigGamePath = GamePath;

            if (Directory.Exists(FullGamePath))
            {
                GameDirectory = FullGamePath;
            }
            // is it a file? if so, just use the file's directory
            else if (File.Exists(FullGamePath))
            {
                GameDirectory = Path.GetDirectoryName(FullGamePath);
            }
            // else we assume old school game name and look for it
            else
            {
                if (Program.GameName == "UE4Game")
                {
                    GameDirectory = Path.GetFullPath(Path.Combine(Config.RootRelativePath, GamePath));
                }
                else
                {
                    GameDirectory = Path.GetFullPath(Path.Combine(Config.RootRelativePath, Program.GameName));
                }
            }

            if (!Directory.Exists(GameDirectory))
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine();
                Console.WriteLine("Unable to find a game or program {0}. You may need to specify a path to the program", OrigGamePath);
                Console.ResetColor();
                return(false);
            }

            // special case handling for anything inside Engine/Source, it will go to the Engine/Binaries directory, not the Game's binaries directory
            if (OrigGamePath.Replace("\\", "/").Contains("Engine/Source"))
            {
                BinariesDirectory = Path.Combine(RootRelativePath, @"Engine\Binaries\" + Config.OSString + @"\");
            }
            else if (!OrigGamePath.Contains(@"Binaries\" + Config.OSString))
            {
                // no sense in adding Binaries\IOS when it's already there. This is a special case to handle packaging UnrealLaunchDaemon from the command line.
                BinariesDirectory = Path.Combine(GameDirectory, @"Binaries\" + Config.OSString + @"\");
            }
            else
            {
                BinariesDirectory = GameDirectory;
            }

            // Root directory on PC for staging files to copy to Mac
            Config.PCStagingRootDir = String.Format(@"{0}-Deploy\{1}\{2}{3}\",
                                                    IntermediateDirectory,
                                                    Program.GameName,
                                                    Program.GameConfiguration,
                                                    Program.Architecture);

            // make a directory for the shared XcodeSupportFiles directory
            Config.PCXcodeStagingDir = Path.Combine(Config.PCStagingRootDir, @"..\XcodeSupportFiles");

            // Code signing identity
            // Rules:
            //   An environment variable wins if set
            //   Otherwise for internal development builds, an internal identity is used
            //   Otherwise, developer or distribution are used
            // Distro builds won't succeed on a machine with multiple distro certs installed unless the environment variable is set.
            Config.CodeSigningIdentity = Config.bForDistribution ? "iPhone Distribution" : "iPhone Developer";


            if (Config.bForDistribution)
            {
                Config.CodeSigningIdentity = Utilities.GetEnvironmentVariable("ue.IOSDistributionSigningIdentity", Config.CodeSigningIdentity);
            }
            else
            {
                Config.CodeSigningIdentity = Utilities.GetEnvironmentVariable("ue.IOSDeveloperSigningIdentity", Config.CodeSigningIdentity);
            }

            // Remember to also change the default min version in UBT (iPhoneToolChain.cs)
            Config.MinOSVersion = Utilities.GetEnvironmentVariable("ue3.iPhone_MinOSVersion", "6.0");

            // look for the signing prefix environment variable
            string DefaultPrefix = "";

            if (bIsEpicInternal)
            {
                // default Epic to "Epic_" prefix
                DefaultPrefix = "Epic_";
            }

            if (Config.bForDistribution)
            {
                DefaultPrefix = "Distro_";
            }
            Config.SigningPrefix = Utilities.GetEnvironmentVariable("ue.IOSSigningPrefix", DefaultPrefix);

            // Windows doesn't allow environment vars to be set to blank so detect "none" and treat it as such
            if (Config.SigningPrefix == "none")
            {
                Config.SigningPrefix = Config.bForDistribution ? "Distro_" : "";
            }

            CompileTime.ConfigurePaths();
            return(true);
        }