Added support for Unity configured JDK Path.

Also,
* Fixed VersionHandler build errors with Unity 5.5, due to the constantly
  changing BuildTarget enum. rather than requiring JAVA_HOME to be set in the
  Jar Resolver.
* Fixed VersionHandler build when multiple versions of Unity are installed.

BUG=33292471

Change-Id: Ie36ca053822db885a87eeeb4388e74acac9028f5

Author: Stewart Miles

CHANGELOG.md

@@ -1,3 +1,10 @@
+# Version 1.2.7 - Dec 2, 2016
+## Bug Fixes
+    * Fixed VersionHandler build errors with Unity 5.5, due to the constantly
+      changing BuildTarget enum.
+    * Added support for Unity configured JDK Path rather than requiring
+      JAVA_HOME to be set in the Jar Resolver.
+
 # Version 1.2.6 - Nov 15, 2016
 ## Bug Fixes
     * Fixed IOSResolver errors when iOS support is not installed.

build.gradle

@@ -138,7 +138,7 @@ project.ext {
     buildPath = file('build').absolutePath
     exportPath = file('build/plugin.unitypackage').absolutePath
     dllDir = 'Assets/PlayServicesResolver/Editor'
-    pluginVersion = '1.2.6.0'
+    pluginVersion = '1.2.7.0'
     currentPluginPath = file('.').absolutePath
     currentPluginBasename = 'play-services-resolver'
     currentPluginName = (currentPluginBasename + '-' + pluginVersion +

exploded/Assets/PlayServicesResolver/Editor.meta

@@ -0,0 +1,3 @@
+Assets/PlayServicesResolver/Editor/Google.IOSResolver_v1.2.7.0.dll
+Assets/PlayServicesResolver/Editor/Google.JarResolver_v1.2.7.0.dll
+Assets/PlayServicesResolver/Editor/Google.VersionHandler_v1.2.7.0.dll

exploded/Assets/PlayServicesResolver/Editor/Google.IOSResolver_v1.2.6.0.dll renamed to exploded/Assets/PlayServicesResolver/Editor/Google.IOSResolver_v1.2.7.0.dll

@@ -43,8 +43,8 @@
         <HintPath>$(UnityHintPath)/UnityEngine.dll</HintPath>
     </Reference>
     <Reference Include="UnityEditor.iOS.Extensions.Xcode">
-      <HintPath>$(UnityIosPath)/UnityEditor.iOS.Extensions.Xcode.dll</HintPath>
-      <HintPath>$(UnityIosPath)/Unity.iOS.Extensions.Xcode.dll</HintPath>
+      <HintPath Condition="Exists('$(UnityIosPath)/UnityEditor.iOS.Extensions.Xcode.dll')">$(UnityIosPath)/UnityEditor.iOS.Extensions.Xcode.dll</HintPath>
+      <HintPath Condition="Exists('$(UnityIosPath)/Unity.iOS.Extensions.Xcode.dll')">$(UnityIosPath)/Unity.iOS.Extensions.Xcode.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />

exploded/Assets/PlayServicesResolver/Editor/Google.IOSResolver_v1.2.6.0.dll.meta renamed to exploded/Assets/PlayServicesResolver/Editor/Google.IOSResolver_v1.2.7.0.dll.meta

@@ -213,7 +213,8 @@ internal bool SupportsAarFiles
         /// <param name="toolName">Name of the tool to search for.</param>
         private string FindJavaTool(string javaTool)
         {
-            string javaHome = Environment.GetEnvironmentVariable("JAVA_HOME");
+            string javaHome = UnityEditor.EditorPrefs.GetString("JdkPath");
+            javaHome = javaHome ?? Environment.GetEnvironmentVariable("JAVA_HOME");
             string toolPath;
             if (javaHome != null)
             {

exploded/Assets/PlayServicesResolver/Editor/Google.JarResolver_v1.2.6.0.dll renamed to exploded/Assets/PlayServicesResolver/Editor/Google.JarResolver_v1.2.7.0.dll

@@ -82,39 +82,81 @@ public FilenameComponents(string filename) {
         private static string LABEL_PREFIX = "gvh_";
         // Initialized depending on the version of unity we are running against
         private static HashSet<BuildTarget> targetBlackList = null;
+        // Initialized by parsing BuildTarget enumeration values from
+        // BUILD_TARGET_NAME_TO_ENUM_NAME.
+        private static Dictionary<string, BuildTarget>
+            buildTargetNameToEnum = null;
 
         /// <summary>
         /// Label which flags whether an asset is should be managed by this
         /// module.
         /// </summary>
         public static string ASSET_LABEL = "gvh";
 
-        // Map of build target names to BuildTarget enumeration values.
-        static public Dictionary<string, BuildTarget>
-            BUILD_TARGET_NAME_TO_ENUM = new Dictionary<string, BuildTarget> {
-            {"osx", BuildTarget.StandaloneOSXUniversal},
-            {"osxintel", BuildTarget.StandaloneOSXIntel},
-            {"windows", BuildTarget.StandaloneWindows},
-            {"ios", BuildTarget.iOS},
-            {"ps3", BuildTarget.PS3},
-            {"xbox360", BuildTarget.XBOX360},
-            {"android", BuildTarget.Android},
-            {"linux32", BuildTarget.StandaloneLinux},
-            {"windows64", BuildTarget.StandaloneWindows64},
-            {"webgl", BuildTarget.WebGL},
-            {"linux64", BuildTarget.StandaloneLinux64},
-            {"linux", BuildTarget.StandaloneLinuxUniversal},
-            {"osxintel64", BuildTarget.StandaloneOSXIntel64},
-            {"tizen", BuildTarget.Tizen},
-            {"psp2", BuildTarget.PSP2},
-            {"ps4", BuildTarget.PS4},
-            {"xboxone", BuildTarget.XboxOne},
-            {"samsungtv", BuildTarget.SamsungTV},
-            {"nintendo3ds", BuildTarget.Nintendo3DS},
-            {"wiiu", BuildTarget.WiiU},
-            {"tvos", BuildTarget.tvOS},
+        // Map of build target names to BuildTarget enumeration names.
+        // We don't use BuildTarget enumeration values here as Unity has a
+        // habit of removing unsupported ones from the API.
+        static public Dictionary<string, string>
+            BUILD_TARGET_NAME_TO_ENUM_NAME = new Dictionary<string, string> {
+            {"osx", "StandaloneOSXUniversal"},
+            {"osxintel", "StandaloneOSXIntel"},
+            {"windows", "StandaloneWindows"},
+            {"ios", "iOS"},
+            {"ps3", "PS3"},
+            {"xbox360", "XBOX360"},
+            {"android", "Android"},
+            {"linux32", "StandaloneLinux"},
+            {"windows64", "StandaloneWindows64"},
+            {"webgl", "WebGL"},
+            {"linux64", "StandaloneLinux64"},
+            {"linux", "StandaloneLinuxUniversal"},
+            {"osxintel64", "StandaloneOSXIntel64"},
+            {"tizen", "Tizen"},
+            {"psp2", "PSP2"},
+            {"ps4", "PS4"},
+            {"xboxone", "XboxOne"},
+            {"samsungtv", "SamsungTV"},
+            {"nintendo3ds", "Nintendo3DS"},
+            {"wiiu", "WiiU"},
+            {"tvos", "tvOS"},
         };
 
+        /// <summary>
+        /// Get a set of build target names mapped to supported BuildTarget
+        /// enumeration values.
+        /// </summary>
+        internal static Dictionary<string, BuildTarget> GetBuildTargetNameToEnum() {
+            if (buildTargetNameToEnum == null) {
+                var targetBlackList = GetBlackList();
+                buildTargetNameToEnum =
+                    new Dictionary<string, BuildTarget>();
+                foreach (var targetNameEnumName in
+                         BUILD_TARGET_NAME_TO_ENUM_NAME) {
+                    // Attempt to parse the build target name.
+                    // ArgumentException, OverflowException or
+                    // TypeInitializationException
+                    // will be thrown if the build target is no longer
+                    // supported.
+                    BuildTarget target;
+                    try {
+                        target = (BuildTarget)Enum.Parse(
+                            typeof(BuildTarget), targetNameEnumName.Value);
+                    } catch (ArgumentException) {
+                        continue;
+                    } catch (OverflowException) {
+                        continue;
+                    } catch (TypeInitializationException) {
+                        continue;
+                    }
+                    if (!targetBlackList.Contains(target)) {
+                        buildTargetNameToEnum[targetNameEnumName.Key] =
+                            target;
+                    }
+                }
+            }
+            return buildTargetNameToEnum;
+        }
+
         // Returns the major/minor version of the unity environment we are running in
         // as a float so it can be compared numerically.
         static float GetUnityVersionMajorMinor() {
@@ -133,6 +175,11 @@ static float GetUnityVersionMajorMinor() {
 
         // Returns a hashset containing blacklisted build targets for the current
         // unity environment.
+        // We need to maintain a seperate blacklist as Unity occasionally
+        // removes BuildTarget display names but does not remove the enumeration
+        // values associated with the names.  This causes a fatal error in
+        // PluginImporter.GetCompatibleWithPlatform() when provided with a
+        // BuildTarget that no longer has a display name.
         static HashSet<BuildTarget> GetBlackList() {
             if (targetBlackList == null) {
                 targetBlackList = new HashSet<BuildTarget>();
@@ -144,11 +191,6 @@ static HashSet<BuildTarget> GetBlackList() {
             return targetBlackList;
         }
 
-        // Returns true if the given target is supported by the current environment.
-        internal static bool IsTargetSupportedByUnity(BuildTarget target) {
-            return !GetBlackList().Contains(target);
-        }
-
         /// <summary>
         /// Name of the file use to construct this object.
         /// </summary>
@@ -285,11 +327,11 @@ public bool GetEditorEnabled() {
         /// </returns>
         public HashSet<BuildTarget> GetBuildTargets() {
             HashSet<BuildTarget> buildTargetSet = new HashSet<BuildTarget>();
+            var buildTargetToEnum = GetBuildTargetNameToEnum();
             if (targets != null) {
                 foreach (string target in targets) {
                     BuildTarget buildTarget;
-                    if (BUILD_TARGET_NAME_TO_ENUM.TryGetValue(
-                            target, out buildTarget)) {
+                    if (buildTargetToEnum.TryGetValue(target, out buildTarget)) {
                         buildTargetSet.Add(buildTarget);
                     } else if (!target.Equals("editor")) {
                         UnityEngine.Debug.LogError(
@@ -577,23 +619,21 @@ public bool EnableMostRecentPlugins() {
                     modifiedThisVersion = true;
                 }
                 foreach (BuildTarget target in
-                         FileMetadata.BUILD_TARGET_NAME_TO_ENUM.Values) {
-                    if (FileMetadata.IsTargetSupportedByUnity(target)) {
-                        bool enabled = selectedTargets != null &&
-                            selectedTargets.Contains(target);
-                        try {
-                            if (pluginImporter.GetCompatibleWithPlatform(target) !=
-                                enabled) {
-                                pluginImporter.SetCompatibleWithPlatform(
-                                    target, enabled);
-                                modifiedThisVersion = true;
-                            }
-                        }
-                        catch(Exception e) {
-                          UnityEngine.Debug.LogWarning(
-                            "Unexpected error enumerating targets: " + e.Message);
+                         FileMetadata.GetBuildTargetNameToEnum().Values) {
+                    bool enabled = selectedTargets != null &&
+                        selectedTargets.Contains(target);
+                    try {
+                        if (pluginImporter.GetCompatibleWithPlatform(target) !=
+                            enabled) {
+                            pluginImporter.SetCompatibleWithPlatform(
+                                target, enabled);
+                            modifiedThisVersion = true;
                         }
                     }
+                    catch(Exception e) {
+                      UnityEngine.Debug.LogWarning(
+                        "Unexpected error enumerating targets: " + e.Message);
+                    }
                 }
                 if (modifiedThisVersion) {
                     pluginImporter.SaveAndReimport();