public V8Callback GetOrCreateCallback(IV8Plugin plugin, string memberName, CefV8Value callback, V8CallbackType callbackType)
{
V8Callback adapter = null;
_callbacksByMemberName.AddOrUpdate(
memberName,
key =>
{
var disposeCallback = new Action <V8Callback>(cb => DisposeCallback(memberName, cb));
adapter = new V8Callback(plugin, callback, callbackType, disposeCallback);
return(new List <V8Callback> {
adapter
});
},
(key, list) =>
{
adapter = list.FirstOrDefault(c => c.CallbackFunction != null && c.CallbackFunction.IsSame(callback));
if (adapter == null)
{
var disposeCallback = new Action <V8Callback>(cb => DisposeCallback(memberName, cb));
adapter = new V8Callback(plugin, callback, callbackType, disposeCallback);
list.Add(adapter);
}
return(list);
});
return(adapter);
}
public V8Callback(IV8Plugin plugin, CefV8Value callback, V8CallbackType callbackType, Action <V8Callback> disposeHandler = null)
{
_plugin = plugin;
CallbackFunction = callback;
_callbackType = callbackType;
_disposeHandler = disposeHandler;
Identifier = Guid.NewGuid();
}
/// <summary>
/// Create a new V8 plugin adapter.
/// </summary>
/// <param name="pluginObject">
/// The local or remote native plugin to adapt to V8.
/// </param>
/// <param name="v8HostObject">
/// Optional - if supplied, the adapter will add the native methods and events to this
/// existing object instead of creating a new one with a property accessor.
/// </param>
private V8PluginAdapter(IV8Plugin pluginObject, CefV8Value v8HostObject = null)
{
Plugin = pluginObject;
V8Object = v8HostObject;
if (V8Object == null)
{
V8Object = CefV8Value.CreateObject(new PluginV8Accessor());
V8Object.SetUserData(this);
}
// Create a single method handler configured to handle all methods on the plugin
var methodHandler = new PluginMethodV8Handler(Plugin);
foreach (var methodDescriptor in Plugin.Descriptor.Methods)
{
V8Object.SetValue(methodDescriptor.MethodName,
CefV8Value.CreateFunction(methodDescriptor.MethodName, methodHandler),
CefV8PropertyAttribute.None);
}
foreach (var eventName in Plugin.Descriptor.Events)
{
// For each event, create a child object exposed as a property named after the event
// The child object is a syntactic placeholder for the addListener/removeListener/hasListener/hasListeners methods
var eventObject = CefV8Value.CreateObject(null);
var eventHandler = new PluginEventV8Handler(Plugin, eventName);
eventObject.SetValue(PluginEventV8Handler.MethodNameAddListener,
CefV8Value.CreateFunction(PluginEventV8Handler.MethodNameAddListener, eventHandler),
CefV8PropertyAttribute.None);
eventObject.SetValue(PluginEventV8Handler.MethodNameRemoveListener,
CefV8Value.CreateFunction(PluginEventV8Handler.MethodNameRemoveListener, eventHandler),
CefV8PropertyAttribute.None);
eventObject.SetValue(PluginEventV8Handler.MethodNameHasListener,
CefV8Value.CreateFunction(PluginEventV8Handler.MethodNameHasListener, eventHandler),
CefV8PropertyAttribute.None);
eventObject.SetValue(PluginEventV8Handler.MethodNameHasListeners,
CefV8Value.CreateFunction(PluginEventV8Handler.MethodNameHasListeners, eventHandler),
CefV8PropertyAttribute.None);
V8Object.SetValue(eventName, eventObject, CefV8PropertyAttribute.None);
}
}
public PluginMethodV8Handler(IV8Plugin plugin)
{
_plugin = plugin;
}
public LocalV8Callback(IV8Plugin plugin)
: base(plugin, null, V8CallbackType.FunctionCallback, null)
{
}
public PluginEventV8Handler(IV8Plugin pluginObject, string eventName)
{
_plugin = pluginObject;
_eventName = eventName;
}
public static V8PluginAdapter Create(IV8Plugin pluginObject, CefV8Value v8HostObject)
{
return(new V8PluginAdapter(pluginObject, v8HostObject));
}
