Add initial support for the InteractableType wrapper.

Author: wiwei

Assets/MixedRealityToolkit.SDK/Features/UX/Interactable/Scripts/TypeResolution.meta

@@ -0,0 +1,44 @@
+using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.UX.Interactable
+{
+    /// <summary>
+    /// A wrapper for a Type which gives a "friendly name" for the type (i.e.
+    /// the class name) along with the assembly qualified name (which can be used
+    /// to new instances of this type). 
+    /// </summary>
+    /// <remarks>
+    /// The intent of this wrapper is for use with the various Interactable state, event
+    /// and theme classes, which are enumerated using reflection in the editor but must
+    /// then be instantiated at runtime (without the usage of reflection due to .NET
+    /// backend constraints).
+    /// </remarks>
+    public class InteractableType
+    {
+        /// <summary>
+        /// The class name of this interactable type (for example, "InteractableActivateTheme").
+        /// </summary>
+        public string ClassName { get; private set; }
+
+        /// <summary>
+        /// The assembly qualified name of the class (for example, 
+        /// "Microsoft.MixedReality.Toolkit.SDK.UX.Interactable.Themes.InteractableActivateTheme, 
+        /// Microsoft.MixedReality.Toolkit.SDK")
+        /// </summary>
+        public string AssemblyQualifiedName { get; private set; }
+
+        /// <summary>
+        /// The type of the class (for example, typeof(InteractableActivateTheme)).
+        /// </summary>
+        public Type Type { get; private set; }
+
+        public InteractableType(Type type)
+        {
+            ClassName = type.Name;
+            AssemblyQualifiedName = SystemType.GetReference(type);
+            Type = type;
+        }
+    }
+}

Assets/MixedRealityToolkit.SDK/Features/UX/Interactable/Scripts/TypeResolution/InteractableType.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.UX.Interactable.TypeResolution
+{
+    /// <summary>
+    /// A helper that uses reflection to find objects that implement base types of the
+    /// Interactable types that populate the various state, theme, and event inspectors.
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    public class InteractableTypeFinder
+    {
+        /// <summary>
+        /// Controls the behavior of the InteractableTypeFinder.FindTypes function. See individual
+        /// enum values for more details.
+        /// </summary>
+        public enum TypeRestriction
+        {
+            /// <summary>
+            /// When this is specified, only classes derived from the specified type will be
+            /// returned by the lookup. This means that if you pass InteractableStates, the
+            /// lookup will only return classes whose base class is InteractableStates but
+            /// will not return InteractableStates itself.
+            /// </summary>
+            DerivedOnly,
+
+            /// <summary>
+            /// When this is specified, classes derived from the specified type AND the class
+            /// itself will be returned by the lookup. This means that if you pass 
+            /// InteractableStates, the lookup will both classes whose base class is 
+            /// InteractableStates and InteractableStates itself.
+            /// </summary>
+            AllowBase,
+        };
+
+        /// <summary>
+        /// A convenience wrapper provided for editor code to turn a list of types into a form that 
+        /// matches their existing structure.
+        /// </summary>
+        /// <remarks>
+        /// This is primarily a crutch because of how the inspector code stores parallel arrays of
+        /// objects, rather than just storing an array of objects (i.e. it stores three arrays
+        /// of objects which happen to have matching indices, rather than storing a single array
+        /// of objects which have state relevant within the object).
+        /// </remarks>
+        public static InteractableTypesContainer Find(List<Type> types, TypeRestriction typeRestriction)
+        {
+#if UNITY_EDITOR
+            return new InteractableTypesContainer(FindTypes(types, typeRestriction));
+#else
+            // Due to other code structure, it's possible that this can still be invoked at runtime, but should
+            // not return anything (because type information should be read from serialized assembly data, rather
+            // than using reflection at runtime).
+            return new InteractableTypeList(new List<InteractableType>());
+#endif
+        }
+
+#if UNITY_EDITOR
+        /// <summary>
+        /// Used to cache lookups for Types (for example, InteractableThemeBase) to their classes that implement
+        /// that type.
+        /// </summary>
+        private static Dictionary<Type, List<InteractableType>> cache = new Dictionary<Type, List<InteractableType>>();
+
+        /// <summary>
+        /// Gets the list of InteractableType objects for classes that support the specified types.
+        /// </summary>
+        private static List<InteractableType> FindTypes(List<Type> types, TypeRestriction typeRestriction)
+        {
+            EnsureCacheForTypes(types, typeRestriction);
+            return GetTypesFromCache(types);
+        }
+
+        /// <summary>
+        /// Gets the list of InteractableType objects for classes that support the specified types by
+        /// looking directly in the cache.
+        /// </summary>
+        /// <remarks>
+        /// Assumes it is called after EnsureCacheForTypes. Otherwise, this is dangerous to call.
+        /// </remarks>
+        private static List<InteractableType> GetTypesFromCache(List<Type> types)
+        {
+            List<InteractableType> interactableTypes = new List<InteractableType>();
+            foreach (Type type in types)
+            {
+                interactableTypes.AddRange(cache[type]);
+            }
+            return interactableTypes;
+        }
+
+        /// <summary>
+        /// Ensures a cache entry is setup for all types in the InteractableType enum.
+        /// </summary>
+        /// <remarks>
+        /// Note that this is not invoked at runtime and is assumed to be invoked from a single
+        /// threaded UI context, and is thus not locked.
+        /// </remarks>
+        private static void EnsureCacheForTypes(List<Type> types, TypeRestriction typeRestriction)
+        {
+            List<Type> cacheMisses = new List<Type>();
+            foreach (Type type in types)
+            {
+                if (!cache.ContainsKey(type))
+                {
+                    cacheMisses.Add(type);
+                }
+            }
+
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+            foreach (Type type in cacheMisses)
+            {
+                cache[type] = GetTypesFromAssemblies(type, typeRestriction, assemblies);
+            }
+        }
+
+        /// <summary>
+        /// Loads the classes that derive from the given type by looking through all of the assemblies.
+        /// </summary>
+        private static List<InteractableType> GetTypesFromAssemblies(Type type, TypeRestriction typeRestriction, Assembly[] assemblies)
+        {
+            List<InteractableType> interactableTypes = new List<InteractableType>();
+            foreach (Assembly assembly in assemblies)
+            {
+                foreach (Type assemblyType in assembly.GetTypes())
+                {
+                    TypeInfo info = assemblyType.GetTypeInfo();
+                    bool exactBaseMatch = typeRestriction == TypeRestriction.AllowBase && assemblyType.Equals(type);
+                    bool derivedMatch = info.BaseType != null && info.BaseType.Equals(type);
+                    if (exactBaseMatch || derivedMatch)
+                    {
+                        InteractableType interactableType = new InteractableType(assemblyType);
+                        interactableTypes.Add(interactableType);
+                    }
+                }
+            }
+            return interactableTypes;
+        }
+#endif
+    }
+}

