Feature/add command line option to set android external deps (#161)

* Add command line method to setup android external tools

* Add logs

Author: sierpinskid

Assets/Plugins/StreamChat/EditorTools/Builders/AndroidExternalToolsSettings.cs

@@ -0,0 +1,24 @@
+namespace Plugins.StreamChat.EditorTools.Builders
+{
+    public readonly struct AndroidExternalToolsSettings
+    {
+        public string JdkPath { get; }
+        public string AndroidSdkPath { get; }
+        public string AndroidNdkPath { get; }
+        public string GradlePath { get; }
+
+        public AndroidExternalToolsSettings(string jdkPath, string androidSdkPath, string androidNdkPath, string gradlePath)
+        {
+            JdkPath = jdkPath;
+            AndroidSdkPath = androidSdkPath;
+            AndroidNdkPath = androidNdkPath;
+            GradlePath = gradlePath;
+        }
+
+        public override string ToString()
+        {
+            return $"{nameof(AndroidExternalToolsSettings)} - {nameof(JdkPath)}: {JdkPath}, {nameof(AndroidSdkPath)}: {AndroidSdkPath}, " +
+                   $"{nameof(AndroidNdkPath)}: {AndroidNdkPath}, {nameof(GradlePath)}: {GradlePath}";
+        }
+    }
+}

Assets/Plugins/StreamChat/EditorTools/Builders/AndroidExternalToolsSettings.cs.meta

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using Plugins.StreamChat.EditorTools.Builders;
+
+namespace StreamChat.EditorTools.CommandLineParsers
+{
+    public class AndroidExternalToolsCommandLineParser : CommandLineParserBase<AndroidExternalToolsSettings>
+    {
+        public const string JdkPathArgKey = "-jdkPath";
+        public const string AndroidSdkPathArgKey = "-androidSdkPath";
+        public const string AndroidNdkPathArgKey = "-androidNdkPath";
+        public const string GradlePathArgKey = "-gradlePath";
+
+        protected override AndroidExternalToolsSettings Parse(IDictionary<string, string> args)
+        {
+            if (args.Count == 0)
+            {
+                throw new ArgumentException($"No arguments provided");
+            }
+
+            return new AndroidExternalToolsSettings(GetKeyOrDefault(JdkPathArgKey), GetKeyOrDefault(AndroidSdkPathArgKey), GetKeyOrDefault(AndroidNdkPathArgKey),
+                GetKeyOrDefault(GradlePathArgKey));
+
+            string GetKeyOrDefault(string key) => args.TryGetValue(key, out var arg) ? arg : string.Empty;
+        }
+    }
+}

Assets/Plugins/StreamChat/EditorTools/CommandLineParser.cs.meta

@@ -1,14 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using StreamChat.EditorTools;
 using StreamChat.EditorTools.Builders;
 using StreamChat.Libs.Auth;
 using StreamChat.Libs.Serialization;
 using UnityEditor;
 
-namespace StreamChat.EditorTools
+namespace StreamChat.EditorTools.CommandLineParsers
 {
-    public class CommandLineParser
+    public class BuildSettingsCommandLineParser : CommandLineParserBase<(BuildSettings buildSettings, AuthCredentials authCredentials)>
     {
         public const string ApiCompatibilityArgKey = "-apiCompatibility";
         public const string ScriptingBackendArgKey = "-scriptingBackend";
@@ -17,32 +18,31 @@ public class CommandLineParser
 
         public const string StreamBase64TestDataArgKey = "-streamBase64TestDataSet";
 
-        public (BuildSettings buildSettings, AuthCredentials authCredentials) GetParsedBuildArgs()
+        protected override (BuildSettings buildSettings, AuthCredentials authCredentials) Parse(
+            IDictionary<string, string> args)
         {
-            var args = GetParsedCommandLineArguments();
-
             if (IsAnyRequiredArgMissing(args, out var missingArgsInfo, BuildTargetPlatformArgKey,
-                ApiCompatibilityArgKey, ScriptingBackendArgKey, BuildTargetPathArgKey, StreamBase64TestDataArgKey))
+                    ApiCompatibilityArgKey, ScriptingBackendArgKey, BuildTargetPathArgKey, StreamBase64TestDataArgKey))
             {
                 throw new ArgumentException($"Missing argument: `{missingArgsInfo}`");
             }
 
             if (!Enum.TryParse<BuildTargetPlatform>(args[BuildTargetPlatformArgKey], ignoreCase: true,
-                out var targetPlatform))
+                    out var targetPlatform))
             {
                 throw new ArgumentException(
                     $"Failed to parse argument: `{args[BuildTargetPlatformArgKey]}` to enum: {typeof(BuildTargetPlatform)}");
             }
 
             if (!Enum.TryParse<ApiCompatibility>(args[ApiCompatibilityArgKey], ignoreCase: true,
-                out var apiCompatibility))
+                    out var apiCompatibility))
             {
                 throw new ArgumentException(
                     $"Failed to parse argument: `{args[BuildTargetPlatformArgKey]}` to enum: {typeof(BuildTargetPlatform)}");
             }
 
             if (!Enum.TryParse<ScriptingBackend>(args[ScriptingBackendArgKey], ignoreCase: true,
-                out var scriptingBackend))
+                    out var scriptingBackend))
             {
                 throw new ArgumentException(
                     $"Failed to parse argument: `{args[BuildTargetPlatformArgKey]}` to enum: {typeof(BuildTargetPlatform)}");
@@ -71,48 +71,6 @@ public TestAuthDataSet ParseTestAuthDataSetArg(IDictionary<string, string> args)
             return serializer.Deserialize<TestAuthDataSet>(rawTestDataSet);
         }
 
