public static void ChangeProject(string projectName)
{
if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
{
// They hit cancel in the save dialog
return;
}
var result = PrjInterface.RunPrj(PrjInterface.CreatePrjRequestForProject("updateLinks", projectName));
if (result.Succeeded)
{
result = PrjInterface.RunPrj(PrjInterface.CreatePrjRequestForProject("openUnity", projectName));
if (result.Succeeded)
{
EditorApplication.Exit(0);
}
}
if (!result.Succeeded)
{
DisplayPrjError(
"Changing project to '{0}'"
.Fmt(projectName), result.ErrorMessage);
}
}
// NOTE: Returns null on failure
public static IEnumerator LookupPackagesListAsync()
{
var runner = PrjInterface.RunPrjAsync(PrjInterface.CreatePrjRequest("listPackages"));
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
var response = (PrjResponse)runner.Current;
if (response.Succeeded)
{
var docs = response.Output
.Split(new string[] { "---" }, StringSplitOptions.None);
yield return(PrjHelperResponse.Success(
docs
.Select(x => PrjSerializer.DeserializePackageFolderInfo(x))
.Where(x => x != null).ToList()));
}
else
{
yield return(PrjHelperResponse.Error(response.ErrorMessage));
}
}
public static void ChangePlatform(BuildTarget desiredPlatform)
{
if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
{
// They hit cancel in the save dialog
return;
}
if (ProjenyEditorUtil.GetPlatformFromDirectoryName() == desiredPlatform)
{
UnityEngine.Debug.Log("Projeny: Already at the desired platform, no need to change project.");
return;
}
var result = PrjInterface.RunPrj(PrjInterface.CreatePrjRequestForPlatform("updateLinks", desiredPlatform));
if (result.Succeeded)
{
result = PrjInterface.RunPrj(PrjInterface.CreatePrjRequestForPlatform("openUnity", desiredPlatform));
}
if (result.Succeeded)
{
EditorApplication.Exit(0);
}
else
{
DisplayPrjError(
"Changing platform to '{0}'"
.Fmt(desiredPlatform.ToString()), result.ErrorMessage);
}
}
public static IEnumerator DeletePackagesAsync(List <PackageInfo> infos)
{
foreach (var info in infos)
{
Log.Debug("Deleting package '{0}'".Fmt(info.Name));
var req = PrjInterface.CreatePrjRequest("deletePackage");
req.Param1 = info.Name;
var runner = PrjInterface.RunPrjAsync(req);
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
var response = (PrjResponse)runner.Current;
if (response.Succeeded)
{
Log.Info("Deleted package '{0}'".Fmt(info.Name));
}
else
{
yield return(PrjHelperResponse.Error(response.ErrorMessage));
yield break;
}
}
yield return(PrjHelperResponse.Success());
}
// NOTE: It's up to the calling code to update the solution first
public static IEnumerator OpenCustomSolutionAsync()
{
var runner = PrjInterface.RunPrjAsync(PrjInterface.CreatePrjRequest("openCustomSolution"));
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
static IEnumerator UpdateLinksAsyncInternal(PrjRequest req)
{
var runner = PrjInterface.RunPrjAsync(req);
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static IEnumerator OpenPackagesFolderInExplorer()
{
var runner = PrjInterface.RunPrjAsync(
PrjInterface.CreatePrjRequest("openPackagesFolder"));
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static IEnumerator OpenUnityForProjectAsync(string projectName)
{
var runner = PrjInterface.RunPrjAsync(
PrjInterface.CreatePrjRequestForProject("openUnity", projectName));
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static void OpenCustomSolution()
{
UpdateCustomSolution();
var response = PrjInterface.RunPrj(PrjInterface.CreatePrjRequest("openCustomSolution"));
if (!response.Succeeded)
{
PrjHelper.DisplayPrjError(
"Opening C# Project", response.ErrorMessage);
}
}
static PrjPathVars()
{
var response = PrjInterface.RunPrj(PrjInterface.CreatePrjRequest("getPathVars"));
if (response.Succeeded)
{
_varMap = YamlSerializer.Deserialize <Dictionary <string, string> >(response.Output);
}
else
{
PrjHelper.DisplayPrjError("Initializing Path Vars", response.ErrorMessage);
}
}
public static IEnumerator UpdateCustomSolutionAsync()
{
// Need the unity solution for defines and references
ProjenyEditorUtil.ForceGenerateUnitySolution();
var runner = PrjInterface.RunPrjAsync(PrjInterface.CreatePrjRequest("updateCustomSolution"));
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static bool UpdateLinks()
{
var result = PrjInterface.RunPrj(PrjInterface.CreatePrjRequest("updateLinks"));
AssetDatabase.Refresh();
if (!result.Succeeded)
{
DisplayPrjError("Updating directory links", result.ErrorMessage);
return(false);
}
return(true);
}
public static IEnumerator CreatePackageAsync(string name)
{
var req = PrjInterface.CreatePrjRequest("createPackage");
req.Param1 = name;
var runner = PrjInterface.RunPrjAsync(req);
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static IEnumerator CreateProjectAsync(string projectName, bool duplicateSettings)
{
var request = PrjInterface.CreatePrjRequest("createProject");
request.Param1 = projectName;
request.Param2 = duplicateSettings.ToString();
var runner = PrjInterface.RunPrjAsync(request);
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static bool UpdateLinks()
{
var result = PrjInterface.RunPrj(PrjInterface.CreatePrjRequest("updateLinks"));
// This sometimes causes out of memory issues for reasons unknown so just let user
// manually refresh
//AssetDatabase.Refresh();
if (!result.Succeeded)
{
DisplayPrjError("Updating directory links", result.ErrorMessage);
return(false);
}
return(true);
}
public static void UpdateCustomSolution()
{
// Need the unity solution for defines and references
ProjenyEditorUtil.ForceGenerateUnitySolution();
var response = PrjInterface.RunPrj(PrjInterface.CreatePrjRequest("updateCustomSolution"));
if (response.Succeeded)
{
Log.Info("Projeny: Custom solution has been updated");
}
else
{
PrjHelper.DisplayPrjError(
"Updating C# Project", response.ErrorMessage);
}
}
public static IEnumerator InstallReleaseAsync(ReleaseInfo info)
{
var req = PrjInterface.CreatePrjRequest("installRelease");
req.Param1 = info.Id;
if (info.HasVersionCode)
{
req.Param2 = info.VersionCode.ToString();
}
var runner = PrjInterface.RunPrjAsync(req);
while (runner.MoveNext() && !(runner.Current is PrjResponse))
{
yield return(runner.Current);
}
yield return(CreateStandardResponse((PrjResponse)runner.Current));
}
public static IEnumerator UpdateLinksAsyncForProject(string projectName)
{
return(UpdateLinksAsyncInternal(
PrjInterface.CreatePrjRequestForProject("updateLinks", projectName)));
}
// NOTE: It's up to the caller to call AssetDatabase.Refresh()
public static IEnumerator UpdateLinksAsync()
{
return(UpdateLinksAsyncInternal(
PrjInterface.CreatePrjRequest("updateLinks")));
}
