Beispiel #1
0
        public OverlayService(IStatisticProvider statisticProvider,
                              IRecordDataProvider recordDataProvider,
                              IOverlayEntryProvider overlayEntryProvider,
                              IAppConfiguration appConfiguration,
                              ILogger <OverlayService> logger)
            : base(ExceptionAction)
        {
            _statisticProvider    = statisticProvider;
            _recordDataProvider   = recordDataProvider;
            _overlayEntryProvider = overlayEntryProvider;
            _appConfiguration     = appConfiguration;
            _logger = logger;

            _refreshPeriod          = _appConfiguration.OSDRefreshPeriod;
            _numberOfRuns           = _appConfiguration.SelectedHistoryRuns;
            SecondMetric            = _appConfiguration.SecondMetricOverlay;
            ThirdMetric             = _appConfiguration.ThirdMetricOverlay;
            IsOverlayActiveStream   = new Subject <bool>();
            _runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();

            _logger.LogDebug("{componentName} Ready", this.GetType().Name);
            SetOverlayEntries(overlayEntryProvider?.GetOverlayEntries());
            overlayEntryProvider.EntryUpdateStream.Subscribe(x =>
            {
                SetOverlayEntries(overlayEntryProvider?.GetOverlayEntries());
            });

            _runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
            SetRunHistory(_runHistory.ToArray());
            SetRunHistoryAggregation(string.Empty);
            SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
            SetIsCaptureTimerActive(false);
        }
Beispiel #2
0
        public AggregationViewModel(IStatisticProvider statisticProvider, IRecordDataProvider recordDataProvider,
                                    IEventAggregator eventAggregator, IAppConfiguration appConfiguration)
        {
            _statisticProvider  = statisticProvider;
            _recordDataProvider = recordDataProvider;
            _eventAggregator    = eventAggregator;
            _appConfiguration   = appConfiguration;

            ClearTableCommand       = new DelegateCommand(OnClearTable);
            AggregateIncludeCommand = new DelegateCommand(OnAggregateInclude);
            AggregateExcludeCommand = new DelegateCommand(OnAggregateExclude);

            SubscribeToUpdateSession();

            AggregationEntries.CollectionChanged += new NotifyCollectionChangedEventHandler
                                                        ((sender, eventArg) => OnAggregationEntriesChanged());
        }
Beispiel #3
0
        public CaptureViewModel(IAppConfiguration appConfiguration,
                                ICaptureService captureService,
                                IEventAggregator eventAggregator,
                                IRecordDataProvider recordDataProvider,
                                IOverlayService overlayService,
                                IStatisticProvider statisticProvider,
                                ILogger <CaptureViewModel> logger)
        {
            _appConfiguration   = appConfiguration;
            _captureService     = captureService;
            _eventAggregator    = eventAggregator;
            _recordDataProvider = recordDataProvider;
            _overlayService     = overlayService;
            _statisticProvider  = statisticProvider;
            _logger             = logger;

            AddToIgonreListCommand     = new DelegateCommand(OnAddToIgonreList);
            AddToProcessListCommand    = new DelegateCommand(OnAddToProcessList);
            ResetCaptureProcessCommand = new DelegateCommand(OnResetCaptureProcess);

            _logger.LogDebug("{viewName} Ready", this.GetType().Name);
            CaptureStateInfo = "Service ready..." + Environment.NewLine +
                               $"Press {CaptureHotkeyString} to start capture of the running process.";
            SelectedSoundMode = _appConfiguration.HotkeySoundMode;
            CaptureTimeString = _appConfiguration.CaptureTime.ToString();

            ProcessesToIgnore.AddRange(CaptureServiceConfiguration.GetProcessIgnoreList());
            _disposableHeartBeat = GetListUpdatHeartBeat();
            _frametimeStream     = new Subject <string>();

            SubscribeToUpdateProcessIgnoreList();
            SubscribeToGlobalCaptureHookEvent();

            bool captureServiceStarted = StartCaptureService();

            if (captureServiceStarted)
            {
                _overlayService.SetCaptureServiceStatus("Capture service ready...");
            }


            _captureService.IsCaptureModeActiveStream.OnNext(false);

            FrametimeModel = new PlotModel
            {
                PlotMargins         = new OxyThickness(40, 0, 0, 40),
                PlotAreaBorderColor = OxyColor.FromArgb(64, 204, 204, 204),
                LegendPosition      = LegendPosition.TopCenter,
                LegendOrientation   = LegendOrientation.Horizontal
            };

            //Axes
            //X
            FrametimeModel.Axes.Add(new LinearAxis()
            {
                Key                    = "xAxis",
                Position               = AxisPosition.Bottom,
                Title                  = "Samples",
                MajorGridlineStyle     = LineStyle.Solid,
                MajorGridlineThickness = 1,
                MajorGridlineColor     = OxyColor.FromArgb(64, 204, 204, 204),
                MinorTickSize          = 0,
                MajorTickSize          = 0
            });

            //Y
            FrametimeModel.Axes.Add(new LinearAxis()
            {
                Key                    = "yAxis",
                Position               = AxisPosition.Left,
                Title                  = "Frametime [ms]",
                MajorGridlineStyle     = LineStyle.Solid,
                MajorGridlineThickness = 1,
                MajorGridlineColor     = OxyColor.FromArgb(64, 204, 204, 204),
                MinorTickSize          = 0,
                MajorTickSize          = 0
            });
        }
