private void Window_Loaded(object sender, RoutedEventArgs e)
{
// TODO is there a way to initialize DataContext window without using contructors???
mvvm = new OOPPatternsMainWindowMVVM(); // (OOPPatternsMainWindowMVVM)this.DataContext;
mvvm.osStates = new List <ObserverState>();
mvvm.subject = new ProxyClass();
mvvm.os = new ObserverSubject();
mvvm.osA = new ObserverA();
mvvm.osB = new ObserverB();
mvvm.osC = new ObserverC();
ObserverState stateInit = new ObserverState(1, Constants.OBSERVER_STATE_INIT);
mvvm.osStates.Add(stateInit);
ObserverState stateReady = new ObserverState(2, Constants.OBSERVER_STATE_READY);
mvvm.osStates.Add(stateReady);
ObserverState stateProcessing = new ObserverState(3, Constants.OBSERVER_STATE_PROCESSIND);
mvvm.osStates.Add(stateProcessing);
ObserverState stateDone = new ObserverState(4, Constants.OBSERVER_STATE_DONE);
mvvm.osStates.Add(stateDone);
chooseStateCB.ItemsSource = mvvm.osStates;
this.DataContext = mvvm;
cw = new ChatWindow();
}
public void Update(object sub)
{
ObserverState newState = (ObserverState)sub;
if (newState == ObserverState.Standby)
{
m_concreteSubject.DetachAll();
m_concreteSubject.StopUpdateByMyself();
m_concreteSubject = null;
m_concreteObserver = null;
//watch1_button.Enabled = false;
buttonDoObserve.Text = "Do Observe";
}
else
{
m_concreteSubject = new CurrentTimeSubject();
m_concreteObserver = new ConcreteObserver("Observe On Trace");
m_concreteSubject.Attach(m_concreteObserver);
m_concreteSubject.StartUpdateByMyself();
//watch1_button.Enabled = true;
buttonDoObserve.Text = "Stop Observe";
}
}
private void StartUpdateTimers()
{
// setup and start service timers
updateTimer = new System.Timers.Timer
{
Interval = Math.Max(UpdateInterval, Mathf.Epsilon) * 1000.0, // convert to milliseconds
};
updateTimer.Elapsed += (sender, e) =>
{
//if (AutoUpdate || doUpdateOnceOnLoad)
if (AutoUpdate)
{
observerState = ObserverState.GetScene;
//doUpdateOnceOnLoad = false;
}
};
firstUpdateTimer = new System.Timers.Timer()
{
Interval = Math.Max(FirstUpdateDelay, Mathf.Epsilon) * 1000.0, // convert to milliseconds
AutoReset = false
};
// After an initial delay, start a load once or the auto update
firstUpdateTimer.Elapsed += (sender, e) =>
{
updateTimer.Start();
};
firstUpdateTimer.Start();
}
public void Update(object sub)
{
ObserverState newState = (ObserverState)sub;
if (newState == ObserverState.Observing)
{
Enabled = true;
}
else
{
Enabled = false;
}
}
public static IAsyncEnumerator <object> FromObservable <T>(IObservable <T> observable, CancellationToken cancellationToken)
{
// TODO: Allow bounding and optimizations?
var channel = Channel.CreateUnbounded <object>();
var observer = new ObserverState();
var channelObserver = new ChannelObserver <T>(channel.Writer);
observer.Subscription = observable.Subscribe(channelObserver);
observer.TokenRegistration = cancellationToken.Register(obs => ((ChannelObserver <T>)obs).OnCompleted(), channelObserver);
// Make sure the subscription and token registration is disposed when enumeration is completed.
return(new AsyncEnumerator <object>(channel.Reader, cancellationToken, observer));
}
public void Update(object sub)
{
ObserverState newState = (ObserverState)sub;
if (newState == ObserverState.Observing)
{
this.Text = "Observing...";
}
else
{
this.Text = "Standby";
}
}
public async Task Remoting_ContextSwitchOperator_StateChanged_NoneProcessed()
{
var streamId = new Uri("reactor://test/stream");
var subscriptionId = new Uri("reactor://test/subscription");
var testObserverName = new Uri("reactor://test/observer");
using var client = CreateTestClient();
var ctx = client.Context;
var scheduler = (ITestScheduler)client.Platform.QueryEvaluators.First().Scheduler;
var sf = ctx.GetStreamFactory <int, int>(PlatformConstants.Identifiers.Observable.FireHose.Uri);
var stream = await sf.CreateAsync(streamId, null, CancellationToken.None);
var observer = ctx.GetObserver <Uri, int>(TestConstants.Test.TestObserver.Uri)(testObserverName);
scheduler.ScheduleAbsolute(100, () => stream.SubscribeAsync(observer, subscriptionId, null, CancellationToken.None));
// Cause the ItemProcessor to execute once...
scheduler.ScheduleAbsolute(110, () => stream.OnNextAsync(1, CancellationToken.None));
// Cause item to be queued but not processed...
scheduler.ScheduleAbsolute(110, () => stream.OnNextAsync(2, CancellationToken.None));
// Full checkpoint and trigger OnStateSaved()...
scheduler.ScheduleAbsolute(110, () => client.Platform.QueryEvaluators.First().Checkpoint());
// Cause additional item to be queued but not processed...
scheduler.ScheduleAbsolute(110, () => stream.OnNextAsync(3, CancellationToken.None));
// Differential checkpoint and reload from state...
scheduler.ScheduleAbsolute(110, () =>
{
var qe = client.Platform.QueryEvaluators.First();
qe.Checkpoint();
qe.Unload();
qe.Recover();
});
scheduler.Start();
var observerState = new ObserverState <int>(testObserverName)
{
ObserverMessage.OnNext(1),
ObserverMessage.OnNext(2),
ObserverMessage.OnNext(3),
ObserverMessage.OnNext(2),
ObserverMessage.OnNext(3),
};
AssertObserverState(client.Platform, observerState);
}
public void ChangeState(ObserverState state)
{
this.Component1.SetState(state);
this.Component2.SetState(state);
}
public StandardCountState(
ObserverState state
)
{
_state = state;
}
public UnregisterObserverCommandHandler(
ObserverState state
)
{
_state = state;
}
private async Task RunObserverAsync(CancellationToken cancellationToken)
{
Scene scene = null;
Scene previousScene = null;
var sasos = new List <SpatialAwarenessSceneObject>(256);
while (!cancellationToken.IsCancellationRequested)
{
switch (observerState)
{
case ObserverState.Idle:
await new WaitForUpdate();
continue;
case ObserverState.GetScene:
observerState = ObserverState.Working;
await new WaitForBackgroundThread();
{
scene = GetSceneAsync(previousScene);
previousScene = scene;
sceneOriginId = scene.OriginSpatialGraphNodeId;
}
await new WaitForUpdate();
sceneToWorldXformSystem = GetSceneToWorldTransform();
if (!UsePersistentObjects)
{
ClearObservations();
}
if (OrientScene && Application.isEditor)
{
var toUp = System.Numerics.Vector3.Zero;
await new WaitForBackgroundThread();
{
toUp = ToUpFromBiggestFloor(scene.SceneObjects);
}
await new WaitForUpdate();
var floorNormalUnity = new Vector3(toUp.X, toUp.Y, toUp.Z);
// Get the rotation between the floor normal and Unity world's up vector.
var upRotation = Quaternion.FromToRotation(floorNormalUnity, Vector3.down);
correctOrientation = Matrix4x4.TRS(Vector3.zero, upRotation, Vector3.one).ToSystemNumerics();
}
await new WaitForBackgroundThread();
{
sasos = await ConvertSceneObjectsAsync(scene);
}
await new WaitForUpdate();
await new WaitForBackgroundThread();
{
AddUniqueTo(sasos, instantiationQueue);
}
await new WaitForUpdate();
// Add new objects to observer
// notify subscribers of event
foreach (var saso in sasos)
{
if (!sceneObjects.ContainsKey(saso.Guid))
{
sceneObjects.Add(saso.Guid, saso);
SendSceneObjectAdded(saso, saso.Guid);
}
}
if (observerState == ObserverState.Working)
{
observerState = ObserverState.Idle;
}
continue;
default:
await new WaitForUpdate();
continue;
}
}
}
public void SetState(ObserverState state)
{
compState = state;
}
public ObserverA()
{
message = "Updating Observer Subject A.";
observerState = new ObserverState(Constants.OBSERVER_STATE_INIT_ID, Constants.OBSERVER_STATE_INIT);
}
