Async Javascript to Native C# with Params ???
AdP
Balázs Szántó
AdP
- Invocation starts in browser process. I use sendProcessMessage to form a JS function invocation with structured parameters and send it off to the renderer process. This is asynchronous.
- In rederer process I receive this message in the RendererProcessHandler, transform the parameters into a JS call and invoke in synchronous fashion using the V8Context and tryEval. I get the return value and now use sendProcessMessage to send the results back to the browser processs. You can easily set up a scheme to either pass a callback or some other patter so that you can match up original send to the receive in the browser.
- Browser process receives the message from renderer in the BrowserClient and handles is as a return value form original call.
- In C# RendererProcessHandler I create JS function handles (these are known up front) and register a custom handler for them. Assume one of these is called testJS2Native
- JS simply invokes window.testJS2Native.
- Call gets intercepted in the handler I registered in #1, I spawn user thread (Task) and do my processing in renderer process. At the end I post the results back to JS via CefTaskRunner and PostTask. Since this is async, I set up 2 call back in my original JS functions - success and failure. PostTask simply does executeFunctionWithCallback on those as needed.
Mark Morgan
--
You received this message because you are subscribed to the Google Groups "CefGlue" group.
To unsubscribe from this group and stop receiving emails from it, send an email to cefglue+u...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Balázs Szántó
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Threading;
using System;
namespace Xilium.CefGlue.Client
{
internal sealed class DemoApp : CefApp
{
private CefRenderProcessHandler renderProcessHandler = new DemoRenderProcessHandler();
protected override CefRenderProcessHandler GetRenderProcessHandler()
{
return renderProcessHandler;
}
}
internal class DemoRenderProcessHandler : CefRenderProcessHandler
{
MyCustomCefV8Handler myCefV8Handler = new MyCustomCefV8Handler();
protected override void OnWebKitInitialized()
{
base.OnWebKitInitialized();
var nativeFunction = @"nativeImplementation = function(onSuccess) {
native function MyNativeFunction(onSuccess);
return MyNativeFunction(onSuccess);
};";
CefRuntime.RegisterExtension("myExtension", nativeFunction, myCefV8Handler);
}
}
internal class MyCustomCefV8Handler : CefV8Handler
{
protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue,
out string exception)
{
//Debugger.Launch();
var context = CefV8Context.GetCurrentContext();
var taskRunner = CefTaskRunner.GetForCurrentThread();
var callback = arguments[0];
new Thread(() =>
{
//Sleep a bit: to test whether the app remains responsive
Thread.Sleep(3000);
taskRunner.PostTask(new CefCallbackTask(context, callback));
}).Start();
returnValue = CefV8Value.CreateBool(true);
exception = null;
return true;
}
}
internal class CefCallbackTask : CefTask
{
private readonly CefV8Context context;
private readonly CefV8Value callback;
public CefCallbackTask(CefV8Context context, CefV8Value callback)
{
this.context = context;
this.callback = callback;
}
protected override void Execute()
{
var callbackArguments = CreateCallbackArguments();
callback.ExecuteFunctionWithContext(context, null, callbackArguments);
}
private CefV8Value[] CreateCallbackArguments()
{
var imageInBase64EncodedString = LoadImage(@"C:\hamb.jpg");
context.Enter();
var imageV8String = CefV8Value.CreateString(imageInBase64EncodedString);
var featureV8Object = CefV8Value.CreateObject(null);
var listOfFeaturesV8Array = CefV8Value.CreateArray(1);
featureV8Object.SetValue("name", CefV8Value.CreateString("V8"), CefV8PropertyAttribute.None);
featureV8Object.SetValue("isEnabled", CefV8Value.CreateInt(0), CefV8PropertyAttribute.None);
featureV8Object.SetValue("isFromJSCode", CefV8Value.CreateBool(false), CefV8PropertyAttribute.None);
listOfFeaturesV8Array.SetValue(0, featureV8Object);
context.Exit();
return new [] { listOfFeaturesV8Array, imageV8String };
}
private string LoadImage(string fileName)
{
using (var memoryStream = new MemoryStream())
{
var image = Bitmap.FromFile(fileName);
image.Save(memoryStream, ImageFormat.Png);
byte[] imageBytes = memoryStream.ToArray();
return Convert.ToBase64String(imageBytes);
}
}
}
}
The html file, that I loaded at the first place:
<!DOCTYPE html>
<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<title>C# and JS experiments</title>
<script src="index.js"></script>
</head>
<body>
<h1>C# and JS are best friends</h1>
<div id="features">
</div>
<div id="image">
</div>
</body>
</html>
The javascript code:
function Browser() {
}
Browser.prototype.ListAllFeatures = function (onSuccess) {
return nativeImplementation(onSuccess);
}
function App(browser) {
this.browser = browser;
}
App.prototype.Run = function () {
var beforeRun = new Date().getTime();
this.browser.ListAllFeatures(function(features, imageInBase64EncodedString) {
var feautersListString = '';
for (var i = 0; i < features.length; i++) {
var f = features[i];
feautersListString += ('<p>' + 'Name: ' + f.name + ', is enabled: ' + f.isEnabled + ', is called from js code: ' + f.isFromJSCode + '</p>');
}
feautersListString += '<p> The image: </p>';
feautersListString += '<p>' + imageInBase64EncodedString + '</p>';
document.getElementById("features").innerHTML = feautersListString;
var afterRun = new Date().getTime();
document.getElementById("image").innerHTML = '<img src="data:image/png;base64,' + imageInBase64EncodedString + '" />';
var afterLoadedImage = new Date().getTime();
console.log("ELAPSED TIME - INSIDE LIST ALL FEATURES: " + (afterRun - beforeRun));
console.log("ELAPSED TIME - IMAGE IS LOADED TO THE <img> TAG: " + (afterLoadedImage - beforeRun));
});
}
window.onload = function () {
var browser = new Browser();
var application = new App(browser);
//Lets measure
var beforeRun = new Date().getTime();
application.Run();
var afterRun = new Date().getTime();
console.log("ELAPSED TIME - INSIDE ONLOAD: " + (afterRun - beforeRun));
AdP
BBird40
AdP
shijeesh c
Dmitry Azaraev
Provide symbolized call stack please if crash have place. Looks like you something do wrong.
shijeesh c
Dmitry Azaraev
Enable cef logging, it may contain useful info. Symbolized call stack is crash call stack, which can be obtained from log (if available) or from crash minidump. WER can create minidumps, but i'm not sure. Anyway provided info is WER's metadata, which doesn't provide any useful info.
Also I see that crash happens in vshost process. Disable visual studio debug hosting process in project properties - it is too weak to deal with child processes correctly.
shijeesh c
shijeesh c
Dmitry Azaraev
PS: single process mode for debugging purposes only.