public IDisposable Connect(IObservableDevice device)
{
DeviceType deviceType = device.DeviceType;
var observer = device.States
//.Where(state => DeviceStatesHelper.IsBusy(state) == false)
.Throttle(TimeSpan.FromSeconds(THROTTLE_SECONDS))
.DistinctUntilChanged()
.ObserveOnDispatcher()
.Subscribe(onNext: state => Device_StateChanged(device, state.State));
var currentState = device.States.Select(s => s.State).MostRecent(DeviceState.Disconnected).First();
DeviceStatus status;
if (_context.TryAddDevice(deviceType, currentState, out status))
{
StartedObservingDevice?.Invoke(this, status);
}
return(new CompositeDisposable
(
observer,
Disposable.Create(() =>
{
DeviceStatus lastStatus;
if (_context.TryRemoveDevice(deviceType, out lastStatus))
{
StoppedObservingDevice?.Invoke(this, lastStatus);
}
})
));
}
public IDisposable Connect(IObservableDevice device)
{
var writer = new InMemoryDataBufferWriter(device.DeviceType, _buffer, device.DataType);
var bufferedWriter = new BufferedDataWriter(writer, TimeSpan.FromMilliseconds(_configuration.BufferSize));
return(new CompositeDisposable
(
device.Data.Do(d => bufferedWriter.Write(d))
.Finally(bufferedWriter.Close)
.Subscribe(),
bufferedWriter,
writer
));
//return Observable.Using
//(
// () => new InMemoryDataBufferWriter(device.DeviceType, _buffer, device.RecordingDataType),
// writer => Observable.Using
// (
// () => new BufferedDataWriter(writer, TimeSpan.FromMilliseconds(_configuration.BufferSize)),
// bufferedWriter => device.Data.Do(d => bufferedWriter.Write(d))
// .Finally(bufferedWriter.Close)
// )
//).Subscribe();
}
public IDisposable Connect(IObservableDevice device)
{
Data = device.Data.Cast <GazeData>();
States = device.States;
return(new CompositeDisposable
(
Data.StartWith(GazeData.Empty).Subscribe(d => RecentData = d),
States.Select(s => s.State).StartWith(DeviceState.Disconnected).Subscribe(s => RecentState = s)
));
}
private void Device_StateChanged(IObservableDevice device, DeviceState state)
{
_logger.Info(device.DeviceType.Code + " " + state);
DeviceStatus status;
if (_context.TryUpdateDevice(device.DeviceType, state, out status))
{
DeviceStateChanged?.Invoke(this, status);
}
}
public IDisposable Connect(IObservableDevice device)
{
var gazeData = device.Data
.OfType <GazeData>()
.Select(g => g.ToToolkit())
.ObserveOnDispatcher();
_gazeStreams.OnNext(gazeData);
return(Disposable.Create(Clear));
}
public IDisposable Connect(IObservableDevice device)
{
string extension = _writerFactory.FileExtension;
IDisposable data = Disposable.Empty;
if (device.DataType.IsSubclassOf(typeof(DeviceData)))
{
string deviceDataPath = _paths.BuildDeviceFilePath(device.DeviceType, "data", extension);
data = RecordForSessionWithWriter(device.Data, deviceDataPath);
//.TakeUntilOtherCompletes(_sessionRecordingEvents)
//.AttachWriter(deviceDataPath, _writerFactory, device.RecordingDataType, DATA_BUFFER_SIZE)
//.ObserveOn(scheduler: _scheduler)
//.Subscribe();
_result.Paths.Add(deviceDataPath);
}
string deviceStatesPath = _paths.BuildDeviceFilePath(device.DeviceType, "states", extension);
IDisposable states = RecordForSessionWithWriter(device.States, deviceStatesPath);
//.TakeUntilOtherCompletes(_sessionRecordingEvents)
//.AttachWriter(deviceStatesPath, _writerFactory)
//.ObserveOn(scheduler: _scheduler)
//.Subscribe();
_result.Paths.Add(deviceStatesPath);
string deviceLogsPath = _paths.BuildDeviceFilePath(device.DeviceType, "log", extension);
IDisposable logs = RecordForSessionWithWriter(device.Logs, deviceLogsPath);
//.TakeUntilOtherCompletes(_sessionRecordingEvents)
//.AttachWriter(deviceLogsPath, _writerFactory)
//.ObserveOn(scheduler: _scheduler)
//.Subscribe();
_result.Paths.Add(deviceLogsPath);
return(new CompositeDisposable(data, states, logs));
}
