/// <summary>
/// Activates an instance of the specified concrete type using the provided argument collection.
/// </summary>
/// <typeparam name="T">The interface which must be implemented by the concrete type.</typeparam>
/// <param name="concreteType">The type of object to be instantiated.</param>
/// <param name="supportedPlatforms">The platform(s) on which the concrete type is supported.</param>
/// <param name="args">Collection of arguments to provide to the concrete type's constructor.</param>
/// <returns>An instance of the concrete type. Returns a default value of T (typically null) in the event of a failure.</returns>
private T ActivateInstance <T>(Type concreteType, SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1), params object[] args) where T : IMixedRealityService
{
if (concreteType == null)
{
return(default(T));
}
#if UNITY_EDITOR
if (!UnityEditor.EditorUserBuildSettings.activeBuildTarget.IsPlatformSupported(supportedPlatforms))
#else
if (!Application.platform.IsPlatformSupported(supportedPlatforms))
#endif
{
return(default(T));
}
if (!typeof(T).IsAssignableFrom(concreteType))
{
Debug.LogError($"Error: {concreteType.Name} service must implement {typeof(T)}.");
return(default(T));
}
try
{
T serviceInstance = (T)Activator.CreateInstance(concreteType, args);
return(serviceInstance);
}
catch (Exception e)
{
Debug.LogError($"Error: Failed to instantiate {concreteType.Name}: {e.GetType()} - {e.Message}");
return(default(T));
}
}
private static bool IsPluginCompatible(
IFanControlPluginMetadata metadata,
SupportedPlatforms platform,
Version platformVersion,
SupportedCpuArchitectures arch)
{
if (!metadata.SupportedPlatforms.HasFlag(platform))
{
return(false);
}
if (!metadata.SupportedCpuArchitectures.HasFlag(arch))
{
return(false);
}
Version version;
if (Version.TryParse(metadata.MinOSVersion, out version) &&
version > platformVersion)
{
return(false);
}
if (Version.TryParse(metadata.MaxOSVersion, out version) &&
version < platformVersion)
{
return(false);
}
return(true);
}
private static SupportedPlatforms GetSupportedPlatformMask(UnityEditor.BuildTarget editorBuildTarget)
{
SupportedPlatforms supportedPlatforms = 0;
if (Application.platform == RuntimePlatform.WindowsEditor)
{
supportedPlatforms |= SupportedPlatforms.WindowsEditor;
}
switch (editorBuildTarget)
{
case UnityEditor.BuildTarget.StandaloneWindows:
case UnityEditor.BuildTarget.StandaloneWindows64:
supportedPlatforms |= SupportedPlatforms.WindowsStandalone;
break;
case UnityEditor.BuildTarget.WSAPlayer:
case UnityEditor.BuildTarget.XboxOne:
supportedPlatforms |= SupportedPlatforms.WindowsUniversal;
break;
case UnityEditor.BuildTarget.StandaloneOSX:
supportedPlatforms |= SupportedPlatforms.MacStandalone;
break;
case UnityEditor.BuildTarget.StandaloneLinux:
case UnityEditor.BuildTarget.StandaloneLinux64:
case UnityEditor.BuildTarget.StandaloneLinuxUniversal:
supportedPlatforms |= SupportedPlatforms.LinuxStandalone;
break;
}
return(supportedPlatforms);
}
private static SupportedPlatforms GetSupportedPlatformMask(RuntimePlatform runtimePlatform)
{
SupportedPlatforms supportedPlatforms = 0;
switch (runtimePlatform)
{
case RuntimePlatform.WindowsPlayer:
case RuntimePlatform.WindowsEditor:
supportedPlatforms |= SupportedPlatforms.WindowsStandalone;
break;
case RuntimePlatform.WSAPlayerARM:
case RuntimePlatform.WSAPlayerX86:
case RuntimePlatform.WSAPlayerX64:
case RuntimePlatform.XboxOne:
supportedPlatforms |= SupportedPlatforms.WindowsUniversal;
break;
case RuntimePlatform.OSXPlayer:
case RuntimePlatform.OSXEditor:
supportedPlatforms |= SupportedPlatforms.MacStandalone;
break;
case RuntimePlatform.LinuxPlayer:
case RuntimePlatform.LinuxEditor:
supportedPlatforms |= SupportedPlatforms.LinuxStandalone;
break;
}
return(supportedPlatforms);
}
/// <summary>
/// Activates an instance of the specified concrete type using the provided argument collection.
/// </summary>
/// <typeparam name="T">The interface which must be implemented by the concrete type.</typeparam>
/// <param name="concreteType">The type of object to be instantiated.</param>
/// <param name="supportedPlatforms">The platform(s) on which the concrete type is supported.</param>
/// <param name="args">Collection of arguments to provide to the concrete type's constructor.</param>
/// <returns>An instance of the concrete type. Returns a default value of T (typically null) in the event of a failure.</returns>
private T ActivateInstance <T>(Type concreteType, SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1), params object[] args) where T : IMixedRealityService
{
if (concreteType == null)
{
return(default(T));
}
if (!PlatformUtility.IsPlatformSupported(supportedPlatforms))
{
return(default(T));
}
if (!typeof(T).IsAssignableFrom(concreteType))
{
Debug.LogError($"Error: {concreteType.Name} service must implement {typeof(T)}.");
return(default(T));
}
try
{
T serviceInstance = (T)Activator.CreateInstance(concreteType, args);
return(serviceInstance);
}
catch (Exception e)
{
Debug.LogError($"Error: Failed to instantiate {concreteType.Name}: {e.GetType()} - {e.Message}");
return(default(T));
}
}
private void GatherBuildTargets(ProjectFile Project, List <PlatformAndConfigToBuild> OutToBuild)
{
foreach (ProjectTarget Target in Project.ProjectTargets)
{
string ProjectName = Target.TargetRules.Name;
List <UnrealTargetConfiguration> Configs = new List <UnrealTargetConfiguration>();
List <UnrealTargetPlatform> Platforms = new List <UnrealTargetPlatform>();
Target.TargetRules.GetSupportedConfigurations(ref Configs, true);
Target.TargetRules.GetSupportedPlatforms(ref Platforms);
foreach (UnrealTargetPlatform Platform in Platforms)
{
if (SupportedPlatforms.Contains(Platform))
{
foreach (UnrealTargetConfiguration Config in Configs)
{
OutToBuild.Add(new PlatformAndConfigToBuild {
ProjectName = ProjectName, Platform = Platform, Config = Config
});
}
}
}
}
}
public static bool IsSupported(this SupportedPlatforms currentPlatforms, RuntimePlatform platform)
{
switch (platform)
{
case RuntimePlatform.WindowsEditor:
case RuntimePlatform.WindowsPlayer:
return(IsSupported(currentPlatforms, SupportedPlatforms.Windows));
case RuntimePlatform.OSXEditor:
case RuntimePlatform.OSXPlayer:
return(IsSupported(currentPlatforms, SupportedPlatforms.MacOS));
case RuntimePlatform.LinuxEditor:
case RuntimePlatform.LinuxPlayer:
return(IsSupported(currentPlatforms, SupportedPlatforms.Linux));
case RuntimePlatform.WebGLPlayer:
return(IsSupported(currentPlatforms, SupportedPlatforms.Web));
case RuntimePlatform.IPhonePlayer:
return(IsSupported(currentPlatforms, SupportedPlatforms.iOS));
case RuntimePlatform.Android:
return(IsSupported(currentPlatforms, SupportedPlatforms.Android));
default:
return(false);
}
}
/// <inheritdoc />
public bool RegisterDataProvider <T>(
Type concreteType,
SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1),
params object[] args) where T : IMixedRealityDataProvider
{
return(RegisterService <T>(concreteType, supportedPlatforms, args));
}
private static SupportedPlatforms GetSupportedPlatformMask(UnityEditor.BuildTarget editorBuildTarget)
{
SupportedPlatforms supportedPlatforms = 0;
switch (editorBuildTarget)
{
case UnityEditor.BuildTarget.StandaloneWindows:
case UnityEditor.BuildTarget.StandaloneWindows64:
supportedPlatforms |= SupportedPlatforms.WindowsStandalone;
break;
case UnityEditor.BuildTarget.WSAPlayer:
case UnityEditor.BuildTarget.XboxOne:
supportedPlatforms |= SupportedPlatforms.WindowsUniversal;
break;
case UnityEditor.BuildTarget.StandaloneOSX:
supportedPlatforms |= SupportedPlatforms.MacStandalone;
break;
case UnityEditor.BuildTarget.StandaloneLinux:
case UnityEditor.BuildTarget.StandaloneLinux64:
case UnityEditor.BuildTarget.StandaloneLinuxUniversal:
supportedPlatforms |= SupportedPlatforms.LinuxStandalone;
break;
case UnityEditor.BuildTarget.Lumin:
supportedPlatforms |= SupportedPlatforms.Lumin;
break;
}
return(supportedPlatforms);
}
public MixedRealityDataProviderAttribute(
Type serviceInterfaceType,
SupportedPlatforms runtimePlatforms,
string profilePath = "",
string packageFolder = "MixedRealityToolkit") : base(runtimePlatforms, profilePath, packageFolder)
{
ServiceInterfaceType = serviceInterfaceType;
}
public string GetPlatformLink(SupportedPlatforms platform)
{
// Check the platform
string returnUrl = null;
switch (platform)
{
case SupportedPlatforms.NativeIos:
returnUrl = iosNativeLink;
break;
case SupportedPlatforms.WebiOS:
returnUrl = iosWebLink;
break;
case SupportedPlatforms.NativeAmazon:
returnUrl = amazonNativeLink;
break;
case SupportedPlatforms.WebAmazon:
returnUrl = amazonWebLink;
break;
case SupportedPlatforms.NativeAndroid:
returnUrl = androidNativeLink;
if (string.IsNullOrEmpty(returnUrl) == true)
{
returnUrl = amazonNativeLink;
}
break;
case SupportedPlatforms.WebAndroid:
returnUrl = androidWebLink;
if (string.IsNullOrEmpty(returnUrl) == true)
{
returnUrl = amazonWebLink;
}
break;
case SupportedPlatforms.NativeWin10:
returnUrl = windows10NativeLink;
break;
case SupportedPlatforms.WebWin10:
returnUrl = windows10WebLink;
break;
}
// Check if the string is empty
if (string.IsNullOrEmpty(returnUrl) == true)
{
// Replace with a web URL
returnUrl = WebLink;
}
// Return the URL
return(returnUrl);
}
public static bool IsPlatformSupported(SupportedPlatforms platforms)
{
#if UNITY_EDITOR
SupportedPlatforms target = GetSupportedPlatformMask(UnityEditor.EditorUserBuildSettings.activeBuildTarget);
#else
SupportedPlatforms target = GetSupportedPlatformMask(Application.platform);
#endif
return(IsPlatformSupported(target, platforms));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="runtimePlatforms">The platforms on which the extension service is supported.</param>
/// <param name="profilePath">The relative path to the profile asset.</param>
/// <param name="packageFolder">The folder to which the path is relative.</param>
public MixedRealityExtensionServiceAttribute(
SupportedPlatforms runtimePlatforms,
string profilePath = "",
string packageFolder = "MixedRealityToolkit")
{
RuntimePlatforms = runtimePlatforms;
ProfilePath = profilePath;
PackageFolder = packageFolder;
}
private static void UpdateControlVisibility(GameObject[] controls, SupportedPlatforms support)
{
bool active = support.IsSupported();
foreach (GameObject control in controls)
{
control.SetActive(active);
}
}
public FanControlPluginMetadataAttribute(
string uniqueId,
SupportedPlatforms supportedPlatforms,
SupportedCpuArchitectures supportedCpuArchitectures)
: base(typeof(IFanControlPluginMetadata))
{
this.UniqueId = uniqueId;
this.SupportedPlatforms = supportedPlatforms;
this.SupportedCpuArchitectures = supportedCpuArchitectures;
}
public FanControlPluginMetadataAttribute(
string uniqueId,
SupportedPlatforms supportedPlatforms,
SupportedCpuArchitectures supportedCpuArchitectures)
: base(typeof(IFanControlPluginMetadata))
{
this.UniqueId = uniqueId;
this.SupportedPlatforms = supportedPlatforms;
this.SupportedCpuArchitectures = supportedCpuArchitectures;
}
public MixedRealityDataProviderAttribute(
Type serviceInterfaceType,
SupportedPlatforms runtimePlatforms,
string name = "",
string profilePath = "",
string packageFolder = "MixedRealityToolkit",
bool requiresProfile = false) : base(runtimePlatforms, name, profilePath, packageFolder, requiresProfile)
{
ServiceInterfaceType = serviceInterfaceType;
}
public static bool IsThisBuildSupported(this SupportedPlatforms currentPlatforms)
{
bool returnFlag = IsSupported(currentPlatforms, Application.platform);
if ((Singleton.Instance != null) && (Singleton.Instance.IsWebApp == true))
{
returnFlag = IsSupported(currentPlatforms, SupportedPlatforms.Web);
}
return(returnFlag);
}
/// <summary>
/// Initialize a service.
/// </summary>
/// <typeparam name="T">The interface type for the service to be initialized.</typeparam>
/// <param name="concreteType">The concrete type of the service to initialize.</param>
/// <param name="supportedPlatforms">The platform(s) on which the service is supported.</param>
/// <param name="args">Arguments to provide to the service class constructor.</param>
protected virtual void Initialize<T>(Type concreteType, SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1), params object[] args) where T : IMixedRealityService
{
if (!RegisterService<T>(concreteType, supportedPlatforms, args))
{
Debug.LogError($"Failed to register the {concreteType.Name} service.");
}
T serviceInstance = FindService<T>();
serviceInstance?.Initialize();
}
/// <summary>
/// Registers a data provider of the specified type.
/// </summary>
protected bool RegisterDataProvider <T>(
Type concreteType,
SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1),
params object[] args) where T : IMixedRealityDataProvider
{
return(RegisterDataProviderInternal <T>(
true, // Retry with an added IMixedRealityService parameter
concreteType,
supportedPlatforms,
args));
}
protected bool RegisterDataProvider <T>(
Type concreteType,
SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1),
params object[] args) where T : IMixedRealityDataProvider
{
return(RegisterDataProvider <T>(
concreteType,
string.Empty,
supportedPlatforms,
args));
}
/// <summary>
/// Determines whether the specified known platforms is currently supported.
/// </summary>
/// <param name="platformToCheck">The platform to check.</param>
/// <param name="currentPlatform">The current platform.</param>
/// <returns><c>true</c> if the platform is supported; otherwise, <c>false</c>.</returns>
public static bool IsPlatformSupported(KnownPlatforms platformToCheck, SupportedPlatforms currentPlatform)
{
switch (platformToCheck)
{
case KnownPlatforms.Unknown:
return(false);
case KnownPlatforms.NET:
return(currentPlatform == SupportedPlatforms.NET45 ||
currentPlatform == SupportedPlatforms.NET46 ||
currentPlatform == SupportedPlatforms.NET47 ||
currentPlatform == SupportedPlatforms.NET50);
case KnownPlatforms.NET45:
return(currentPlatform == SupportedPlatforms.NET45);
case KnownPlatforms.NET46:
return(currentPlatform == SupportedPlatforms.NET46);
case KnownPlatforms.NET47:
return(currentPlatform == SupportedPlatforms.NET47);
case KnownPlatforms.NET50:
return(currentPlatform == SupportedPlatforms.NET50);
case KnownPlatforms.NetStandard:
return(currentPlatform == SupportedPlatforms.NetStandard20);
case KnownPlatforms.NetStandard20:
return(currentPlatform == SupportedPlatforms.NetStandard20);
case KnownPlatforms.WindowsUniversal:
return(currentPlatform == SupportedPlatforms.WindowsUniversal);
case KnownPlatforms.Xamarin:
return(currentPlatform == SupportedPlatforms.Android ||
currentPlatform == SupportedPlatforms.iOS);
case KnownPlatforms.XamarinAndroid:
return(currentPlatform == SupportedPlatforms.Android);
case KnownPlatforms.XamariniOS:
return(currentPlatform == SupportedPlatforms.iOS);
case KnownPlatforms.XamarinForms:
return(currentPlatform == SupportedPlatforms.PCL);
case KnownPlatforms.PCL:
return(currentPlatform == SupportedPlatforms.PCL);
default:
throw new ArgumentOutOfRangeException("platformToCheck");
}
}
/// <inheritdoc />
public bool RegisterService <T>(Type concreteType, SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1), params object[] args) where T : IMixedRealityService
{
T serviceInstance = ActivateInstance <T>(concreteType, supportedPlatforms, args);
if (serviceInstance == null)
{
return(false);
}
return(RegisterService <T>(serviceInstance));
}
/// <summary>
/// Registers the supported platforms.
/// </summary>
/// <param name="platforms">The platforms.</param>
/// <exception cref="System.ArgumentNullException">platforms</exception>
public static void RegisterSupportedPlatforms(List <SolutionPlatform> platforms)
{
if (platforms == null)
{
throw new ArgumentNullException("platforms");
}
if (SupportedPlatforms.Count > 0)
{
throw new InvalidOperationException("Cannot register new platforms. RegisterSupportedPlatforms can only be called once");
}
SupportedPlatforms.AddRange(platforms);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="componentType">The <see cref="Microsoft.MixedReality.Toolkit.Utilities.SystemType"/> of the observer.</param>
/// <param name="componentName">The friendly name of the observer.</param>
/// <param name="priority">The load priority of the observer.</param>
/// <param name="runtimePlatform">The runtime platform(s) supported by the observer.</param>
/// <param name="configurationProfile">The configuration profile for the observer.</param>
public MixedRealitySpatialObserverConfiguration(
SystemType componentType,
string componentName,
uint priority,
SupportedPlatforms runtimePlatform,
BaseSpatialAwarenessObserverProfile configurationProfile)
{
this.componentType = componentType;
this.componentName = componentName;
this.priority = priority;
this.runtimePlatform = runtimePlatform;
this.observerProfile = configurationProfile;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="runtimePlatforms">The platforms on which the extension service is supported.</param>
/// <param name="defaultProfilePath">The relative path to the default profile asset.</param>
/// <param name="packageFolder">The package folder to which the path is relative.</param>
public MixedRealityExtensionServiceAttribute(
SupportedPlatforms runtimePlatforms,
string name = "",
string defaultProfilePath = "",
string packageFolder = "MixedRealityToolkit",
bool requiresProfile = false)
{
RuntimePlatforms = runtimePlatforms;
Name = name;
DefaultProfilePath = defaultProfilePath;
PackageFolder = packageFolder;
RequiresProfile = requiresProfile;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="componentType">The <see cref="Microsoft.MixedReality.Toolkit.Utilities.SystemType"/> of the data provider.</param>
/// <param name="componentName">The friendly name of the data provider.</param>
/// <param name="priority">The load priority of the data provider.</param>
/// <param name="runtimePlatform">The runtime platform(s) supported by the data provider.</param>
/// <param name="profile">The configuration profile for the data provider.</param>
public MixedRealityInputDataProviderConfiguration(
SystemType componentType,
string componentName,
uint priority,
SupportedPlatforms runtimePlatform,
BaseMixedRealityProfile profile)
{
this.componentType = componentType;
this.componentName = componentName;
this.priority = priority;
this.runtimePlatform = runtimePlatform;
deviceManagerProfile = profile;
}
/// <summary>
/// Checks if the profile can be inspected with the currently active build target and renders
/// a hint to switch build target if not.
/// </summary>
/// <param name="supportedPlatforms">The supported platforms by the profile.</param>
/// <param name="infoText">Optional info text to override info box text.</param>
/// <returns>True, if the profile and the active build target match.</returns>
public static bool CheckProfilePlatform(SupportedPlatforms supportedPlatforms, string infoText = null)
{
if (!PlatformUtility.IsPlatformSupported(EditorUserBuildSettings.activeBuildTarget, supportedPlatforms))
{
EditorGUILayout.HelpBox(string.IsNullOrWhiteSpace(infoText) ?
$"You can't edit this profile with the current build target. Please switch to {supportedPlatforms}."
: infoText, MessageType.Info);
return(false);
}
return(true);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="componentType">The concrete type for the system, feature or manager.</param>
/// <param name="componentName">The simple, human readable name for the system, feature, or manager.</param>
/// <param name="priority">The priority this system, feature, or manager will be initialized in.</param>
/// <param name="runtimePlatform">The runtime platform(s) to run this system, feature, or manager on.</param>
/// <param name="configurationProfile">The configuration profile for the service.</param>
public MixedRealityServiceConfiguration(
SystemType componentType,
string componentName,
uint priority,
SupportedPlatforms runtimePlatform,
BaseMixedRealityProfile configurationProfile)
{
this.componentType = componentType;
this.componentName = componentName;
this.priority = priority;
this.runtimePlatform = runtimePlatform;
this.configurationProfile = configurationProfile;
}
public PlatformSettings(SupportedPlatforms platform, AdvertiserId appId, AdvertiserId idBanner, AdvertiserId idInterstitial, AdvertiserId idRewarded, bool hasBanner, bool hasInterstitial, bool hasRewarded)
{
this.platform = platform;
this.appId = appId;
this.idBanner = idBanner;
this.idInterstitial = idInterstitial;
this.idRewarded = idRewarded;
this.hasBanner = hasBanner;
this.hasInterstitial = hasInterstitial;
this.hasRewarded = hasRewarded;
enabled = false;
directedForChildren = false;
}
public void TestAddOrReplace()
{
var supportedPlatforms = new SupportedPlatforms();
CollectionAssert.IsEmpty(supportedPlatforms);
supportedPlatforms.AddOrReplaceMinimumRequirement(DbPlatform.SqlServer2008);
CollectionAssert.AreEquivalent(new[] { "SqlServer, Version: 10, Driver: AdoNet" }, supportedPlatforms.Select(n => n.ToString()).ToArray());
supportedPlatforms.AddOrReplaceMinimumRequirement(DbPlatform.SqlServer2012);
CollectionAssert.AreEquivalent(new[] { "SqlServer, Version: 11, Driver: AdoNet" }, supportedPlatforms.Select(n => n.ToString()).ToArray());
supportedPlatforms.AddOrReplaceMinimumRequirement(new DbPlatform(Platform.SqlServer, 12, Driver.Odbc));
CollectionAssert.AreEquivalent(new[]
{
"SqlServer, Version: 11, Driver: AdoNet",
"SqlServer, Version: 12, Driver: Odbc"
}, supportedPlatforms.Select(n => n.ToString()).ToArray());
}
/// <summary>
/// Registers a data provider of the specified type.
/// </summary>
/// <typeparam name="T">The interface type of the data provider to be registered.</typeparam>
/// <returns>True if the data provider was successfully registered, false otherwise.</returns>
protected bool RegisterDataProvider <T>(
Type concreteType,
SupportedPlatforms supportedPlatforms = (SupportedPlatforms)(-1),
params object[] args) where T : IMixedRealityDataProvider
{
#if !UNITY_EDITOR
if (!Application.platform.IsPlatformSupported(supportedPlatforms))
#else
if (!EditorUserBuildSettings.activeBuildTarget.IsPlatformSupported(supportedPlatforms))
#endif
{
return(false);
}
if (concreteType == null)
{
Debug.LogError($"Unable to register {typeof(T).Name} service with a null concrete type.");
return(false);
}
if (!typeof(IMixedRealityDataProvider).IsAssignableFrom(concreteType))
{
Debug.LogError($"Unable to register the {concreteType.Name} data provider. It does not implement {typeof(IMixedRealityDataProvider)}.");
return(false);
}
T dataProviderInstance;
try
{
dataProviderInstance = (T)Activator.CreateInstance(concreteType, args);
}
catch (Exception e)
{
Debug.LogError($"Failed to register the {concreteType.Name} data provider: {e.GetType()} - {e.Message}");
// Failures to create the concrete type generally surface as nested exceptions - just logging
// the top level exception itself may not be helpful. If there is a nested exception (for example,
// null reference in the constructor of the object itself), it's helpful to also surface those here.
if (e.InnerException != null)
{
Debug.LogError("Underlying exception information: " + e.InnerException);
}
return(false);
}
return(RegisterDataProvider(dataProviderInstance));
}
public IdentifiableItemBase(IIdentifiable itemInstance, IComposition composition)
{
Contract.Requires(itemInstance != null, "itemInstance != null");
Contract.Requires(composition != null, "composition != null");
_composition = composition;
_guid = Guid.NewGuid().ToString();
_cachedInstanceId = itemInstance.Id;
_cachedInstanceDescribes = new Describes(itemInstance);
_cachedCaptionEdited = false;
_cachedDescriptionEdited = false;
_itemInstance = itemInstance;
_xConstructor = Constructor(itemInstance);
_xConnectivity = Connectivity(itemInstance);
if (itemInstance is IBaseLinkableComponentProposed)
_platforms = ((IBaseLinkableComponentProposed)itemInstance).SupportedPlatforms;
else if (itemInstance is IBaseExchangeItemProposed)
_platforms = ((IBaseExchangeItemProposed)itemInstance).SupportedPlatforms;
else
_platforms = composition.Platforms;
if (itemInstance is IBaseLinkableComponent)
_interface = IdentifiableItemType.IBaseLinkableComponent;
else if (itemInstance is IBaseAdaptedOutput)
_interface = IdentifiableItemType.IBaseAdaptedOutput;
else if (itemInstance is IBaseOutput)
_interface = IdentifiableItemType.IBaseOutput;
else if (itemInstance is IBaseInput)
_interface = IdentifiableItemType.IBaseInput;
else if (itemInstance is IAdaptedOutputFactory)
_interface = IdentifiableItemType.IAdaptedOutputFactory;
else
_interface = IdentifiableItemType.Unknown;
}
public static XElement Persist(SupportedPlatforms platforms, IDocumentAccessor accessor)
{
return new XElement(Component.NamespaceOpenMIv2 + "Platforms",
Persist(platforms).Select(value => new XElement(Component.NamespaceOpenMIv2 + "Platform", value)));
}
/// <summary>
/// Determines whether the specified known platforms is currently supported.
/// </summary>
/// <param name="platformToCheck">The platform to check.</param>
/// <param name="currentPlatform">The current platform.</param>
/// <returns><c>true</c> if the platform is supported; otherwise, <c>false</c>.</returns>
public static bool IsPlatformSupported(KnownPlatforms platformToCheck, SupportedPlatforms currentPlatform)
{
switch (platformToCheck)
{
case KnownPlatforms.Unknown:
return false;
case KnownPlatforms.NET:
return currentPlatform == SupportedPlatforms.NET40 ||
currentPlatform == SupportedPlatforms.NET45 ||
currentPlatform == SupportedPlatforms.NET46 ||
currentPlatform == SupportedPlatforms.NET50;
case KnownPlatforms.NET40:
return currentPlatform == SupportedPlatforms.NET40;
case KnownPlatforms.NET45:
return currentPlatform == SupportedPlatforms.NET45;
case KnownPlatforms.NET46:
return currentPlatform == SupportedPlatforms.NET46;
case KnownPlatforms.NET50:
return currentPlatform == SupportedPlatforms.NET50;
case KnownPlatforms.Silverlight:
return currentPlatform == SupportedPlatforms.Silverlight5;
case KnownPlatforms.Silverlight5:
return currentPlatform == SupportedPlatforms.Silverlight5;
case KnownPlatforms.WindowsPhone:
return currentPlatform == SupportedPlatforms.WindowsPhone80 ||
currentPlatform == SupportedPlatforms.WindowsPhone81Silverlight ||
currentPlatform == SupportedPlatforms.WindowsPhone81Runtime;
case KnownPlatforms.WindowsPhoneSilverlight:
return currentPlatform == SupportedPlatforms.WindowsPhone80 ||
currentPlatform == SupportedPlatforms.WindowsPhone81Silverlight;
case KnownPlatforms.WindowsPhoneRuntime:
return currentPlatform == SupportedPlatforms.WindowsPhone81Runtime;
case KnownPlatforms.WindowsPhone80:
return currentPlatform == SupportedPlatforms.WindowsPhone80;
case KnownPlatforms.WindowsPhone81Silverlight:
return currentPlatform == SupportedPlatforms.WindowsPhone81Silverlight;
case KnownPlatforms.WindowsPhone81Runtime:
return currentPlatform == SupportedPlatforms.WindowsPhone81Runtime;
case KnownPlatforms.WindowsRuntime:
return currentPlatform == SupportedPlatforms.WindowsRuntime80 ||
currentPlatform == SupportedPlatforms.WindowsRuntime81;
case KnownPlatforms.WindowsRuntime80:
return currentPlatform == SupportedPlatforms.WindowsRuntime80;
case KnownPlatforms.WindowsRuntime81:
return currentPlatform == SupportedPlatforms.WindowsRuntime81;
case KnownPlatforms.WindowsUniversal:
return currentPlatform == SupportedPlatforms.WindowsUniversal100;
case KnownPlatforms.WindowsUniversal100:
return currentPlatform == SupportedPlatforms.WindowsUniversal100;
case KnownPlatforms.Xamarin:
return currentPlatform == SupportedPlatforms.Android ||
currentPlatform == SupportedPlatforms.iOS;
case KnownPlatforms.XamarinAndroid:
return currentPlatform == SupportedPlatforms.Android;
case KnownPlatforms.XamariniOS:
return currentPlatform == SupportedPlatforms.iOS;
case KnownPlatforms.PCL:
return currentPlatform == SupportedPlatforms.PCL;
default:
throw new ArgumentOutOfRangeException("platformToCheck");
}
}
public static bool Instantiate(
ExternalType componentType,
SupportedPlatforms platforms,
List<IReport> reports,
out IBaseLinkableComponent component)
{
Contract.Requires(componentType != null, "componentType != null");
Contract.Requires(reports != null, "reports != null");
component = null;
Type type;
try
{
component = componentType
.CreateInstance(out type) as IBaseLinkableComponent;
}
catch (System.Exception e)
{
reports.Add(Report.Error(Report.ResourceIds.Instantiation,
"Cannot instantiate IBaseLinkableComponent", e.Message));
return false;
}
if (component == null)
{
reports.Add(Report.Error(Report.ResourceIds.Instantiation,
"Cannot instantiate IBaseLinkableComponent", type.ToString()));
return false;
}
return true;
}
public static bool Parse(
XElement xLinkableComponent,
IDocumentAccessor accessor,
List<IReport> reports,
out ExternalType component,
out SupportedPlatforms platforms,
out List<Argument> argumentsOmi)
{
Contract.Requires(reports != null, "reports != null");
component = null;
platforms = SupportedPlatforms.Unknown;
argumentsOmi = new List<Argument>();
var ns = xLinkableComponent.Name.Namespace;
if (!Validates(xLinkableComponent, Xsd.ComponentV2, reports))
return false;
var xArgs = xLinkableComponent.Elements(NamespaceOpenMIv2.GetName(XArguments)).SingleOrDefault();
var xArguments = xArgs != null
? xArgs.Elements(NamespaceOpenMIv2.GetName(XArgument))
: null;
var xPlatforms = xLinkableComponent.Elements(NamespaceOpenMIv2.GetName(XPlatforms)).SingleOrDefault();
var assembly = Utilities.Xml.GetAttribute(xLinkableComponent, XAssembly);
var type = Utilities.Xml.GetAttribute(xLinkableComponent, XType);
AssemblyName assemblyName;
Uri codeBaseUri = null;
if (!ExternalType.AssemblyNameGet(assembly, codeBaseUri, type, reports, accessor, out assemblyName))
return false;
component = new ExternalType(accessor);
component.Initialise(assemblyName, type);
if (xArguments != null)
argumentsOmi.AddRange(xArguments
.Select(x => new Argument(x, accessor)));
platforms = Platforms.Parse(xPlatforms, accessor);
return true;
}
public static XElement Persist(
IBaseLinkableComponent component,
SupportedPlatforms platforms,
IDocumentAccessor accessor)
{
// Original intention was to filter out arguments that were read only or
// set explicitly to their default values to simplify what user sees by reducing
// verbosity. However, components that aggregate other components might need to process
// all the aggregated component arguments before those aggregated components ever get
// instantiated (when defaults etc. would normally become visible).
// Hence, welcome verbosity my DEAR old friend.
Contract.Requires(component != null, "component != null");
var args = component
.Arguments
.Select(a => ArgumentValueGet(a, accessor));
return Persist(component, platforms, args, accessor);
}
public static XElement Persist(
IBaseLinkableComponent component,
SupportedPlatforms platforms,
IEnumerable<Argument> argumentsOmi,
IDocumentAccessor accessor)
{
Contract.Requires(component != null, "component != null");
Contract.Requires(argumentsOmi != null, "arguments != null");
var location = new Uri(component.GetType().Assembly.Location);
if (accessor != null && accessor.Uri != null)
location = accessor.Uri.MakeRelativeUri(location);
return new XElement(NamespaceOpenMIv2 + "LinkableComponent",
new XAttribute("Type", component.GetType().ToString()),
new XAttribute("Assembly", location.ToString()),
new XElement(NamespaceOpenMIv2 + "Arguments",
argumentsOmi.Select(a => a.Persist(accessor))),
Platforms.Persist(platforms, accessor));
}
public virtual void Initialise(XElement xElement, IDocumentAccessor accessor)
{
xElement = Persistence.ThisOrSingleChild(XName, xElement);
_guid = Utilities.Xml.GetAttribute(xElement, "id");
_cachedInstanceId = Utilities.Xml.GetAttribute(xElement, "instanceId");
var interfaceType = Utilities.Xml.GetAttribute(xElement, "interface");
_cachedCaptionEdited = Utilities.Xml.GetAttribute(xElement, "captionEdited", false);
_cachedDescriptionEdited = Utilities.Xml.GetAttribute(xElement, "descriptionEdited", false);
var caption = Utilities.Xml.GetAttribute(xElement, "caption");
var description = _cachedDescriptionEdited
? xElement.Element("Description").Value
: "Description unavailable until ItemInstance(composition) accessed";
_cachedInstanceDescribes = new Describes(caption, description);
_cachedCaptionEdited = true;
_xConstructor = Persistence.ThisOrSingleChild(XConstructor, xElement);
_xConnectivity = Persistence.ThisOrSingleChild(XConnectivity, xElement);
_platforms = Persistence.PlatformsChi.Parse(xElement, accessor);
_interface = (IdentifiableItemType)Enum.Parse(typeof(IdentifiableItemType), interfaceType);
}
public void ReturnsFalseForUnsupportedPlatform(KnownPlatforms platformToCheck, SupportedPlatforms currentPlatform)
{
Assert.IsFalse(Platforms.IsPlatformSupported(platformToCheck, currentPlatform));
}
static List<string> Persist(SupportedPlatforms platforms)
{
var values = new List<string>();
if ((platforms & SupportedPlatforms.Win) != 0)
values.Add(SupportedPlatforms.Win.ToString());
if ((platforms & SupportedPlatforms.Win32) != 0)
values.Add(SupportedPlatforms.Win32.ToString());
if ((platforms & SupportedPlatforms.Win64) != 0)
values.Add(SupportedPlatforms.Win64.ToString());
if ((platforms & SupportedPlatforms.Unix) != 0)
values.Add(SupportedPlatforms.Unix.ToString());
if ((platforms & SupportedPlatforms.Unix32) != 0)
values.Add(SupportedPlatforms.Unix32.ToString());
if ((platforms & SupportedPlatforms.Unix64) != 0)
values.Add(SupportedPlatforms.Unix64.ToString());
if ((platforms & SupportedPlatforms.Linux) != 0)
values.Add(SupportedPlatforms.Linux.ToString());
if ((platforms & SupportedPlatforms.Linux32) != 0)
values.Add(SupportedPlatforms.Linux32.ToString());
if ((platforms & SupportedPlatforms.Linux64) != 0)
values.Add(SupportedPlatforms.Linux64.ToString());
if ((platforms & SupportedPlatforms.Mac) != 0)
values.Add(SupportedPlatforms.Mac.ToString());
if ((platforms & SupportedPlatforms.Mac32) != 0)
values.Add(SupportedPlatforms.Mac32.ToString());
if ((platforms & SupportedPlatforms.Mac64) != 0)
values.Add(SupportedPlatforms.Mac64.ToString());
return values;
}
