static void RunAvailabilityCheck(SupportsInstall supportsInstall, SessionAvailability availability)
{
ARSession.s_State = ARSessionState.None;
InitMock(supportsInstall, availability);
CheckAvailabilitySync();
DeinitMock();
}
/// <summary>
/// Begin installing AR software on the current device (if supported).
/// </summary>
/// <remarks>
/// Installation may be asynchronous, so this is implemented as a coroutine.
/// It is safe to call this multiple times; if called a second time while an installation
/// is in process, it returns a new coroutine which waits on the first.
/// </remarks>
/// <returns>An <c>IEnumerator</c> used for a coroutine.</returns>
public static IEnumerator Install()
{
if (systemState == ARSystemState.Installing)
{
yield return(new WaitWhile(() => { return systemState == ARSystemState.Installing; }));
}
if ((sessionSubsystem == null) || (systemState != ARSystemState.NeedsInstall))
{
yield break;
}
systemState = ARSystemState.Installing;
var installPromise = sessionSubsystem.InstallAsync();
yield return(installPromise);
var installStatus = installPromise.result;
if (installStatus == SessionInstallationStatus.Success)
{
systemState = ARSystemState.Ready;
s_Availability = (s_Availability | SessionAvailability.Installed);
}
else if (installStatus == SessionInstallationStatus.ErrorUserDeclined)
{
systemState = ARSystemState.NeedsInstall;
}
else
{
systemState = ARSystemState.Unsupported;
}
}
static void InitMock(SupportsInstall supportsInstall, SessionAvailability availability)
{
MockLoader.supportsInstall = supportsInstall;
MockProvider.availability = availability;
var xrManager = ScriptableObject.CreateInstance <XRManagerSettings>();
xrManager.loaders.Clear();
xrManager.loaders.Add(ScriptableObject.CreateInstance <MockLoader>());
xrManager.InitializeLoaderSync();
XRGeneralSettings.Instance = ScriptableObject.CreateInstance <XRGeneralSettings>();
XRGeneralSettings.Instance.Manager = xrManager;
}
/// <summary>
/// Start checking the availability of AR on the current device.
/// </summary>
/// <remarks>
/// The availability check may be asynchronous, so this is implemented as a coroutine.
/// It is safe to call this multiple times; if called a second time while an availability
/// check is being made, it returns a new coroutine which waits on the first.
/// </remarks>
/// <returns>An <c>IEnumerator</c> used for a coroutine.</returns>
public static IEnumerator CheckAvailability()
{
if (systemState == ARSystemState.CheckingAvailability)
{
yield return(new WaitWhile(() => { return systemState == ARSystemState.CheckingAvailability; }));
}
// Availability has already been determined if we make it here and the state is not None.
if (systemState != ARSystemState.None)
{
yield break;
}
if (sessionSubsystem == null)
{
systemState = ARSystemState.Unsupported;
}
else if (systemState == ARSystemState.None)
{
systemState = ARSystemState.CheckingAvailability;
var availabilityPromise = sessionSubsystem.GetAvailabilityAsync();
yield return(availabilityPromise);
s_Availability = availabilityPromise.result;
if (s_Availability.IsSupported() && s_Availability.IsInstalled())
{
systemState = ARSystemState.Ready;
}
else if (s_Availability.IsSupported() && !s_Availability.IsInstalled())
{
systemState = ARSystemState.NeedsInstall;
}
else
{
systemState = ARSystemState.Unsupported;
}
}
}
/// <summary>
/// A helper method for <see cref="SessionAvailability"/> flags.
/// </summary>
/// <param name="availability">A <see cref="SessionAvailability"/> enum</param>
/// <returns>True if the <see cref="SessionAvailability.Installed"/> flag is set.</returns>
public static bool IsInstalled(this SessionAvailability availability)
{
return((availability & SessionAvailability.Installed) != SessionAvailability.None);
}
/// <summary>
/// A helper method for <see cref="SessionAvailability"/> flags.
/// </summary>
/// <param name="availability">A <see cref="SessionAvailability"/> enum</param>
/// <returns>True if the <see cref="SessionAvailability.Supported"/> flag is set.</returns>
public static bool IsSupported(this SessionAvailability availability)
{
return((availability & SessionAvailability.Supported) != SessionAvailability.None);
}