Beispiel #4
0
 /// <summary>
 /// 构造函数
 /// </summary>
 public RecordFacade()
 {
     recordData = ClassFactory.GetIRecordDataProvider();
 }
        public ControlViewModel(IRecordDirectoryObserver recordObserver,
                                IEventAggregator eventAggregator,
                                IAppConfiguration appConfiguration,
                                IRecordDataProvider recordDataProvider)
        {
            _recordObserver     = recordObserver;
            _eventAggregator    = eventAggregator;
            _appConfiguration   = appConfiguration;
            _recordDataProvider = recordDataProvider;

            //Commands
            OpenEditingDialogCommand   = new DelegateCommand(OnOpenEditingDialog);
            AddToIgnoreListCommand     = new DelegateCommand(OnAddToIgnoreList);
            DeleteRecordFileCommand    = new DelegateCommand(OnDeleteRecordFile);
            AcceptEditingDialogCommand = new DelegateCommand(OnAcceptEditingDialog);
            CancelEditingDialogCommand = new DelegateCommand(OnCancelEditingDialog);
            AddCpuInfoCommand          = new DelegateCommand(OnAddCpuInfo);
            AddGpuInfoCommand          = new DelegateCommand(OnAddGpuInfo);
            AddRamInfoCommand          = new DelegateCommand(OnAddRamInfo);
            DeleteRecordCommand        = new DelegateCommand(OnPressDeleteKey);
            SelectedRecordingsCommand  = new DelegateCommand <object>(OnSelectedRecordings);

            HasValidSource = recordObserver.HasValidSource;

            Task.Factory.StartNew(() =>
            {
                if (recordObserver.HasValidSource)
                {
                    var initialRecordFileInfoList = _recordDataProvider?.GetFileRecordInfoList();

                    foreach (var recordFileInfo in initialRecordFileInfoList)
                    {
                        AddToRecordInfoList(recordFileInfo);
                    }
                }
            });

            RecordDataGridSelectedIndex = -1;

            _recordDeleteSubStream = new Subject <FileInfo>();

            var context = SynchronizationContext.Current;

            _recordObserver.RecordCreatedStream
            .ObserveOn(context)
            .SubscribeOn(context)
            .Subscribe(OnRecordCreated);
            _recordObserver.RecordDeletedStream
            .Merge(_recordDeleteSubStream)
            .Where(x => _recordDeleteStreamActive)
            .ObserveOn(context)
            .SubscribeOn(context)
            .Subscribe(x => OnRecordDeleted());

            // Turn streams now on
            if (_recordObserver.HasValidSource)
            {
                _recordObserver.IsActive = true;
            }

            SetAggregatorEvents();
            SubscribeToResetRecord();
            SubscribeToObservedDiretoryUpdated();
            SubscribeToSetFileRecordInfoExternal();
        }