/// <summary> /// The start server. /// </summary> /// <param name="address"> /// The address. /// </param> /// <param name="port"> /// The port. /// </param> /// <param name="completecallback"> /// The completecallback. /// </param> public void StartServer(string address, int port, Action completecallback) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Action <string, int, Action> startServer = (a, p, c) => StartServer(a, p, c); PostTask(CefThreadId.UI, startServer, address, port, completecallback); return; } if (mServer == null) { if (!(port >= 1025 && port <= 65535)) { return; } Address = string.IsNullOrWhiteSpace(address) ? DefaultServerAddress : address; Port = port; mCompleteCallback = completecallback; CefServer.Create(Address, (ushort)Port, DefaultServerBacklog, this); } }
/// <summary> /// The register message routers. /// </summary> private void RegisterMessageRouters() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, this.RegisterMessageRouters); return; } BrowserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); // Register message router handlers List <object> messageRouterHandlers = IoC.GetAllInstances(typeof(ChromelyMessageRouter)).ToList(); if ((messageRouterHandlers != null) && (messageRouterHandlers.Count > 0)) { var routerHandlers = messageRouterHandlers.ToList(); foreach (var item in routerHandlers) { ChromelyMessageRouter routerHandler = (ChromelyMessageRouter)item; if (routerHandler.Handler is CefMessageRouterBrowserSide.Handler) { BrowserMessageRouter.AddHandler((CefMessageRouterBrowserSide.Handler)routerHandler.Handler); } } } else { BrowserMessageRouter.AddHandler(new CefGlueMessageRouterHandler()); } }
public static Task RunAsync(CefThreadId threadId, Action action) { if (CefRuntime.CurrentlyOn(threadId)) { action(); return(TaskHelpers.Completed()); } else { var tcs = new TaskCompletionSource <FakeVoid>(); StartNew(threadId, () => { try { action(); tcs.SetResultAsync(default(FakeVoid)); } catch (Exception e) { tcs.SetExceptionAsync(e); } }); return(tcs.Task); } }
/// <summary> /// The register message routers. /// </summary> private void RegisterMessageRouters() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, RegisterMessageRouters); return; } BrowserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); IoC.RegisterInstance <CefMessageRouterBrowserSide>(typeof(CefMessageRouterBrowserSide).FullName, BrowserMessageRouter); // Register message router handlers var messageRouterHandlers = IoC.GetAllInstances(typeof(ChromelyMessageRouter)).ToList(); if (messageRouterHandlers.Any()) { var routerHandlers = messageRouterHandlers.ToList(); foreach (var item in routerHandlers) { ChromelyMessageRouter routerHandler = (ChromelyMessageRouter)item; if (routerHandler.Handler is CefMessageRouterBrowserSide.Handler) { BrowserMessageRouter.AddHandler((CefMessageRouterBrowserSide.Handler)routerHandler.Handler); } } } else { BrowserMessageRouter.AddHandler(new CefGlueMessageRouterHandler()); } }
protected virtual void RegisterCustomSchemeHandlers() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { ActionTask.PostTask(CefThreadId.UI, RegisterCustomSchemeHandlers); return; } // Register custom request handlers var schemeHandlerList = _handlersResolver?.Invoke(typeof(IChromelySchemeHandler)); if (schemeHandlerList != null && schemeHandlerList.Any()) { foreach (var schemeHandlerObj in schemeHandlerList) { var schemehandler = schemeHandlerObj as IChromelySchemeHandler; if (schemehandler == null || schemehandler.Scheme == null || string.IsNullOrWhiteSpace(schemehandler.Scheme.Scheme) || string.IsNullOrWhiteSpace(schemehandler.Scheme.Host)) { continue; } _requestSchemeProvider.Add(schemehandler.Scheme); var schemeHandlerFactory = schemehandler.HandlerFactory as CefSchemeHandlerFactory; CefRuntime.RegisterSchemeHandlerFactory(schemehandler.Scheme.Scheme, schemehandler.Scheme.Host, schemeHandlerFactory); } } }
protected virtual void RegisterCustomSchemeHandlers() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { ActionTask.PostTask(CefThreadId.UI, RegisterCustomSchemeHandlers); return; } // Register custom request handlers var schemeHandlerList = _handlersResolver?.Invoke(typeof(IChromelySchemeHandler)); if (schemeHandlerList is not null && schemeHandlerList.Any()) { foreach (var schemeHandlerObj in schemeHandlerList) { if (schemeHandlerObj is not IChromelySchemeHandler schemehandler || schemehandler.Scheme is null || !schemehandler.Scheme.ValidSchemeHost) { continue; } _requestSchemeProvider.Add(schemehandler.Scheme); var schemeHandlerFactory = schemehandler.HandlerFactory as CefSchemeHandlerFactory; if (schemeHandlerFactory is not null) { CefRuntime.RegisterSchemeHandlerFactory(schemehandler.Scheme.Scheme, schemehandler.Scheme.Host, schemeHandlerFactory); } } } }
protected virtual void MessageRouterHandlers() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { ActionTask.PostTask(CefThreadId.UI, MessageRouterHandlers); return; } _browserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); // Register message router handlers var messageRouterHandlers = _handlersResolver?.Invoke(typeof(IChromelyMessageRouter))?.ToList(); if (messageRouterHandlers != null && messageRouterHandlers.Any()) { foreach (var handler in messageRouterHandlers) { var router = handler as CefMessageRouterBrowserSide.Handler; if (router != null) { _browserMessageRouter.AddHandler(router); } } } }
/// <summary> /// The register AJAX scheme handlers. /// </summary> private void RegisterAjaxSchemeHandlers() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, RegisterAjaxSchemeHandlers); return; } // Register AJAX scheme handlers var schemeSchemes = _config?.UrlSchemes.GetAllAjaxSchemes(); if (schemeSchemes != null && schemeSchemes.Any()) { foreach (var item in schemeSchemes) { bool isDefault = true; if (!string.IsNullOrWhiteSpace(item.Name)) { var schemeObj = _container.GetInstance(typeof(IChromelySchemeHandlerFactory), item.Name); var schemeHandlerFactory = schemeObj as CefSchemeHandlerFactory; if (schemeHandlerFactory != null) { isDefault = false; CefRuntime.RegisterSchemeHandlerFactory(item.Scheme, item.Host, schemeHandlerFactory); } } if (isDefault) { CefRuntime.RegisterSchemeHandlerFactory(item.Scheme, item.Host, new ExternalRequestSchemeHandlerFactory()); } } } }
/// <summary> /// The start server. /// </summary> /// <param name="port"> /// The port. /// </param> /// <param name="completecallback"> /// The completecallback. /// </param> public void StartServer(int port, Action completecallback) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Action <int, Action> startServer = (p, c) => this.StartServer(p, c); this.PostTask(CefThreadId.UI, startServer, port, completecallback); return; } if (this.mServer == null) { if (!(port >= 1025 && port <= 65535)) { return; } this.Address = DefaultServerAddress; this.Port = port; this.mCompleteCallback = completecallback; CefServer.Create(this.Address, (ushort)this.Port, DefaultServerBacklog, this); } }
/// <summary> /// The register message routers. /// </summary> private void RegisterMessageRouters() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, RegisterMessageRouters); return; } BrowserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); // Register message router handlers var messageRouterHandlers = _container.GetAllInstances(typeof(IChromelyMessageRouter)); if (messageRouterHandlers == null && messageRouterHandlers.Any()) { foreach (var handler in messageRouterHandlers) { var router = handler as CefMessageRouterBrowserSide.Handler; if (router != null) { BrowserMessageRouter.AddHandler(router); } } } else { BrowserMessageRouter.AddHandler(new CefGlueMessageRouterHandler(_requestTaskRunner)); } }
internal static void RequireRendererThread() { if (!CefRuntime.CurrentlyOn(CefThreadId.Renderer)) { throw new InvalidOperationException("This method should be called on CEF renderer thread."); } }
/// <summary> /// The register resource handlers. /// </summary> private void RegisterResourceHandlers() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, RegisterResourceHandlers); return; } // Register resource handlers var resourceSchemes = _config?.UrlSchemes.GetAllResouceSchemes(); if (resourceSchemes != null && resourceSchemes.Any()) { foreach (var item in resourceSchemes) { bool isDefault = true; if (!string.IsNullOrWhiteSpace(item.Name)) { var resourceObj = _container.GetInstance(typeof(IChromelyResourceHandlerFactory), item.Name); var resourceHandlerFactory = resourceObj as CefSchemeHandlerFactory; if (resourceHandlerFactory != null) { isDefault = false; CefRuntime.RegisterSchemeHandlerFactory(item.Scheme, item.Host, resourceHandlerFactory); } } if (isDefault) { CefRuntime.RegisterSchemeHandlerFactory(item.Scheme, item.Host, new CefGlueResourceSchemeHandlerFactory()); } } } }
private static bool EnsureOnRendererThread() { if (!CefRuntime.CurrentlyOn(CefThreadId.Renderer)) { Logger.Error("Current thread is not the render thread"); return(false); } return(true); }
private void RegisterMessageRouter() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, this.RegisterMessageRouter); return; } // window.cefQuery({ request: 'my_request', onSuccess: function(response) { console.log(response); }, onFailure: function(err,msg) { console.log(err, msg); } }); DemoApp.BrowserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); DemoApp.BrowserMessageRouter.AddHandler(new DemoMessageRouterHandler()); }
/* * I think it is possible to RegisterMessageRouter prior to an event being added but after the other handler objects are made * The MessageRouterHandler will do a lookup of registered events every time **/ private void RegisterMessageRouter() { Debug.WriteLine(DBGPREFIX + "Message Router, attempting registration"); if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Debug.WriteLine(DBGPREFIX + "Message Router, creating task on UI Thread"); CefRuntime.PostTask(CefThreadId.UI, new ActionTask(RegisterMessageRouter)); return; } // window.cefQuery({ request: 'my_request', onSuccess: function(response) { console.log(response); }, onFailure: function(err,msg) { console.log(err, msg); } }); _messageRouter.AddHandler(MessageRouterHandler); Debug.WriteLine(DBGPREFIX + "Message Router, registered"); }
protected void NativeHost_CreateAndShowWindow() { if (_config.Platform != ChromelyPlatform.Windows) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { ActionTask.PostTask(CefThreadId.UI, NativeHost_CreateAndShowWindow); return; } } _nativeHost?.CreateWindow(_config.WindowOptions, _config.DebuggingMode); }
private void CreateMainWindow() { if (_config.Platform != ChromelyPlatform.Windows) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, CreateMainWindow); return; } } _mainWindow = CreateMainView(); }
/// <summary> /// The run complete callback. /// </summary> /// <param name="isRunning"> /// The is running. /// </param> private void RunCompleteCallback(bool isRunning) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Action <bool> run = (f) => RunCompleteCallback(f); PostTask(CefThreadId.UI, run, isRunning); return; } mCompleteCallback?.Invoke(); }
private void RegisterMessageRouter() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, this.RegisterMessageRouter); return; } BrowserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); _queryHandler = new WorkerCefMessageRouterHandler(); _queryHandler.OnBrowserQuery += Handler_OnBrowserQuery; BrowserMessageRouter.AddHandler(_queryHandler); }
/// <summary> /// Executes the task on the selected CEF thread. /// </summary> /// <param name="threadId">The thread identifier.</param> /// <param name="action">The action.</param> /// <exception cref="System.ArgumentNullException">action</exception> public static void ExecuteTask(CefThreadId threadId, Action action) { if (action == null) { throw new ArgumentNullException("action"); } if (!CefRuntime.CurrentlyOn(threadId)) { CefRuntime.PostTask(threadId, new ActionTask(action)); } else { action(); } }
/// <summary> /// The run complete callback. /// </summary> /// <param name="isRunning"> /// The is running. /// </param> private void RunCompleteCallback(bool isRunning) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Action <bool> run = (f) => this.RunCompleteCallback(f); this.PostTask(CefThreadId.UI, run, isRunning); return; } if (this.mCompleteCallback != null) { this.mCompleteCallback.Invoke(); } }
private void RegisterMessageRouter() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { PostTask(CefThreadId.UI, this.RegisterMessageRouter); return; } BrowserMessageRouter = new CefMessageRouterBrowserSide(new CefMessageRouterConfig()); _queryHandler = new WorkerCefMessageRouterHandler(); _queryHandler.OnBrowserQuery += Handler_OnBrowserQuery; BrowserMessageRouter.AddHandler(_queryHandler); var myFactory = new MySchemeHandlerFactory(_staticResourceStorage, this); CefRuntime.RegisterSchemeHandlerFactory("http", _domainId, myFactory); }
/// <summary> /// The stop server. /// </summary> /// <param name="completecallback"> /// The completecallback. /// </param> public void StopServer(Action completecallback) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Action <Action> stopServer = (c) => this.StopServer(c); this.PostTask(CefThreadId.UI, stopServer, completecallback); return; } if (this.mServer != null) { this.mCompleteCallback = completecallback; this.mServer.Shutdown(); } }
protected virtual void RegisterDefaultSchemeHandlers() { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { ActionTask.PostTask(CefThreadId.UI, RegisterDefaultSchemeHandlers); return; } if (_handlersResolver is null) { return; } // Register default resource/reguest handlers IDictionary <UrlSchemeType, Type> urlTypesMapper = new Dictionary <UrlSchemeType, Type> { { UrlSchemeType.LocalResource, typeof(IDefaultResourceCustomHandler) }, { UrlSchemeType.FolderResource, typeof(IDefaultResourceCustomHandler) }, { UrlSchemeType.AssemblyResource, typeof(IDefaultAssemblyResourceCustomHandler) }, { UrlSchemeType.LocalRequest, typeof(IDefaultRequestCustomHandler) }, { UrlSchemeType.Owin, typeof(IDefaultOwinCustomHandler) }, { UrlSchemeType.ExternalRequest, typeof(IDefaultExernalRequestCustomHandler) } }; foreach (var urlType in urlTypesMapper) { var handler = _handlersResolver.GetDefaultHandler(typeof(CefSchemeHandlerFactory), urlType.Value); if (handler is CefSchemeHandlerFactory schemeHandlerFactory) { var schemes = _config?.UrlSchemes.GetSchemesByType(urlType.Key); if (schemes is not null && schemes.Any()) { foreach (var item in schemes) { _requestSchemeProvider.Add(item); CefRuntime.RegisterSchemeHandlerFactory(item.Scheme, item.Host, schemeHandlerFactory); } } } } }
/// <summary> /// Calls back into V8 in response to either: /// - a local function response message /// - a local event fired message /// - an exception while making a local function call /// Will switch to the Renderer thread if needed. /// </summary> /// <param name="call"></param> /// <param name="result"></param> /// <param name="errorCode"></param> /// <param name="error"></param> public void LocalCallbackInvoked(LocalRenderCallInfo call, object result, int errorCode, string error) { if (!CefRuntime.CurrentlyOn(CefThreadId.Renderer)) { // Call completed received from remote process, so currently are on the IO method. Marshal to the renderer to callback into V8 CefRuntime.PostTask(CefThreadId.Renderer, new ActionCallbackTask(() => LocalCallbackInvoked(call, result, errorCode, error))); return; } var msg = call.RequestMessage; Logger.Info("LocalCallbackInvoked MsgType {0} Plugin {1} Member {2}", msg.MessageType, msg.PluginId, msg.MemberName); // Already on the render thread (e.g. local plugin event triggered by call into function from JS, or function invoke failed try { var context = GetContextById(call.RequestMessage.ContextId); if (!call.IsRetained) { _pendingCallbacks.Remove(call); } if (context != null && call.Callback != null) { call.Callback.Invoke(this, context, result, errorCode, error); } if (!call.IsRetained) { call.Dispose(); } } catch (Exception exception) { Logger.Error("LocalCallbackInvoked Failed MsgType {0} Plugin {1} Member {2}: {3}", call.RequestMessage.MessageType, call.RequestMessage.PluginId, call.RequestMessage.MemberName, exception); } }
/// <summary> /// Notify the associated JavaScript onFailure callback that the query has /// failed with the specified |error_code| and |error_message|. /// </summary> public void Failure(int errorCode, string errorMessage) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { // Must execute on the UI thread to access member variables. Helpers.PostTask(CefThreadId.UI, Helpers.Apply(this.Failure, errorCode, errorMessage) ); return; } if (_router != null) { Helpers.PostTaskUncertainty(CefThreadId.UI, Helpers.Apply(_router.OnCallbackFailure, _browserId, _queryId, errorCode, errorMessage) ); // Failure always invalidates the callback. _router = null; } }
// Cancel all pending queries associated with either |browser| or |handler|. // If both |browser| and |handler| are NULL all pending queries will be // canceled. Set |notify_renderer| to true if the renderer should be notified. private void CancelPendingFor(CefBrowser browser, Handler handler, bool notifyRenderer) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { // Must execute on the UI thread. Helpers.PostTask(CefThreadId.UI, Helpers.Apply(this.CancelPendingFor, browser, handler, notifyRenderer) ); return; } if (_browserQueryInfoMap.IsEmpty) { return; } BrowserInfoMap.Visitor visitor = (int browserId, long queryId, QueryInfo info, ref bool remove) => { if (handler == null || info.Handler == handler) { remove = true; CancelQuery(queryId, info, notifyRenderer); info.Dispose(); } return(true); }; if (browser != null) { // Cancel all queries associated with the specified browser. _browserQueryInfoMap.FindAll(browser.Identifier, visitor); } else { // Cancel all queries for all browsers. _browserQueryInfoMap.FindAll(visitor); } }
/// <summary> /// Notify the associated JavaScript onSuccess callback that the query has /// completed successfully with the specified |response|. /// </summary> public void Success(string response) { if (!CefRuntime.CurrentlyOn(CefThreadId.UI)) { Helpers.PostTask(CefThreadId.UI, Helpers.Apply(this.Success, response) ); return; } if (_router != null) { Helpers.PostTaskUncertainty(CefThreadId.UI, Helpers.Apply(_router.OnCallbackSuccess, _browserId, _queryId, response) ); if (!_persistent) { // Non-persistent callbacks are only good for a single use. _router = null; } } }