public void Tracking_GetInheritedEngine()
{
var engine = TrackingEngine.GetEngine(() => Tracking_GetInheritedEngine());
Assert.IsNotNull(engine);
Assert.IsInstanceOfType(engine, typeof(UniversalAnalytics));
}
/// <summary>
/// Creates a new <see cref="PreparedTrackingRequest"/> which performs no additional
/// finalization on a request object.
/// </summary>
/// <param name="engine">The <see cref="TrackingEngine"/> managing the tracking request</param>
/// <param name="request">The <see cref="IRestRequest"/> representing the current request</param>
/// <param name="requiredFinalizations">The <see cref="ITrackingModule"/>s which require finalization of the request before sending</param>
public PreparedTrackingRequest(TrackingEngine engine, IRestRequest request, IEnumerable <ITrackingFinalize> requiredFinalizations)
{
Engine = engine;
RequestID = Guid.NewGuid();
RequiredFinalizations = requiredFinalizations;
Request = request;
}
public void Tracking_CreateEngine()
{
var engine = TrackingEngine.Create(Account, x => new UniversalAnalytics(x));
Assert.IsNotNull(engine);
Assert.IsInstanceOfType(engine, typeof(UniversalAnalytics));
Assert.AreEqual(Account, engine.TrackingID);
}
/// <summary>
/// Creates a <see cref="PreparedTrackingRequest"/> from a serialized <see cref="PreparedTrackingRequest"/> object.
/// </summary>
public PreparedTrackingRequest(SerializationInfo info, StreamingContext context)
{
Engine = TrackingEngine.GetEngineByID(info.GetString("Engine"));
RequestID = (Guid)info.GetValue("RequestID", typeof(Guid));
RequiredFinalizations = (IEnumerable <ITrackingFinalize>)info.GetValue("RequiredFinalizations", typeof(IEnumerable <ITrackingFinalize>));
Request = DeserializeRequest(info, context);
}
public static void Main(string[] args)
{
// Setup the name of your application (used to persist events across sessions)
BlobCache.ApplicationName = "SierraLib.Analytics.Example";
Console.WriteLine("Sending events from previous session");
TrackingEngine.ProcessStoredRequests();
new Program().Run();
}
public void Tracking_SetUserAgent()
{
var engine = TrackingEngine.GetEngine(() => Tracking_SetUserAgent());
Assert.IsNotNull(engine);
Assert.IsInstanceOfType(engine, typeof(UniversalAnalytics));
var oldUserAgent = engine.UserAgent;
engine.UpdateUserAgent("SierraLib.Analytics.Test", "1.0.0", "CustomUA");
Assert.IsTrue(engine.UserAgent.IndexOf("CustomUA") != -1, "Custom UserAgent not propagated");
engine.UserAgent = oldUserAgent;
Assert.AreEqual(oldUserAgent, engine.UserAgent);
}
public void SetTrackingEngine(TrackingEngine engine)
{
trackingEngine = engine;
if (currentTrackingEngine != trackingEngine)
{
if (currentTrackingEngine == TrackingEngine.ARCore)
{
onARCoreStop.Invoke();
}
else if (currentTrackingEngine == TrackingEngine.ARKit)
{
onARKitStop.Invoke();
}
else if (currentTrackingEngine == TrackingEngine.Vuforia)
{
onVuforiaStop.Invoke();
}
else if (currentTrackingEngine == TrackingEngine.Other)
{
onOtherStop.Invoke();
}
if (engine == TrackingEngine.ARCore)
{
SetARCoreTracking();
onARCoreSet.Invoke();
}
else if (engine == TrackingEngine.ARKit)
{
SetARKitTracking();
onARKitSet.Invoke();
}
else if (engine == TrackingEngine.Vuforia)
{
SetVuforiaTracking();
onVuforiaSet.Invoke();
}
else if (engine == TrackingEngine.Other)
{
SetOtherTracking();
onOtherSet.Invoke();
}
else
{
currentTrackingTransform = null;
currentTrackingEngine = TrackingEngine.None;
}
}
}
private void SetOtherTracking()
{
if (useOther)
{
currentTrackingTransform = otherTransform;
trackingEngine = TrackingEngine.Other;
currentTrackingEngine = trackingEngine;
if (aryzonMode)
{
onOtherStart.Invoke();
}
}
else
{
trackingEngine = currentTrackingEngine;
}
}
private void SetVuforiaTracking()
{
if (useVuforia)
{
currentTrackingTransform = vuforiaTransform;
trackingEngine = TrackingEngine.Vuforia;
currentTrackingEngine = trackingEngine;
if (aryzonMode)
{
onVuforiaStart.Invoke();
}
}
else
{
trackingEngine = currentTrackingEngine;
}
}
private void SetARKitTracking()
{
if (useARKit)
{
currentTrackingTransform = arKitTransform;
trackingEngine = TrackingEngine.ARKit;
currentTrackingEngine = trackingEngine;
if (aryzonMode)
{
onARKitStart.Invoke();
}
}
else
{
trackingEngine = currentTrackingEngine;
}
}
public void Start()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
Loggers.Current.Log(LogLevel.Info, $"Starting TwometerVR v{Version}");
Loggers.Current.Log(LogLevel.Debug, "Opening video stream");
var videoConfig = configProvider.VideoSourceConfig;
videoSource = VideoSourceFactory.Create(videoConfig.VideoSourceType, videoConfig.VideoSourceIndex);
videoSource.Width = videoConfig.FrameWidth;
videoSource.Height = videoConfig.FrameHeight;
videoSource.Framerate = videoConfig.Framerate;
videoSource.Open();
Loggers.Current.Log(LogLevel.Debug, "Initializing tracking engine");
trackingEngine = new TrackingEngine(trackerManager, configProvider, videoSource);
Loggers.Current.Log(LogLevel.Debug, "Setting up network");
discoveryClient = new DiscoveryClient();
driverClient = new DriverClient(trackerManager);
trackerClient = new TrackerClient(trackerManager);
watchdog = new TrackerWatchdog(trackerManager, configProvider);
Loggers.Current.Log(LogLevel.Debug, "Initializing update timer");
updateTimer = new Timer(Update, null, 0, 1 / configProvider.UserConfig.Input.RefreshRate);
Loggers.Current.Log(LogLevel.Debug, "Starting video procecssing thread");
videoThread = new Thread(VideoLoop);
videoThread.Start();
stopwatch.Stop();
Loggers.Current.Log(LogLevel.Info, $"Done after {stopwatch.Elapsed}");
}
public void Tracking_Serialization()
{
var engine = TrackingEngine.GetEngine(() => Tracking_Serialization()) as UniversalAnalytics;
var request = new RestRequest()
{
Resource = "/collect",
Method = Method.POST
};
request.AddParameter("q", "Test", ParameterType.GetOrPost);
request.AddParameter("r", "Yargh!", ParameterType.GetOrPost);
var pendingRequest = new PreparedTrackingRequest(engine, request, Array.Empty <Implementation.ITrackingFinalize>());
var formatter = new BinaryFormatter();
PreparedTrackingRequest deserialized = null;
using (var ms = new MemoryStream())
{
formatter.Serialize(ms, pendingRequest);
ms.Seek(0, SeekOrigin.Begin);
deserialized = formatter.Deserialize(ms) as PreparedTrackingRequest;
}
Assert.IsNotNull(deserialized);
Assert.IsNotNull(deserialized.Request);
Assert.AreEqual(pendingRequest.Generated, deserialized.Generated);
Assert.AreEqual(pendingRequest.Engine, deserialized.Engine);
Assert.AreEqual(pendingRequest.Request.Parameters.Count, request.Parameters.Count);
for (int i = 0; i < pendingRequest.Request.Parameters.Count; i++)
{
var got = pendingRequest.Request.Parameters[i];
var expected = request.Parameters[i];
Assert.AreEqual(expected.Type, got.Type);
Assert.AreEqual(expected.Name, got.Name);
Assert.AreEqual(expected.Value, got.Value);
}
}
private void AddCameraEventsForTrackingEngine(TrackingEngine engine)
{
Camera camera = null;
UnityEvent startEvent = null;
UnityEvent stopEvent = null;
if (engine == TrackingEngine.ARCore)
{
if (aryzonTracking.arCoreTransform)
{
camera = aryzonTracking.arCoreTransform.gameObject.GetComponent <Camera> ();
startEvent = aryzonTracking.onARCoreStart;
stopEvent = aryzonTracking.onARCoreStop;
}
else
{
return;
}
}
else if (engine == TrackingEngine.ARKit)
{
if (aryzonTracking.arKitTransform)
{
camera = aryzonTracking.arKitTransform.gameObject.GetComponent <Camera> ();
startEvent = aryzonTracking.onARKitStart;
stopEvent = aryzonTracking.onARKitStop;
}
else
{
return;
}
}
else if (engine == TrackingEngine.Vuforia)
{
if (aryzonTracking.vuforiaTransform)
{
camera = aryzonTracking.vuforiaTransform.gameObject.GetComponent <Camera> ();
startEvent = aryzonTracking.onVuforiaStart;
stopEvent = aryzonTracking.onVuforiaStop;
}
else
{
return;
}
}
else if (engine == TrackingEngine.Other)
{
if (aryzonTracking.otherTransform)
{
camera = aryzonTracking.otherTransform.gameObject.GetComponent <Camera> ();
startEvent = aryzonTracking.onOtherStart;
stopEvent = aryzonTracking.onOtherStop;
}
else
{
return;
}
}
else if (engine == TrackingEngine.None)
{
return;
}
if (camera == null)
{
return;
}
int startCount = startEvent.GetPersistentEventCount();
int stopCount = stopEvent.GetPersistentEventCount();
bool startEventFound = false;
bool stopEventFound = false;
for (int i = 0; i < startCount; i++)
{
if (startEvent.GetPersistentTarget(i) == camera && startEvent.GetPersistentMethodName(i) == "set_enabled")
{
startEventFound = true;
break;
}
}
for (int i = 0; i < stopCount; i++)
{
if (stopEvent.GetPersistentTarget(i) == camera && stopEvent.GetPersistentMethodName(i) == "set_enabled")
{
stopEventFound = true;
break;
}
}
MethodInfo method = null;
if (!startEventFound || !stopEventFound)
{
method = typeof(UnityEngine.Camera).GetMethod("set_enabled");
if (engine == TrackingEngine.ARCore)
{
//aryzonTracking.showARCoreEvents = true;
EditorPrefs.SetBool("showARCoreEvents", true);
}
else if (engine == TrackingEngine.ARKit)
{
//aryzonTracking.showARKitEvents = true;
EditorPrefs.SetBool("showARKitEvents", true);
}
else if (engine == TrackingEngine.Vuforia)
{
//aryzonTracking.showVuforiaEvents = true;
EditorPrefs.SetBool("showVuforiaEvents", true);
}
else if (engine == TrackingEngine.Other)
{
//aryzonTracking.showOtherEvents = true;
EditorPrefs.SetBool("showOtherEvents", true);
}
}
if (!startEventFound)
{
UnityAction <bool> startAction = System.Delegate.CreateDelegate(typeof(UnityAction <bool>), camera, method) as UnityAction <bool>;
UnityEventTools.AddBoolPersistentListener(startEvent, startAction, false);
}
if (!stopEventFound)
{
UnityAction <bool> stopAction = System.Delegate.CreateDelegate(typeof(UnityAction <bool>), camera, method) as UnityAction <bool>;
UnityEventTools.AddBoolPersistentListener(stopEvent, stopAction, true);
}
}
public void Tracking_BasicEvent()
{
TrackingEngine.TrackDefaultAsync(() => Tracking_BasicEvent(), TrackOn.Entry);
}
