Esempio n. 1
0
        public override void OnFrameworkInitializationCompleted()
        {
            if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
            {
                var configuration = AudioSenseiConfiguration.LoadOrCreate("config.json");
                var window        = new MainWindow();
                window.DataContext = new MainWindowViewModel(new BassAudioBackend(window.PlatformImpl.Handle.Handle));
                desktop.MainWindow = window;
            }

            base.OnFrameworkInitializationCompleted();
        }
Esempio n. 2
0
        public override void Initialize()
        {
            _configuration = AudioSenseiConfiguration.LoadOrCreate(Path.Combine(ApplicationDataPath, "config.json"));

            string directory      = Path.Combine(ApplicationDataPath, "logs");
            string latestLogPath  = Path.Combine(directory, "latest.log");
            string rollingLogPath = Path.Combine(directory, $"log-{DateTimeOffset.Now.ToString(_configuration.General.LogTimeFormat)}.log.gz");

            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            try
            {
                if (File.Exists(latestLogPath))
                {
                    File.Delete(latestLogPath);
                }
            }
            catch (Exception ex)
            {
                latestLogPath = Path.Combine(directory, $"{Environment.ProcessId}-latest.log");
                if (File.Exists(latestLogPath))
                {
                    File.Delete(latestLogPath);
                }
                Log.Information(ex, $"Failed to delete the latest log, using {latestLogPath} instead");
            }

            var loggerConfiguration = new LoggerConfiguration()
                                      .MinimumLevel.Is(_configuration.General.LoggerMinimumLevel)
                                      .WriteTo.File(latestLogPath, outputTemplate: _configuration.General.LogTemplate)
                                      .WriteTo.File(rollingLogPath, outputTemplate: _configuration.General.LogTemplate, buffered: true, hooks: new GZipHooks());

            if (_configuration.General.EnableMessageBoxSink)
            {
                loggerConfiguration.WriteTo.MessageBox(restrictedToMinimumLevel: _configuration.General.MessageBoxSinkMinimumLevel);
            }

            var logger = loggerConfiguration.CreateLogger();

            Avalonia.Logging.Logger.Sink = new AvaloniaSerilogSink(logger);
            Log.Logger    = logger;
            Program.Exit += Log.CloseAndFlush;

            AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
            {
                string message;
                if (args.ExceptionObject is Exception ex)
                {
                    message = $"Caught an unhandled {ex.GetType().Name} exception";
                    if (args.IsTerminating)
                    {
                        Log.Fatal(ex, $"{message}, terminating the program");
                        Program.TriggerExit();
                    }
                    else
                    {
                        Log.Error($"{message}, not terminating the program");
                    }
                }
                else
                {
                    message = "Caught an unidentified unhandled exception";

                    if (args.IsTerminating)
                    {
                        Log.Fatal($"{message}, terminating the program");
                        Program.TriggerExit();
                    }
                    else
                    {
                        Log.Error($"{message}, not terminating the program");
                    }
                }
            };

            AppDomain.CurrentDomain.ProcessExit += (sender, args) => Program.TriggerExit();

#if LINUX
            new Thread(() =>
            {
                UnixSignal[] signals =
                {
                    new UnixSignal(Signum.SIGINT),  // CTRL + C pressed
                    new UnixSignal(Signum.SIGTERM), // Sending KILL
                    new UnixSignal(Signum.SIGUSR1),
                    new UnixSignal(Signum.SIGUSR2),
                    new UnixSignal(Signum.SIGHUP)   // Terminal is closed
                };
                // Blocking operation with infinite expectation of any signal
                UnixSignal.WaitAny(signals, -1);
                Program.TriggerExit();
            })
            {
                IsBackground = true, Priority = ThreadPriority.BelowNormal
            }.Start();
#endif

            Log.Information("Opening a new instance of AudioSensei");

            AvaloniaXamlLoader.Load(this);
        }