-        public IDictionary<string, string> GetParsedCommandLineArguments()
-        {
-            var result = new Dictionary<string, string>();
-            ParseCommandLineArguments(Environment.GetCommandLineArgs(), result);
-
-            return result;
-        }
-
-        public void ParseCommandLineArguments(string[] args, IDictionary<string, string> result)
-            => ParseCommandLineArguments(args, _ => result.Add(_.Key, _.Value));
-
-        public void ParseCommandLineArguments(string[] args, Action<(string Key, string Value)> onArgumentParsed)
-        {
-            for (int i = 0; i < args.Length; i++)
-            {
-                if (args[i].StartsWith("-"))
-                {
-                    var key = args[i];
-                    var value = i < args.Length - 1 ? args[i + 1] : "";
-
-                    onArgumentParsed?.Invoke((key, value));
-                }
-            }
-        }
-
-        private static bool IsAnyRequiredArgMissing(IDictionary<string, string> args, out string missingArgsInfo,
-            params string[] argKeys)
-        {
-            var missingKeys = new List<string>();
-
-            foreach (var key in argKeys)
-            {
-                if (!args.ContainsKey(key))
-                {
-                    missingKeys.Add(key);
-                }
-            }
-
-            missingArgsInfo = missingKeys.Count == 0 ? string.Empty : string.Join(", ", missingKeys);
-            return missingKeys.Count != 0;
-        }
-
         private BuildTargetGroup GetBuildTargetGroup(BuildTargetPlatform targetPlatform)
         {
             if (targetPlatform == BuildTargetPlatform.Standalone)
@@ -130,7 +88,6 @@ private BuildTargetGroup GetBuildTargetGroup(BuildTargetPlatform targetPlatform)
         private ApiCompatibilityLevel GetApiCompatibilityLevel(ApiCompatibility apiCompatibility)
         {
 #if UNITY_2021
-
             switch (apiCompatibility)
             {
                 case ApiCompatibility.NET_4_x: return ApiCompatibilityLevel.NET_Unity_4_8;

Assets/Plugins/StreamChat/EditorTools/CommandLineParsers.meta

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+
+namespace StreamChat.EditorTools.CommandLineParsers
+{
+    public abstract class CommandLineParserBase<TResult>
+    {
+        public TResult Parse()
+        {
+            var args = GetParsedCommandLineArguments();
+            return Parse(args);
+        }
+
+        public IDictionary<string, string> GetParsedCommandLineArguments()
+        {
+            var result = new Dictionary<string, string>();
+            ParseCommandLineArguments(Environment.GetCommandLineArgs(), result);
+
+            return result;
+        }
+
+        protected abstract TResult Parse(IDictionary<string, string> args);
+
+        protected void ParseCommandLineArguments(string[] args, IDictionary<string, string> result)
+            => ParseCommandLineArguments(args, _ => result.Add(_.Key, _.Value));
+
+        protected void ParseCommandLineArguments(string[] args, Action<(string Key, string Value)> onArgumentParsed)
+        {
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i].StartsWith("-"))
+                {
+                    var key = args[i];
+                    var value = i < args.Length - 1 ? args[i + 1] : "";
+
+                    onArgumentParsed?.Invoke((key, value));
+                }
+            }
+        }
+
+        protected static bool IsAnyRequiredArgMissing(IDictionary<string, string> args, out string missingArgsInfo,
+            params string[] argKeys)
+        {
+            var missingKeys = new List<string>();
+
+            foreach (var key in argKeys)
+            {
+                if (!args.ContainsKey(key))
+                {
+                    missingKeys.Add(key);
+                }
+            }
+
+            missingArgsInfo = missingKeys.Count == 0 ? string.Empty : string.Join(", ", missingKeys);
+            return missingKeys.Count != 0;
+        }
+    }
+}