Example #1
0
        /// <summary>
        /// Invoked when the application is launched normally by the end user.  Other entry points
        /// will be used such as when the application is launched to open a specific file.
        /// </summary>
        /// <param name="e">Details about the launch request and process.</param>
        protected override void OnLaunched(LaunchActivatedEventArgs e)
        {
            #if DEBUG
            if (System.Diagnostics.Debugger.IsAttached)
            {
                DebugSettings.EnableFrameRateCounter = true;
            }
            #endif

            Frame rootFrame = Window.Current.Content as Frame;

            // Do not repeat application initialization when the Window already has content,
            // just ensure that the window is active
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();

                rootFrame.NavigationFailed += OnNavigationFailed;

                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
                {
                    //TODO: Load state from previously suspended application
                }

                // Place the frame in the current Window
                Window.Current.Content = rootFrame;
            }

            // add needed objects to IoC container
            var locator = Resources[LocaterResource] as ViewModelLocator;
            if (locator != null)
            {
                var container = locator.Container;
                container.Register(locator);

                var dateTimeTask = new DateTimeProvider(container);
                container.Register(dateTimeTask);
                dateTimeTask.Start();

                var client = new MqttClient(MqttBrokerAddress);
                container.Register(client);

                var telemetryProvider = new TelemetryProvider(container);
                container.Register(telemetryProvider);

                var rssProvider = new RssProvider(container);
                container.Register(rssProvider);
                rssProvider.Start();

                var speechInterpreter = new SpeechInterpreter(container);
                container.Register(speechInterpreter);
                speechInterpreter.Start();

                var WeatherProvider = new WeatherProvider(container);
                container.Register(WeatherProvider);

                var ioProvider = new IOProvider(container);
                container.Register(ioProvider);
            }

            ApplicationView.GetForCurrentView().TryEnterFullScreenMode();

            if (rootFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter
                rootFrame.Navigate(typeof(MainPage), e.Arguments);
            }
            // Ensure the current window is active
            Window.Current.Activate();
            if (locator != null)
            {
                var container = locator.Container;
                container.Register(Window.Current);
            }
        }
Example #2
0
        public static void Run(string[] args)
        {
            var options = new Options();
            var optionsParser = new OptionsParser();
            if(!optionsParser.Parse(options, args))
            {
                return;
            }

            Plugins.XwtProviderPlugin.XwtProvider.StartXwtThread();
            using(var context = ObjectCreator.Instance.OpenContext())
            {
                var monitor = new Emul8.UserInterface.Monitor();
                context.RegisterSurrogate(typeof(Emul8.UserInterface.Monitor), monitor);

                // we must initialize plugins AFTER registering monitor surrogate
                // as some plugins might need it for construction
                TypeManager.Instance.PluginManager.Init("CLI");

                Logger.AddBackend(ConsoleBackend.Instance, "console");

                EmulationManager.Instance.ProgressMonitor.Handler = new CLIProgressMonitor();

                var crashHandler = new CrashHandler();
                AppDomain.CurrentDomain.UnhandledException += (sender, e) => crashHandler.HandleCrash(e);

                Shell shell = null;
                Type preferredUARTAnalyzer = null;
                if(options.Port > 0)
                {
                    var io = new IOProvider(new SocketIOSource(options.Port));
                    shell = ShellProvider.GenerateShell(io, monitor, true, false);
                }
                else
                {
                    preferredUARTAnalyzer = typeof(UARTWindowBackendAnalyzer);

                    var terminal = new UARTWindowBackendAnalyzer();
                    shell = ShellProvider.GenerateShell(terminal.IO, monitor);
                    monitor.Quitted += shell.Stop;

                    try
                    {
                        terminal.Show();
                    }
                    catch(InvalidOperationException ex)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.Error.WriteLine(ex.Message);
                        Emulator.Exit();
                    }
                }
                shell.Quitted += Emulator.Exit;

                if(preferredUARTAnalyzer != null)
                {
                    EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
                    EmulationManager.Instance.EmulationChanged += () =>
                    {
                        EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
                    };
                }
                monitor.Interaction = shell.Writer;
                monitor.MachineChanged += emu => shell.SetPrompt(emu != null ? new Prompt(string.Format("({0}) ", emu), ConsoleColor.DarkYellow) : null);

                if(options.Execute != null)
                {
                    shell.Started += s => s.InjectInput(string.Format("{0}\n", options.Execute));
                }
                else if(!string.IsNullOrEmpty(options.ScriptPath))
                {
                    shell.Started += s => s.InjectInput(string.Format("i {0}{1}\n", Path.IsPathRooted(options.ScriptPath) ? "@" : "$CWD/", options.ScriptPath));
                }

                new Thread(x => shell.Start(true)) 
                { 
                    IsBackground = true, 
                    Name = "Shell thread" 
                }.Start();

                Emulator.BeforeExit += () =>
                {
                    Emulator.DisposeAll();
                };

                Emulator.WaitForExit();
                Plugins.XwtProviderPlugin.XwtProvider.StopXwtThread();
            }
        }