Assets/MixedRealityToolkit.SDK/Features/UX/Interactable/Scripts/TypeResolution/InteractableTypeFinder.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.UX.Interactable
+{
+    /// <summary>
+    /// A convenience class that holds arrays of class names, fully qualified assembly names
+    /// and their corresponding actual types.
+    /// </summary>
+    /// <remarks>
+    /// This abstraction exists primarily to reduce code duplication among the different
+    /// inspectors which use these lists to populate their dropdowns.
+    /// 
+    /// Note that all of these arrays are the same size and come in the same order
+    /// (so for example, ClassName[0] = "InteractableActivateTheme" means that
+    /// Types[0] == typeof(InteractableActivateTheme) and AssemblyQualifiedNames
+    /// is the assembly qualified name for InteractableActivateTheme.
+    /// </remarks>
+    public class InteractableTypesContainer
+    {
+        /// <summary>
+        /// An array of class names (for example, "InteractableActivateTheme").
+        /// </summary>
+        public string[] ClassNames { get; private set; }
+
+        /// <summary>
+        /// A array of assembly qualified names (for example, 
+        /// "Microsoft.MixedReality.Toolkit.SDK.UX.Interactable.Themes.InteractableActivateTheme, 
+        /// Microsoft.MixedReality.Toolkit.SDK")
+        /// </summary>
+        public string[] AssemblyQualifiedNames { get; private set; }
+
+        /// <summary>
+        /// An array of types. See class remarks for more information on relation to
+        /// other fields.
+        /// </summary>
+        public Type[] Types { get; private set; }
+
+        /// <summary>
+        /// A convenience helper that will unwrap a list of InteractableType objects into
+        /// a form that is more easy consumed by inspector components.
+        /// </summary>
+        public InteractableTypesContainer(List<InteractableType> interactableTypes)
+        {
+            var classNames = new List<string>();
+            var assemblyQualifiedNames = new List<string>();
+            var types = new List<Type>();
+
+            for (int i = 0; i < interactableTypes.Count; i++)
+            {
+                classNames.Add(interactableTypes[i].ClassName);
+                assemblyQualifiedNames.Add(interactableTypes[i].AssemblyQualifiedName);
+                types.Add(interactableTypes[i].Type);
+            }
+
+            ClassNames = classNames.ToArray();
+            AssemblyQualifiedNames = assemblyQualifiedNames.ToArray();
+            Types = types.ToArray();
+        }
+    }
+}