/// <summary>
/// Draw the GUI
/// </summary>
public override void OnInspectorGUI()
{
if (service == null)
{
var hook = target as ServiceDisplayHook;
if (hook != null)
{
serviceName = hook.gameObject.name;
if (MixedRealityToolkit.IsInitialized)
{
service = MixedRealityServiceRegistry.GetAllServices()
.FirstOrDefault(p => p.Name == serviceName);
}
}
}
if (service != null)
{
DrawInspectorGUI(service, service.GetType().FullName);
}
else
{
DrawHeader($"No service with name {serviceName} found");
}
}
public void TestGetAllServicesAscendingOrderAfterRemoval()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
ITestExtensionService3 service3 = new TestExtensionService3("Service3", 10, null);
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService3>(service3);
ITestExtensionService1 service1 = new TestExtensionService1("Service1", 20, null);
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService1>(service1);
ITestExtensionService2 service2 = new TestExtensionService2("Service2", 30, null);
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService2>(service2);
MixedRealityToolkit.Instance.UnregisterService <ITestExtensionService2>();
// The order should be service3, service1 because:
// service3 priority = 10
// service1 priority = 20
CollectionAssert.AreEqual(
new List <IMixedRealityService>()
{
service3, service1
},
MixedRealityServiceRegistry.GetAllServices());
}
public IEnumerator VerifyServiceCount()
{
MixedRealityToolkitConfigurationProfile profile1 = LoadTestProfile(BoundaryOnlyProfilePath);
yield return(null);
// Initialize the test case with profile 1
InitializeTest(profile1);
// Get count of registered services
IReadOnlyList <IMixedRealityService> services = MixedRealityServiceRegistry.GetAllServices();
int count1 = services.Count;
yield return(null);
// Switch to profile 2
MixedRealityToolkitConfigurationProfile profile2 = LoadTestProfile(DefaultHoloLens2ProfilePath);
ChangeProfile(profile2);
yield return(null);
// Get count of registered services
services = MixedRealityServiceRegistry.GetAllServices();
int count2 = services.Count;
// We specifically selected the test profiles to ensure that they load a different number of services.
Assert.IsTrue(count1 != count2);
}
public void Test01_CreateMixedRealityInputSystem()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
// Create a Input System Profiles
var inputSystemProfile = ScriptableObject.CreateInstance <MixedRealityInputSystemProfile>();
inputSystemProfile.FocusProviderType = typeof(FocusProvider);
inputSystemProfile.RaycastProviderType = typeof(DefaultRaycastProvider);
inputSystemProfile.InputActionsProfile = ScriptableObject.CreateInstance <MixedRealityInputActionsProfile>();
inputSystemProfile.InputActionRulesProfile = ScriptableObject.CreateInstance <MixedRealityInputActionRulesProfile>();
inputSystemProfile.PointerProfile = ScriptableObject.CreateInstance <MixedRealityPointerProfile>();
inputSystemProfile.PointerProfile.GazeProviderType = typeof(GazeProvider);
inputSystemProfile.GesturesProfile = ScriptableObject.CreateInstance <MixedRealityGesturesProfile>();
inputSystemProfile.SpeechCommandsProfile = ScriptableObject.CreateInstance <MixedRealitySpeechCommandsProfile>();
inputSystemProfile.ControllerVisualizationProfile = ScriptableObject.CreateInstance <MixedRealityControllerVisualizationProfile>();
inputSystemProfile.ControllerMappingProfile = ScriptableObject.CreateInstance <MixedRealityControllerMappingProfile>();
MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile = inputSystemProfile;
// Add Input System
bool didRegister = MixedRealityToolkit.Instance.RegisterService <IMixedRealityInputSystem>(new MixedRealityInputSystem(MixedRealityToolkit.Instance, MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile));
// Tests
Assert.IsTrue(didRegister);
Assert.AreEqual(1, MixedRealityServiceRegistry.GetAllServices().Count);
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <IMixedRealityInputSystem>());
}
public void CreateInputSystem()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile = CreateDefaultInputSystemProfile();
// Add Input System
bool didRegister = MixedRealityToolkit.Instance.RegisterService <IMixedRealityInputSystem>(new MixedRealityInputSystem(MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile));
// Tests
Assert.IsTrue(didRegister);
Assert.AreEqual(1, MixedRealityServiceRegistry.GetAllServices().Count);
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <IMixedRealityInputSystem>());
}
public void TestRegisterMixedRealityExtensionService()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
// Register ITestExtensionService1
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1", 10, null));
// Retrieve ITestExtensionService1
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <IMixedRealityExtensionService>());
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <ITestExtensionService1>());
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <TestExtensionService1>());
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <BaseExtensionService>());
Assert.AreEqual(1, MixedRealityServiceRegistry.GetAllServices().Count);
}
public void TestDataProviderRegistration()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile = AssetDatabase.LoadAssetAtPath <MixedRealityInputSystemProfile>(TestInputSystemProfilePath);
var inputSystem = new MixedRealityInputSystem(MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile);
Assert.IsTrue(MixedRealityToolkit.Instance.RegisterService <IMixedRealityInputSystem>(inputSystem));
// Since EditMode, we have to auto-enable MRTK input system ourselves
MixedRealityToolkit.Instance.EnableAllServicesByType(typeof(IMixedRealityInputSystem));
Assert.AreEqual(1, MixedRealityServiceRegistry.GetAllServices().Count);
Assert.IsNotNull(MixedRealityToolkit.Instance.GetService <IMixedRealityInputSystem>());
var dataProviderAccess = (inputSystem as IMixedRealityDataProviderAccess);
Assert.IsNotNull(dataProviderAccess);
var dataProvider = dataProviderAccess.GetDataProvider <TestInputDataProvider>();
Assert.IsNotNull(dataProvider);
Assert.IsTrue(dataProvider.IsInitialized);
Assert.IsTrue(dataProvider.IsEnabled);
inputSystem.Disable();
Assert.IsFalse(dataProvider.IsEnabled);
inputSystem.Enable();
// We still have reference to old dataProvider, check still disabled
Assert.IsFalse(dataProvider.IsEnabled);
// dataProvider has been unregistered in Disable and new one created by Enable.
dataProvider = dataProviderAccess.GetDataProvider <TestInputDataProvider>();
Assert.IsNotNull(dataProvider);
Assert.IsTrue(dataProvider.IsEnabled);
inputSystem.Reset();
LogAssert.Expect(LogType.Log, "TestDataProvider Reset");
Assert.IsFalse(dataProvider.IsEnabled);
// dataProvider has been unregistered and newly created in Reset
dataProvider = dataProviderAccess.GetDataProvider <TestInputDataProvider>();
Assert.IsNotNull(dataProvider);
Assert.IsTrue(dataProvider.IsInitialized);
Assert.IsTrue(dataProvider.IsEnabled);
}
public void TestRegisterMixedRealityExtensionServices()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
// Add test ExtensionService
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1", 10, null));
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService2>(new TestExtensionService2("Test ExtensionService 2", 10, null));
// Retrieve all registered IMixedRealityExtensionServices
var extensionServices = MixedRealityToolkit.Instance.GetServices <IMixedRealityExtensionService>();
var serviceCount = MixedRealityServiceRegistry.GetAllServices().Count;
// Tests
Assert.IsNotNull(MixedRealityToolkit.Instance.ActiveProfile);
Assert.AreEqual(2, serviceCount);
Assert.AreEqual(extensionServices.Count, serviceCount);
}
public void TestUnregisterMixedRealityExtensionServicesByType()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
// Add test ExtensionService
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1", 10, null));
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService2>(new TestExtensionService2("Test ExtensionService 2", 10, null));
// Retrieve all registered IMixedRealityExtensionServices
var extensionServices = MixedRealityToolkit.Instance.GetServices <IMixedRealityExtensionService>();
var serviceCount = MixedRealityServiceRegistry.GetAllServices().Count;
// Tests
Assert.IsNotNull(MixedRealityToolkit.Instance.ActiveProfile);
Assert.AreEqual(2, serviceCount);
Assert.AreEqual(extensionServices.Count, serviceCount);
// Retrieve services
var extensionService1 = MixedRealityToolkit.Instance.GetService <ITestExtensionService1>();
var extensionService2 = MixedRealityToolkit.Instance.GetService <ITestExtensionService2>();
// Validate
Assert.IsNotNull(extensionService1);
Assert.IsNotNull(extensionService2);
var success1 = MixedRealityToolkit.Instance.UnregisterService <ITestExtensionService1>();
var success2 = MixedRealityToolkit.Instance.UnregisterService <ITestExtensionService2>();
// Validate non-existent service
var isService1Registered = MixedRealityToolkit.Instance.IsServiceRegistered <ITestExtensionService1>();
var isService2Registered = MixedRealityToolkit.Instance.IsServiceRegistered <ITestExtensionService2>();
// Tests
Assert.IsTrue(success1);
Assert.IsTrue(success2);
Assert.IsFalse(isService1Registered);
Assert.IsFalse(isService2Registered);
Assert.IsEmpty(MixedRealityServiceRegistry.GetAllServices());
}
public void TestUnregisterMixedRealityExtensionServiceByType()
{
TestUtilities.InitializeMixedRealityToolkitAndCreateScenes();
// Register ITestExtensionService1
MixedRealityToolkit.Instance.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1", 10, null));
// Retrieve ITestExtensionService1
var extensionService1 = MixedRealityToolkit.Instance.GetService <ITestExtensionService1>();
// Tests
Assert.IsNotNull(extensionService1);
Assert.AreEqual(1, MixedRealityServiceRegistry.GetAllServices().Count);
var success = MixedRealityToolkit.Instance.UnregisterService <ITestExtensionService1>();
// Validate non-existent service
var isServiceRegistered = MixedRealityToolkit.Instance.IsServiceRegistered <ITestExtensionService1>();
// Tests
Assert.IsTrue(success);
Assert.IsFalse(isServiceRegistered);
Assert.IsEmpty(MixedRealityServiceRegistry.GetAllServices());
}
private static HashSet <IMixedRealityService> GetAllServices()
{
HashSet <IMixedRealityService> serviceList = new HashSet <IMixedRealityService>(MixedRealityServiceRegistry.GetAllServices());
// These are core systems that are likely out-of-box services and known to have register DataProviders
// Search for any dataproviders that service facades can be created for
var dataProviderManagers = new IMixedRealityService[] { CoreServices.InputSystem, CoreServices.SpatialAwarenessSystem };
foreach (var system in dataProviderManagers)
{
var dataProviderAccess = system as IMixedRealityDataProviderAccess;
if (dataProviderAccess != null)
{
foreach (var dataProvider in dataProviderAccess.GetDataProviders())
{
serviceList.Add(dataProvider);
}
}
}
return(serviceList);
}
private static void UpdateServiceFacades()
{
if (!MixedRealityToolkit.IsInitialized)
{ // Nothing to do here.
return;
}
if (EditorApplication.isCompiling)
{ // Wait for compilation to complete before creating or destroying facades
return;
}
if (Application.isPlaying && Time.frameCount == previousFrameCount)
{ // Only update once per frame (SceneGUI + Update may result in multiple calls)
return;
}
previousFrameCount = Time.frameCount;
if (previousActiveInstance != null && MixedRealityToolkit.Instance != previousActiveInstance)
{ // We've changed active instances. Destroy all children in the previous instance.
DestroyAllChildren(previousActiveInstance);
}
if (MixedRealityToolkit.Instance.HasActiveProfile && !MixedRealityToolkit.Instance.ActiveProfile.UseServiceInspectors)
{ // If we're not using inspectors, destroy them all now
DestroyAllChildren(MixedRealityToolkit.Instance);
return;
}
servicesToSort.Clear();
servicesToSort.AddRange(MixedRealityServiceRegistry.GetAllServices());
IMixedRealityInputSystem inputSystem;
MixedRealityServiceRegistry.TryGetService(out inputSystem);
if (inputSystem != null)
{
servicesToSort.AddRange((inputSystem as IMixedRealityDataProviderAccess).GetDataProviders());
}
servicesToSort.Sort(
delegate(IMixedRealityService s1, IMixedRealityService s2)
{
string s1Name = s1.GetType().Name;
string s2Name = s2.GetType().Name;
if (s1Name == s2Name)
{
return(s1.Priority.CompareTo(s2.Priority));
}
return(s1Name.CompareTo(s2Name));
});
for (int i = 0; i < servicesToSort.Count; i++)
{
CreateFacade(MixedRealityToolkit.Instance.transform, servicesToSort[i], i);
}
// Delete any stragglers
childrenToDelete.Clear();
for (int i = servicesToSort.Count; i < MixedRealityToolkit.Instance.transform.childCount; i++)
{
childrenToDelete.Add(MixedRealityToolkit.Instance.transform.GetChild(i));
}
foreach (Transform childToDelete in childrenToDelete)
{
if (Application.isPlaying)
{
GameObject.Destroy(childToDelete.gameObject);
}
else
{
GameObject.DestroyImmediate(childToDelete.gameObject);
}
}
try
{
// Update all self-registered facades
foreach (ServiceFacade facade in ServiceFacade.ActiveFacadeObjects)
{
if (facade == null)
{
continue;
}
facade.CheckIfStillValid();
}
}
catch (Exception)
{
Debug.LogWarning("Service Facades should remain parented under the MixedRealityToolkit instance.");
}
previousActiveInstance = MixedRealityToolkit.Instance;
}
