예제 #1
0
파일: Menu.cs 프로젝트: asimonf/RetroLite
        public Menu(
            CefApp menuCeffApp,
            CefMainArgs mainArgs,
            InputProcessor inputProcessor,
            MenuBrowserClient browserClient,
            StateManager stateManager,
            EventBus eventBus
            )
        {
            // State Initialization
            _buttons        = (GameControllerButton[])Enum.GetValues(typeof(GameControllerButton));
            _analogs        = (GameControllerAnalog[])Enum.GetValues(typeof(GameControllerAnalog));
            _eventTokenList = new List <SubscriptionToken>();
            _eventBus       = eventBus;

#if (DEBUG)
            var logSeverity = CefLogSeverity.Error;
#else
            var logSeverity = CefLogSeverity.Error;
#endif

            var settings = new CefSettings
            {
                WindowlessRenderingEnabled = true,
                LogSeverity = logSeverity,
                NoSandbox   = true
            };

            CefRuntime.Initialize(mainArgs, settings, menuCeffApp, IntPtr.Zero);

            // Instruct CEF to not render to a window at all.
            var cefWindowInfo = CefWindowInfo.Create();
            cefWindowInfo.SetAsWindowless(IntPtr.Zero, false);

            var browserSettings = new CefBrowserSettings()
            {
                WindowlessFrameRate = 60,
            };

            _inputProcessor = inputProcessor;
            _browserClient  = browserClient;
            _browser        = CefBrowserHost.CreateBrowserSync(
                cefWindowInfo,
                _browserClient,
                browserSettings,
                "http://localhost:4200"
                );

            _eventTokenList.Add(_eventBus.Subscribe <OpenMenuEvent>(OnOpenMenuEvent));
            _eventTokenList.Add(_eventBus.Subscribe <CloseMenuEvent>(OnCloseMenuEvent));

            var game = stateManager.GetGameById("Super Mario World (USA)");
            eventBus.Publish(new LoadGameEvent(game));
        }
예제 #2
0
        public void Initialize()
        {
            IoCManager.Instance !.InjectDependencies(this, oneOff: true);

            string subProcessName;

            if (OperatingSystem.IsWindows())
            {
                subProcessName = "Robust.Client.WebView.exe";
            }
            else if (OperatingSystem.IsLinux())
            {
                subProcessName = "Robust.Client.WebView";
            }
            else
            {
                throw new NotSupportedException("Unsupported platform for CEF!");
            }

            var subProcessPath   = PathHelpers.ExecutableRelativeFile(subProcessName);
            var cefResourcesPath = LocateCefResources();

            // System.Console.WriteLine(AppContext.GetData("NATIVE_DLL_SEARCH_DIRECTORIES"));

            if (cefResourcesPath == null)
            {
                throw new InvalidOperationException("Unable to locate cef_resources directory!");
            }

            var settings = new CefSettings()
            {
                WindowlessRenderingEnabled = true,  // So we can render to our UI controls.
                ExternalMessagePump        = false, // Unsure, honestly. TODO CEF: Research this?
                NoSandbox             = true,       // Not disabling the sandbox crashes CEF.
                BrowserSubprocessPath = subProcessPath,
                LocalesDirPath        = Path.Combine(cefResourcesPath, "locales"),
                ResourcesDirPath      = cefResourcesPath,
                RemoteDebuggingPort   = 9222,
            };

            Logger.Info($"CEF Version: {CefRuntime.ChromeVersion}");

            _app = new RobustCefApp();

            // We pass no main arguments...
            CefRuntime.Initialize(new CefMainArgs(null), settings, _app, IntPtr.Zero);

            // TODO CEF: After this point, debugging breaks. No, literally. My client crashes but ONLY with the debugger.
            // I have tried using the DEBUG and RELEASE versions of libcef.so, stripped or non-stripped...
            // And nothing seemed to work. Odd.
        }
예제 #3
0
        public CefGlueBrowser(IntPtr parentHandle, CefApp app, CefConfig config)
        {
            this.ParentHandle = parentHandle;
            this.App          = app;
            this.Config       = config;

            var windowInfo = CefWindowInfo.Create();

            windowInfo.SetAsChild(parentHandle, new CefRectangle(0, 0, config.Width, config.Height));

            this.WebBrowser          = new WebBrowser(this);
            this.WebBrowser.Created += WebBrowser_Created;
            this.Client              = new WebClient(this.WebBrowser);

            CefBrowserHost.CreateBrowser(windowInfo, Client, config.CefBrowserSettings, config.StartUrl);
        }
