public RemoteV8Plugin(IV8PluginRouter router, IPluginContext pluginContext, PluginDescriptor remoteObjectDescriptor)
: base(pluginContext, remoteObjectDescriptor)
{
if (router == null)
{
throw new ArgumentNullException("router");
}
_router = router;
}
public virtual void Invoke(IV8PluginRouter router, CefV8Context context, object result, int errorCode, string error)
{
if (CallbackFunction == null)
{
throw new ObjectDisposedException("_callback");
}
// Have to enter the context in order to be able to create object/array/function/date V8 instances
context.Enter();
try
{
var args = new List <CefV8Value>();
switch (_callbackType)
{
case V8CallbackType.ParameterCallback:
case V8CallbackType.EventListener:
{
var remoteResult = result as ResultData;
var localArray = result as object[];
if (remoteResult != null)
{
if (remoteResult.Items != null)
{
args.AddRange(remoteResult.Items.Select(item => ToCefV8Value(router, item)));
}
}
else if (localArray != null)
{
args.AddRange(localArray.Select(item => ToCefV8Value(router, item)));
}
break;
}
case V8CallbackType.FunctionCallback:
{
args.Add(ToCefV8Value(router, result));
args.Add(CefV8Value.CreateInt(errorCode));
args.Add(CefV8Value.CreateString(error));
break;
}
}
var functionResult = CallbackFunction.ExecuteFunction(null, args.ToArray());
if (functionResult == null && CallbackFunction.HasException)
{
var exception = CallbackFunction.GetException();
Logger.Error("Error executing callback: ", exception.Message);
}
}
finally
{
context.Exit();
}
}
public LocalV8Plugin(IV8PluginRouter router, IPluginContext pluginContext, JavaScriptPlugin plugin)
: base(pluginContext, plugin.Descriptor)
{
if (router == null)
{
throw new ArgumentNullException("router");
}
_router = router;
_plugin = plugin;
}
/// <summary>
/// Create an adapter for a local (in-process) plugin.
/// </summary>
/// <param name="router"></param>
/// <param name="pluginContext"></param>
/// <param name="jsPlugin"></param>
/// <returns></returns>
public static V8PluginAdapter CreateLocal(IV8PluginRouter router, IPluginContext pluginContext, JavaScriptPlugin jsPlugin)
{
if (jsPlugin == null)
{
return(null);
}
var plugin = new LocalV8Plugin(router, pluginContext, jsPlugin);
var pluginAdapter = new V8PluginAdapter(plugin);
return(pluginAdapter);
}
public override void Invoke(IV8PluginRouter router, CefV8Context context, object result, int errorCode, string error)
{
// No need to enter context, since we are executing synchronously
try
{
Result = this.ToCefV8Value(router, result);
Error = error;
}
catch (Exception ex)
{
Error = ex.Message;
}
}
/// <summary>
/// Create an adapter for a remote (out-of-process) plugin.
/// </summary>
/// <param name="router"></param>
/// <param name="pluginContext"></param>
/// <param name="descriptor"></param>
/// <returns></returns>
public static V8PluginAdapter CreateRemote(IV8PluginRouter router, IPluginContext pluginContext, PluginDescriptor descriptor)
{
V8PluginAdapter adapter;
if (!RemotePluginAdapterCache.TryGetValue(descriptor.PluginId, out adapter))
{
lock (RemotePluginAdapterCache)
{
if (!RemotePluginAdapterCache.TryGetValue(descriptor.PluginId, out adapter))
{
var plugin = new RemoteV8Plugin(router, pluginContext, descriptor);
adapter = new V8PluginAdapter(plugin);
RemotePluginAdapterCache.Add(descriptor.PluginId, adapter);
}
}
}
return(adapter);
}
public PluginContext(IV8PluginRouter router, Guid pluginContextId)
{
_router = router;
_pluginManager = new PluginManager(PluginProcess.Renderer);
}
protected CefV8Value ToCefV8Value(IV8PluginRouter router, object result)
{
if (result == null)
{
return(CefV8Value.CreateNull());
}
// VALUES FROM REMOTE PLUGINS
var remoteResult = result as ResultData;
if (remoteResult != null)
{
switch (remoteResult.DataType)
{
case ResultDataType.Scalar:
if (remoteResult.Items != null && remoteResult.Items.Count != 0)
{
return(ToCefV8Value(router, remoteResult.Items[0]));
}
return(CefV8Value.CreateNull());
case ResultDataType.Array:
{
var cefArray = CefV8Value.CreateArray(remoteResult.Items.Count);
if (remoteResult.Items != null)
{
for (var resultIndex = 0; resultIndex < remoteResult.Items.Count; ++resultIndex)
{
var cefValue = ToCefV8Value(router, remoteResult.Items[resultIndex]);
cefArray.SetValue(resultIndex, cefValue);
}
}
return(cefArray);
}
case ResultDataType.Dictionary:
{
var cefObject = CefV8Value.CreateObject(null);
if (remoteResult.Items != null)
{
foreach (var dictionaryItem in remoteResult.Items)
{
if (string.IsNullOrEmpty(dictionaryItem.Name))
{
continue;
}
var cefValue = ToCefV8Value(router, dictionaryItem);
cefObject.SetValue(dictionaryItem.Name, cefValue, CefV8PropertyAttribute.None);
}
}
return(cefObject);
}
}
}
var resultItem = result as ResultItem;
if (resultItem != null)
{
return(ToCefV8Value(router, (object)resultItem.DynamicPlugin ?? resultItem.PlainData));
}
var pluginObjectDescriptor = result as PluginDescriptor;
if (pluginObjectDescriptor != null)
{
return(V8PluginAdapter.CreateRemote(router, _plugin.PluginContext, pluginObjectDescriptor).V8Object);
}
// VALUES FROM REMOTE OR LOCAL PLUGINS
var plainData = result as JToken;
if (plainData != null)
{
return(CefJsonValueConverter.ToCef(plainData));
}
// VALUES FROM LOCAL PLUGINS
var localArray = result as object[];
if (localArray != null)
{
var cefArray = CefV8Value.CreateArray(localArray.Length);
for (var resultIndex = 0; resultIndex < localArray.Length; ++resultIndex)
{
var cefValue = ToCefV8Value(router, localArray[resultIndex]);
cefArray.SetValue(resultIndex, cefValue);
}
return(cefArray);
}
var localPlugin = result as JavaScriptPlugin;
if (localPlugin != null)
{
return(V8PluginAdapter.CreateLocal(router, _plugin.PluginContext, localPlugin).V8Object);
}
if (JavaScriptPlugin.IsDynamicPlugin(result))
{
var dynPlugin = JavaScriptPlugin.CreateFromObject(PluginProcess.Renderer, result);
_plugin.PluginContext.PluginManager.AddLocalPlugin(dynPlugin);
return(V8PluginAdapter.CreateLocal(router, _plugin.PluginContext, dynPlugin).V8Object);
}
// local C# POCO
return(CefNativeValueConverter.ToCef(result));
}
