public MainWindow()
{
logger = NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
telemetryWriter = new TelemetryWriter();
logger.Info("\n\nApp start");
telemetryWriter.WriteAppStart();
messageBoxService = new MessageBoxService();
dbService = new DbService();
drawService = new DrawService(logger);
throwService = new ThrowService(logger);
configService = new ConfigService(logger, dbService);
scoreBoardService = new ScoreBoardService(logger, configService, drawService);
camsDetectionBoard = new CamsDetectionBoard(configService, logger, drawService);
fileSystemService = new FileSystemService();
versionChecker = new VersionChecker(appVersion, fileSystemService, dbService, configService, messageBoxService);
detectionService = new DetectionService(drawService, configService, throwService, logger, camsDetectionBoard);
manualThrowPanel = new ManualThrowPanel(logger, detectionService);
gameService = new GameService(scoreBoardService, camsDetectionBoard, detectionService, logger, dbService, manualThrowPanel);
InitializeComponent();
viewModel = new MainWindowViewModel(logger,
messageBoxService,
dbService,
versionChecker,
scoreBoardService,
camsDetectionBoard,
drawService,
detectionService,
manualThrowPanel,
gameService,
configService);
DataContext = viewModel;
}
private Nancy.Response DetectService(string providerName, string extension, string group)
{
LogHelper.WriteLog4($"开始检测{extension}分机,间数为{group}", LogType.Info);
DetectionService detectionService = new DetectionService(providerName, extension, group);
return(RequestOK(detectionService.run()));
}
/// <summary>
/// Takes the photo.
/// </summary>
/// <returns>The photo.</returns>
public async Task <byte[]> TakePhoto()
{
var photo = await PhotoService.TaskPhotoAsync();
if (photo.Length == 0)
{
return(photo);
}
// Track Camera usage
AnalyticService.Track("Photo taken");
ImageProcessingService.Open(photo);
var detections = await DetectionService.DetectAsync(photo);
foreach (var d in detections)
{
// Track each detection
AnalyticService.Track($"Detection done:{d.Emotion.ToLower()}");
#if DEBUG
ImageProcessingService.DrawDebugRect(d.Rectangle);
#endif
ImageProcessingService.DrawImage(FileService.LoadResource($"{d.Emotion.ToLower()}.png"), d.Rectangle);
}
var finalImage = ImageProcessingService.GetImage();
ImageProcessingService.Close();
return(finalImage);
}
public ManualThrowPanel(Logger logger, DetectionService detectionService)
{
this.logger = logger;
this.detectionService = detectionService;
MakeManualThrowCommand = new MakeManualThrowCommand(ThrowDartTo);
manualThrowPanelWindow = new ManualThrowPanelWindow
{
DartboardImage = { Source = Converter.BitmapToBitmapImage(Resources.Resources.Dartboard) },
DataContext = this
};
}
private void RegisterContainer()
{
logger.Debug("Services container register start");
var cb = new ContainerBuilder();
cb.Register(r => logger).AsSelf().SingleInstance();
cb.Register(r => telemetryWriter).AsSelf().SingleInstance();
var messageBoxService = new MessageBoxService();
cb.Register(r => messageBoxService).AsSelf().SingleInstance();
var dbService = new DBService();
cb.Register(r => dbService).AsSelf().SingleInstance();
var configService = new ConfigService(logger, dbService);
cb.Register(r => configService).AsSelf().SingleInstance();
var versionChecker = new VersionChecker(dbService, configService, messageBoxService);
cb.Register(r => versionChecker).AsSelf().SingleInstance();
var scoreBoardService = new ScoreBoardService();
cb.Register(r => scoreBoardService).AsSelf().SingleInstance();
var drawService = new DrawService(this, configService, logger);
cb.Register(r => drawService).AsSelf().SingleInstance();
var throwService = new ThrowService(drawService, logger);
cb.Register(r => throwService).AsSelf().SingleInstance();
var detectionService = new DetectionService(this, drawService, configService, throwService, logger);
cb.Register(r => detectionService).AsSelf().SingleInstance();
var manualThrowPanel = new ManualThrowPanel(logger, detectionService);
cb.Register(r => manualThrowPanel).AsSelf().SingleInstance();
var gameService = new GameService(this, scoreBoardService, detectionService, configService, drawService, logger, dbService);
cb.Register(r => gameService).AsSelf().SingleInstance();
ServiceContainer = cb.Build();
logger.Debug("Services container register end");
}
// Amalyses a collection of transforms (position and rotation) and returns a dictionary of functionalities and results (e.g. "falldetection": true").
public IDictionary <string, object> AnalyseMovement([FromHeader(Name = "ApiKey")] string apiKey, [FromBody] JObject transformsJson)
{
try
{
IDictionary <string, object> result = DetectionService.AnalyseMovement(transformsJson);
return(result);
}
catch
{
return(null);
}
}
public GameService(ScoreBoardService scoreBoardService,
CamsDetectionBoard camsDetectionBoard,
DetectionService detectionService,
Logger logger,
DBService dbService)
{
this.logger = logger;
this.scoreBoardService = scoreBoardService;
this.camsDetectionBoard = camsDetectionBoard;
this.detectionService = detectionService;
this.dbService = dbService;
}
public ManualThrowPanel(Logger logger, DetectionService detectionService)
{
this.logger = logger;
this.detectionService = detectionService;
if (App.ThrowPanel)
{
manualThrowPanelWindow = new ManualThrowPanelWindow(this);
manualThrowPanelWindow.DartboardImage.Source = Converter.BitmapToBitmapImage(Resources.Dartboard);
manualThrowPanelWindow.Show();
}
}
public GameService(ScoreBoardService scoreBoardService,
CamsDetectionBoard camsDetectionBoard,
DetectionService detectionService,
Logger logger,
DbService dbService,
ManualThrowPanel manualThrowPanel)
{
this.logger = logger;
this.scoreBoardService = scoreBoardService;
this.camsDetectionBoard = camsDetectionBoard;
this.detectionService = detectionService;
this.dbService = dbService;
this.manualThrowPanel = manualThrowPanel;
}
public async Task <IActionResult> DetectRoom([FromHeader(Name = "ApiKey")] string apiKey)
{
try
{
byte[] imageBytes = await Request.GetRawBodyBytesAsync();
var response = await DetectionService.DetectRoom(imageBytes);
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public LinksViewModel(
ChapterRepository chapterRepository,
DialogService dialogService,
DetectionService detectionService,
IEventAggregator eventAggregator
)
{
this.chapterRepository = chapterRepository;
this.eventAggregator = eventAggregator;
this.dialogService = dialogService;
AddCommand = new DelegateCommand(async() => await detectionService.SetAddress(Data.Linked));
MoveCommand = new DelegateCommand <Link>(Move);
DeleteCommand = new DelegateCommand <Link>(Delete);
SelectionCommand = new DelegateCommand <Link>(link => detectionService.Selected(Data.Linked, link));
}
public GameService(MainWindow mainWindow,
ScoreBoardService scoreBoardService,
DetectionService detectionService,
ConfigService configService,
DrawService drawService,
Logger logger,
DBService dbService)
{
this.mainWindow = mainWindow;
this.scoreBoardService = scoreBoardService;
this.detectionService = detectionService;
this.configService = configService;
this.drawService = drawService;
this.logger = logger;
this.dbService = dbService;
}
/// <summary>
/// Detection Thread
/// </summary>
public static void OnDetect()
{
while (true)
{
if (Config.GetStartDate().Ticks == 0 || Config.GetEndDate().Ticks == 0)
{
Console.ReadLine();
return;
}
if (Calender.GetToday.InDateTime().Ticks >= Config.GetStartDate().Ticks&& Calender.GetToday.InDateTime().Ticks <= Config.GetEndDate().Ticks)
{
DetectionService.DetectFacebook();
DetectionService.DetectInstagram();
}
}
}
public void Ctor_IServiceProvider_Success()
{
string userAgent = "Agent";
var context = new DefaultHttpContext();
context.Request.Headers["User-Agent"] = userAgent;
var serviceProvider = new ServiceProvider()
{
HttpContextAccessor = new HttpContextAccessor()
{
HttpContext = context
}
};
var detectionService = new DetectionService(serviceProvider);
Assert.NotNull(detectionService.Context);
Assert.NotNull(detectionService.UserAgent);
Assert.Equal(userAgent.ToLowerInvariant(), detectionService.UserAgent.ToString());
}
static void Main(string[] args)
{
RecordingService recordingService = new RecordingService();
DetectionService detectionService = new DetectionService();
detectionService.DownloadGameDetections();
detectionService.DownloadNonGameDetections();
LTCProcess ltc = new LTCProcess();
ltc.Log += (sender, msg) => {
ConsoleColor consoleColor = ConsoleColor.White;
switch (msg.Title)
{
case "LTCPROCESS":
consoleColor = ConsoleColor.DarkCyan;
break;
case "RECEIVED":
consoleColor = ConsoleColor.Cyan;
break;
case "SENT":
consoleColor = ConsoleColor.Green;
break;
case "INFO":
consoleColor = ConsoleColor.Magenta;
break;
case "WARNING":
consoleColor = ConsoleColor.Yellow;
break;
case "ERROR":
consoleColor = ConsoleColor.Red;
break;
default:
break;
}
Logger.WriteLine(consoleColor, msg.Title + ": ", msg.Message);
};
ltc.ConnectionHandshake += (sender, msg) => {
ltc.SetCaptureMode(49152); //ORB_GAMEDVR_SET_CAPTURE_MODE ?????
ltc.SetGameDVRCaptureEngine(1); //1 = nvidia ?????
};
ltc.ProcessCreated += (sender, msg) => {
if (!recordingService.IsRecording) // If we aren't already recording something, lets look for a process to record
{
bool isGame = detectionService.IsMatchedGame(msg.ExeFile);
bool isNonGame = detectionService.IsMatchedNonGame(msg.ExeFile);
if (isGame && !isNonGame)
{
Logger.WriteLine(ConsoleColor.Magenta, "INFO: ", "This is a recordable game, preparing to LoadGameModule");
string gameTitle = detectionService.GetGameTitle(msg.ExeFile);
recordingService.SetCurrentSession(msg.Pid, gameTitle);
ltc.SetGameName(gameTitle);
ltc.LoadGameModule(msg.Pid);
}
else if (!isGame && !isNonGame)
{
Logger.WriteLine(ConsoleColor.Magenta, "INFO: ", "This is an unknown application, lets try to ScanForGraphLib");
recordingService.SetCurrentSession(msg.Pid, "Game Unknown");
ltc.ScanForGraphLib(msg.Pid); // the response will be sent to GraphicsLibLoaded if successful
}
else
{
Logger.WriteLine(ConsoleColor.Magenta, "INFO: ", "This is a non-game");
}
}
else
{
Logger.WriteLine(ConsoleColor.Magenta, "INFO: ", "Current recording a game right now, ignoring detection checks.");
}
};
ltc.GraphicsLibLoaded += (sender, msg) => {
ltc.SetGameName("Game Unknown");
ltc.LoadGameModule(msg.Pid);
};
ltc.GameBehaviorDetected += (sender, msg) => {
ltc.StartAutoHookedGame(msg.Pid);
};
ltc.VideoCaptureReady += (sender, msg) => {
//if (AutomaticRecording == true)
if (!recordingService.IsRecording)
{
ltc.SetKeyBinds();
ltc.StartRecording();
recordingService.StartRecording();
}
};
ltc.ProcessTerminated += (sender, msg) => {
if (recordingService.IsRecording)
{
if (recordingService.GetCurrentSession().Pid == msg.Pid)
{
ltc.StopRecording();
recordingService.StopRecording();
}
}
};
ltc.Connect();
Console.ReadKey();
}
static void Main(string[] args)
{
RecordingService recordingService = new RecordingService();
DetectionService detectionService = new DetectionService();
detectionService.DownloadGameDetections();
detectionService.DownloadNonGameDetections();
LTCProcess ltc = new LTCProcess();
ltc.ConnectionHandshake += (sender, msg) => {
Console.WriteLine("Connection Handshake: {0}, {1}", msg.Version, msg.IntegrityCheck);
ltc.SetCaptureMode(49152); //ORB_GAMEDVR_SET_CAPTURE_MODE ?????
ltc.SetGameDVRCaptureEngine(1); //1 = nvidia ?????
};
ltc.ProcessCreated += (sender, msg) => {
Console.WriteLine("Process Created: {0}, {1}", msg.Pid, msg.ExeFile, msg.CmdLine);
if (!recordingService.IsRecording) // If we aren't already recording something, lets look for a process to record
{
bool isGame = detectionService.IsMatchedGame(msg.ExeFile);
bool isNonGame = detectionService.IsMatchedNonGame(msg.ExeFile);
if (isGame && !isNonGame)
{
Console.WriteLine("This is a recordable game, preparing to LoadGameModule");
string gameTitle = detectionService.GetGameTitle(msg.ExeFile);
recordingService.SetCurrentSession(msg.Pid, gameTitle);
ltc.SetGameName(gameTitle);
ltc.LoadGameModule(msg.Pid);
}
else if (!isGame && !isNonGame)
{
Console.WriteLine("This is an unknown application, lets try to ScanForGraphLib");
recordingService.SetCurrentSession(msg.Pid, "Game Unknown");
ltc.ScanForGraphLib(msg.Pid); // the response will be sent to GraphicsLibLoaded if successful
}
else
{
Console.WriteLine("This is a non-game");
}
}
else
{
Console.WriteLine("Current recording a game right now, ignoring detection checks.");
}
};
ltc.GraphicsLibLoaded += (sender, msg) => {
Console.WriteLine("Graphics Lib Loaded: {0}, {1}", msg.Pid, msg.ModuleName);
ltc.SetGameName("Game Unknown");
ltc.LoadGameModule(msg.Pid);
};
ltc.ModuleLoaded += (sender, msg) => {
Console.WriteLine("Plays-ltc Recording Module Loaded: {0}, {1}", msg.Pid, msg.ModuleName);
};
ltc.GameLoaded += (sender, msg) => {
Console.WriteLine("Game finished loading: {0}, {1}x{2}", msg.Pid, msg.Width, msg.Height);
};
ltc.VideoCaptureReady += (sender, msg) => {
Console.WriteLine("Video capture ready, can start recording: {0}", msg.Pid);
//if (AutomaticRecording == true)
if (!recordingService.IsRecording)
{
ltc.SetKeyBinds();
ltc.StartRecording();
recordingService.StartRecording();
}
};
ltc.ProcessTerminated += (sender, msg) => {
Console.WriteLine("Process Terminated: {0}", msg.Pid);
if (recordingService.IsRecording)
{
if (recordingService.GetCurrentSession().Pid == msg.Pid)
{
ltc.StopRecording();
recordingService.StopRecording();
}
}
};
ltc.Connect();
Console.ReadKey();
}