예제 #4
0
        private static Container SetupContainer(CefMainArgs cefMainArgs, CefApp cefApp)
        {
            var container = new Container();

            // Register Cef related instances
            container.RegisterInstance(cefMainArgs);
            container.RegisterInstance(cefApp);
            container.RegisterInstance <IEventBusConfiguration>(
                new EventBusConfiguration
            {
                ThrowSubscriberException = false
            }
                );

            // Register renderer (TODO: maybe make it configurable?)
            container.Register <IRenderer, SurfaceRenderer>(Lifestyle.Singleton);

            // Register main components
            container.RegisterSingleton <InputProcessor>();
            container.RegisterSingleton <SceneManager>();
            container.RegisterSingleton <MenuRenderer>();
            container.RegisterSingleton <MenuBrowserClient>();
            container.RegisterSingleton <StateManager>();
            container.RegisterSingleton <EventProcessor>();
            container.RegisterSingleton <EventBus>();
            container.RegisterSingleton <Config>();
            container.RegisterSingleton <RetroCoreFactory>();
            container.RegisterSingleton <RawRenderer>();

            // Register Scenes
//            container.Collection.Register<IScene>(Assembly.GetExecutingAssembly());

//            container.RegisterSingleton<RetroCoreManager>();

            container.Collection.Register <IScene>(typeof(RetroCoreManager));


            // Register API components
            container.RegisterSingleton <ApiRouter>();
            container.Register <CefRequestHandler, ApiRequestHandler>(Lifestyle.Singleton);
            container.Collection.Register <IAction>(Assembly.GetExecutingAssembly());

            return(container);
        }
예제 #5
0
        public unsafe static void Main(string[] args)
        {
            string cefPath = Path.Combine(Path.GetDirectoryName(GetProjectPath()), "cef");
            var    path    = Environment.GetEnvironmentVariable("PATH");

            Environment.SetEnvironmentVariable("PATH", Path.Combine(cefPath, "Release") + ";" + path);
            string libname = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "libcef.dll" : "libcef.so";
            IntPtr pLibCef = NativeMethods.LoadLibrary(Path.Combine(cefPath, "Release", libname));

            // This executable is called many times, because it
            // is also used for subprocesses. Let's print args
            // so we can differentiate between main process and
            // subprocesses. If one of the first args is for
            // example "--type=renderer" then it means that
            // this is a Renderer process. There may be more
            // subprocesses like GPU (--type=gpu-process) and
            // others. On Linux there are also special Zygote
            // processes.
            Console.Write("\nProcess args: ");
            if (args.Length == 0)
            {
                Console.Write("none (Main process)");
            }
            else
            {
                Console.WriteLine();
                for (int i = 0; i < args.Length; i++)
                {
                    if (args[i].Length > 128)
                    {
                        Console.WriteLine(args[i].Remove(128) + "...");
                    }
                    else
                    {
                        Console.WriteLine(args[i]);
                    }
                }
            }
            Console.Write("\n\n");

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) &&
                !args.Any(arg => arg.StartsWith("--type=")) &&
                !args.Contains("--no-zygote"))
            {
                Console.WriteLine("Please run with --no-zygote");
                return;
            }

            // CEF version
            if (args.Length == 0)
            {
                var version = new int[8];
                for (int i = 0; i < version.Length; i++)
                {
                    version[i] = CefApi.CefVersionInfo((CefVersionComponent)i);
                }
                Console.Write("CEF version: {0}\n", string.Join(".", version));
            }

            // Main args
            CefMainArgs main_args = CefMainArgs.CreateDefault();

            // Cef app
            var app = new CefApp();

            // Execute subprocesses. It is also possible to have
            // a separate executable for subprocesses by setting
            // cef_settings_t.browser_subprocess_path. In such
            // case cef_execute_process should not be called here.
            Console.Write("cef_execute_process, argc={0}\n", args.Length);
            int code = CefApi.ExecuteProcess(main_args, app, IntPtr.Zero);

            if (code >= 0)
            {
                main_args.Dispose();
                Environment.Exit(code);
            }

            // Application settings. It is mandatory to set the
            // "size" member.
            var settings = new CefSettings();

            //settings.MultiThreadedMessageLoop = true;
            settings.LocalesDirPath             = Path.Combine(cefPath, "Resources", "locales");
            settings.ResourcesDirPath           = Path.Combine(cefPath, "Resources");
            settings.LogSeverity                = CefLogSeverity.Warning; // Show only warnings/errors
            settings.NoSandbox                  = true;
            settings.WindowlessRenderingEnabled = true;

            // Initialize CEF
            Console.Write("cef_initialize\n");
            CefApi.Initialize(main_args, settings, app, IntPtr.Zero);
            GC.KeepAlive(settings);
            main_args.Dispose();

            // Window info
            var windowInfo = new CefWindowInfo();

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                windowInfo.SetAsPopup(IntPtr.Zero, "cefapi example");
            }
            else
            {
                windowInfo.WindowName = "cefapi example";
            }


            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                NativeMethods.XSetErrorHandler(x11_error_handler);
                NativeMethods.XSetIOErrorHandler(x11_io_error_handler);
            }

            var browserSettings = new CefBrowserSettings();

            // Client handlers
            var client = new CefClientClass();


            // Create browser asynchronously. There is also a
            // synchronous version of this function available.
            Console.WriteLine("cef_browser_host_create_browser");
            bool cbok = CefApi.CreateBrowser(windowInfo, client, "https://yandex.com/", browserSettings, null, null);

            Console.WriteLine("CreateBrowser: {0}", cbok);
            windowInfo.Dispose();

            // Message loop. There is also cef_do_message_loop_work()
            // that allow for integrating with existing message loops.
            // On Windows for best performance you should set
            // cef_settings_t.multi_threaded_message_loop to true.
            // Note however that when you do that CEF UI thread is no
            // more application main thread and using CEF API is more
            // difficult and require using functions like cef_post_task
            // for running tasks on CEF UI thread.
            Console.WriteLine("cef_run_message_loop\n");
            CefApi.RunMessageLoop();

            // Release references to CefBrowser's (if any)
            GC.Collect();
            GC.WaitForPendingFinalizers();

            // Shutdown CEF
            Console.WriteLine("cef_shutdown\n");
            CefApi.Shutdown();


            GC.KeepAlive(client);
        }
예제 #6
0
 public RenderProcessHandler(CefApp app)
 {
     this.App = app;
 }
예제 #7
0
 public BrowserProcessHandler(CefApp app)
 {
     this.App = app;
 }
        protected int RunInternal(string[] args)
        {
            MacHostRuntime.LoadNativeHostFile(_config);

            _config.ChromelyVersion = CefRuntime.ChromeVersion;

            var tempFiles = CefBinariesLoader.Load(_config);

            CefRuntime.EnableHighDpiSupport();

            _settings = new CefSettings
            {
                MultiThreadedMessageLoop = (_config.Platform == ChromelyPlatform.Windows && !_config.WindowOptions.UseOnlyCefMessageLoop),
                LogSeverity      = CefLogSeverity.Info,
                LogFile          = "logs\\chromely.cef_" + DateTime.Now.ToString("yyyyMMdd") + ".log",
                ResourcesDirPath = _config.AppExeLocation
            };

            _settings.LocalesDirPath      = Path.Combine(_settings.ResourcesDirPath, "locales");
            _settings.RemoteDebuggingPort = 20480;
            _settings.Locale    = "en-US";
            _settings.NoSandbox = true;

            var argv = args;

            if (CefRuntime.Platform != CefRuntimePlatform.Windows)
            {
                argv = new string[args.Length + 1];
                Array.Copy(args, 0, argv, 1, args.Length);
                argv[0] = "-";
            }

            // Update configuration settings
            _settings.Update(_config.CustomSettings);

            // For Windows- if MultiThreadedMessageLoop is overriden in Setting using CustomSettings, then
            // It is assumed that the developer way not be aware of IWindowOptions - UseOnlyCefMessageLoop
            if (_config.Platform == ChromelyPlatform.Windows)
            {
                _config.WindowOptions.UseOnlyCefMessageLoop = !_settings.MultiThreadedMessageLoop;
            }

            // Set DevTools url
            string devtoolsUrl = _config.DevToolsUrl;

            if (string.IsNullOrWhiteSpace(devtoolsUrl))
            {
                _config.DevToolsUrl = $"http://127.0.0.1:{_settings.RemoteDebuggingPort}";
            }
            else
            {
                Uri uri = new Uri(devtoolsUrl);
                if (uri.Port <= 80)
                {
                    _config.DevToolsUrl = $"{devtoolsUrl}:{_settings.RemoteDebuggingPort}";
                }
            }

            ResolveHandlers();

            var    mainArgs = new CefMainArgs(argv);
            CefApp app      = CreateApp();

            if (ClientAppUtils.ExecuteProcess(_config.Platform, argv))
            {
                // CEF applications have multiple sub-processes (render, plugin, GPU, etc)
                // that share the same executable. This function checks the command-line and,
                // if this is a sub-process, executes the appropriate logic.
                var exitCode = CefRuntime.ExecuteProcess(mainArgs, app, IntPtr.Zero);
                if (exitCode >= 0)
                {
                    // The sub-process has completed so return here.
                    Logger.Instance.Log.LogInformation($"Sub process executes successfully with code: {exitCode}");
                    return(exitCode);
                }
            }

            CefRuntime.Initialize(mainArgs, _settings, app, IntPtr.Zero);

            _window.RegisterHandlers();
            RegisterDefaultSchemeHandlers();
            RegisterCustomSchemeHandlers();

            CefBinariesLoader.DeleteTempFiles(tempFiles);

            _window.Init(_settings);

            MacHostRuntime.EnsureNativeHostFileExists(_config);

            NativeHost_CreateAndShowWindow();

            NativeHost_Run();

            CefRuntime.Shutdown();

            NativeHost_Quit();

            return(0);
        }