private static IAsyncResult BeginMethod <T>(JavaScriptValue func, IServiceNode node, AsyncCallback callback, object state)
{
var conveter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
AsyncResult <T> result = new AsyncResult <T>();
Action <T> fullfilledCallback = (x) =>
{
result.SetResult(x);
callback(result);
};
Action <string> rejectedCallback = (s) =>
{
result.SetResult(default(T));
throw new PromiseRejectedException(s);
};
Func <JSValue> promiseCall = conveter.FromJSValue <Func <JSValue> >(func); // the target function which returns a promise object
JSValue promiseObject = promiseCall(); //call the function,get the Promise object
var service = promiseObject.ServiceNode.GetService <PromiseCallbackPairService>(); //get the delegate interceptor
service.Begin(); //enable the interceptor
promiseObject.CallMethod <Action <T>, Action <String> >("then", fullfilledCallback, rejectedCallback);
System.Diagnostics.Debug.WriteLine("[Then] called");
service.End();//disable the interceptor
return(result);
}
private static Action <T1, T2, T3, T4, T5> fromJSMethod <T1, T2, T3, T4, T5>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
Action <T1, T2, T3, T4, T5> result = (T1 para1, T2 para2, T3 para3, T4 para4, T5 para5) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
node.WithContext(() =>
{
var caller = node.GetService <ICallContextService>().Caller;
p1.AddRef();
p2.AddRef();
p3.AddRef();
p4.AddRef();
p5.AddRef();
value.CallFunction(caller, p1, p2, p3, p4, p5);
p1.Release();
p2.Release();
p3.Release();
p4.Release();
p5.Release();
});
GC.KeepAlive(stub); //keep referenced javascript value alive
};
return(result);
}
private static Action <T1, T2, T3, T4, T5, T6> fromJSMethod <T1, T2, T3, T4, T5, T6>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
Action <T1, T2, T3, T4, T5, T6> result = (T1 para1, T2 para2, T3 para3, T4 para4, T5 para5, T6 para6) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
JavaScriptValue p6 = converter.ToJSValue <T6>(para6);
node.WithContext(() =>
{
var caller = node.GetService <ICallContextService>().Caller;
p1.AddRef();
p2.AddRef();
p3.AddRef();
p4.AddRef();
p5.AddRef();
p6.AddRef();
value.CallFunction(caller, p1, p2, p3, p4, p5, p6);
p1.Release();
p2.Release();
p3.Release();
p4.Release();
p5.Release();
p6.Release();
});
};
return(result);
}
private static JavaScriptValue toJSFunction <T1, T2, T3, T4, T5, TResult> (IServiceNode node, Func <bool, T1, T2, T3, T4, T5, TResult> callback)
{
var converter = node.GetService <IJSValueConverterService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 6)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
T1 para1 = converter.FromJSValue <T1>(arguments[1]);
T2 para2 = converter.FromJSValue <T2>(arguments[2]);
T3 para3 = converter.FromJSValue <T3>(arguments[3]);
T4 para4 = converter.FromJSValue <T4>(arguments[4]);
T5 para5 = converter.FromJSValue <T5>(arguments[5]);
arguments[1].AddRef();
arguments[2].AddRef();
arguments[3].AddRef();
arguments[4].AddRef();
arguments[5].AddRef();
TResult result = callback(isConstructCall, para1, para2, para3, para4, para5);
arguments[1].Release();
arguments[2].Release();
arguments[3].Release();
arguments[4].Release();
arguments[5].Release();
return(converter.ToJSValue <TResult>(result));
};
return(node.GetService <IJSValueService>().CreateFunction(f, IntPtr.Zero));
}
private static Func <bool, T1, TResult> fromJSFunction <T1, TResult>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
var callContext = node.GetService <ICallContextService>();
Func <bool, T1, TResult> result = (bool isConstruct, T1 para1) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
{
p1.AddRef();
JavaScriptValue resultValue;
if (isConstruct)
{
resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1);
}
else
{
resultValue = jsValueService.CallFunction(value, callContext.Caller, p1);
}
p1.Release();
return(resultValue);
});
return(converter.FromJSValue <TResult>(r));
};
return(result);
}
private static Func <bool, T1, TResult> fromJSFunction <T1, TResult>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
var callContext = node.GetService <ICallContextService>();
IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
Func <bool, T1, TResult> result = (bool isConstruct, T1 para1) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
{
p1.AddRef();
JavaScriptValue resultValue;
if (isConstruct)
{
resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1);
}
else
{
resultValue = jsValueService.CallFunction(value, callContext.Caller, p1);
}
p1.Release();
GC.KeepAlive(stub);//keep referenced javascript value alive
return(resultValue);
});
return(converter.FromJSValue <TResult>(r));
};
return(result);
}
private static JavaScriptValue toJSMethod <T1, T2, T3, T4, T5, T6> (IServiceNode node, Action <T1, T2, T3, T4, T5, T6> a)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 7)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
T1 para1 = converter.FromJSValue <T1>(arguments[1]);
T2 para2 = converter.FromJSValue <T2>(arguments[2]);
T3 para3 = converter.FromJSValue <T3>(arguments[3]);
T4 para4 = converter.FromJSValue <T4>(arguments[4]);
T5 para5 = converter.FromJSValue <T5>(arguments[5]);
T6 para6 = converter.FromJSValue <T6>(arguments[6]);
arguments[1].AddRef();
arguments[2].AddRef();
arguments[3].AddRef();
arguments[4].AddRef();
arguments[5].AddRef();
arguments[6].AddRef();
a(para1, para2, para3, para4, para5, para6);
arguments[1].Release();
arguments[2].Release();
arguments[3].Release();
arguments[4].Release();
arguments[5].Release();
arguments[6].Release();
return(jsValueService.JSValue_Undefined);
};
return(jsValueService.CreateFunction(f, IntPtr.Zero));
}
private static Action <T1, T2, T3> fromJSMethod <T1, T2, T3>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
Action <T1, T2, T3> result = (T1 para1, T2 para2, T3 para3) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
node.WithContext(() =>
{
var caller = node.GetService <ICallContextService>().Caller;
p1.AddRef();
p2.AddRef();
p3.AddRef();
value.CallFunction(caller, p1, p2, p3);
p1.Release();
p2.Release();
p3.Release();
});
};
return(result);
}
private static Func <bool, T1, T2, T3, T4, T5, T6, T7, TResult> fromJSFunction <T1, T2, T3, T4, T5, T6, T7, TResult>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
var callContext = node.GetService <ICallContextService>();
IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
Func <bool, T1, T2, T3, T4, T5, T6, T7, TResult> result = (bool isConstruct, T1 para1, T2 para2, T3 para3, T4 para4, T5 para5, T6 para6, T7 para7) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
JavaScriptValue p6 = converter.ToJSValue <T6>(para6);
JavaScriptValue p7 = converter.ToJSValue <T7>(para7);
JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
{
p1.AddRef();
p2.AddRef();
p3.AddRef();
p4.AddRef();
p5.AddRef();
p6.AddRef();
p7.AddRef();
JavaScriptValue resultValue;
if (isConstruct)
{
resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1, p2, p3, p4, p5, p6, p7);
}
else
{
resultValue = jsValueService.CallFunction(value, callContext.Caller, p1, p2, p3, p4, p5, p6, p7);
}
p1.Release();
p2.Release();
p3.Release();
p4.Release();
p5.Release();
p6.Release();
p7.Release();
GC.KeepAlive(stub);//keep referenced javascript value alive
return(resultValue);
});
return(converter.FromJSValue <TResult>(r));
};
return(result);
}
private static Action fromJSMethod(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
Action result = () =>
{
node.WithContext(() =>
{
var caller = node.GetService <ICallContextService>().Caller;
value.CallFunction(caller);
});
};
return(result);
}
public static void InjectShareMemoryObjects(this IServiceNode target)
{
//create/release all these objects inside the runtime internal context, this make sure all objects can be destroyed even user context is released
var converter = target.GetService <IJSValueConverterService>();
//var switchService = target.ServiceNode.GetService<IRuntimeService>().InternalContextSwitchService;
if (converter.CanConvert <JSArrayBuffer>())
{
return;
}
converter.RegisterConverter <JSArrayBuffer>(
(node, value) =>
{
var jsValueService = node.GetService <IJSValueService>();
return(jsValueService.CreateArrayBuffer(value));
},
(node, value) =>
{
var switchService = node.GetService <IRuntimeService>().InternalContextSwitchService;
return(switchService.With <JSArrayBuffer>(() =>
{
if (value.ValueType != JavaScriptValueType.ArrayBuffer)
{
throw new InvalidOperationException("source type should be ArrayBuffer");
}
IntPtr buffer = JavaScriptValue.GetArrayBufferStorage(value, out uint size);
var result = JSArrayBuffer.CreateFromJS(buffer, size, value, switchService);
return result;
}));
}, false
private static Action fromJSMethod(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
Action result = () =>
{
node.WithContext(() =>
{
var caller = node.GetService <ICallContextService>().Caller;
value.CallFunction(caller);
});
GC.KeepAlive(stub); //keep referenced javascript value alive
};
return(result);
}
public static void InjecTimerService(this IServiceNode target)
{
target.GetService <IJSValueConverterService>().RegisterProxyConverter <JSTimer>((binding, value, node) =>
{
binding.SetMethod <Action, int>("setTimeout", value.SetTimeout);
binding.SetFunction <Action, int, Guid>("setInterval", value.SetInterval);
binding.SetMethod <Guid>("clearInterval", value.ClearInterval);
});
}
private static Func <bool, T1, T2, T3, T4, T5, T6, TResult> fromJSFunction <T1, T2, T3, T4, T5, T6, TResult>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
var callContext = node.GetService <ICallContextService>();
Func <bool, T1, T2, T3, T4, T5, T6, TResult> result = (bool isConstruct, T1 para1, T2 para2, T3 para3, T4 para4, T5 para5, T6 para6) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
JavaScriptValue p6 = converter.ToJSValue <T6>(para6);
JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
{
p1.AddRef();
p2.AddRef();
p3.AddRef();
p4.AddRef();
p5.AddRef();
p6.AddRef();
JavaScriptValue resultValue;
if (isConstruct)
{
resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1, p2, p3, p4, p5, p6);
}
else
{
resultValue = jsValueService.CallFunction(value, callContext.Caller, p1, p2, p3, p4, p5, p6);
}
p1.Release();
p2.Release();
p3.Release();
p4.Release();
p5.Release();
p6.Release();
return(resultValue);
});
return(converter.FromJSValue <TResult>(r));
};
return(result);
}
private static JavaScriptValue toJSFunction <TResult> (IServiceNode node, Func <bool, TResult> callback)
{
var converter = node.GetService <IJSValueConverterService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 1)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
TResult result = callback(isConstructCall);
return(converter.ToJSValue <TResult>(result));
};
return(node.GetService <IJSValueService>().CreateFunction(f, IntPtr.Zero));
}
private static JavaScriptValue ToJSMethod(IServiceNode node, Action <IEnumerable <JavaScriptValue> > a)
{
IJSValueService jsValueService = node.GetService <IJSValueService>();
return(jsValueService.CreateFunction(
(JavaScriptNativeFunction)((callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
a(arguments.Skip(1));
return jsValueService.JSValue_Undefined;
}), IntPtr.Zero));
}
private static JavaScriptValue toJSMethod(IServiceNode node, Action a)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 1)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
a();
return(jsValueService.JSValue_Undefined);
};
return(jsValueService.CreateFunction(f, IntPtr.Zero));
}
private static Action <T1> fromJSMethod <T1>(IServiceNode node, JavaScriptValue value)
{
var converter = node.GetService <IJSValueConverterService>();
IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
Action <T1> result = (T1 para1) =>
{
JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
node.WithContext(() =>
{
var caller = node.GetService <ICallContextService>().Caller;
p1.AddRef();
value.CallFunction(caller, p1);
p1.Release();
});
GC.KeepAlive(stub); //keep referenced javascript value alive
};
return(result);
}
private static IAsyncResult BeginMethod <T>(JavaScriptValue promiseObject, IServiceNode node, AsyncCallback callback, object state)
{
var converter = node.GetService <IJSValueConverterService>();
var valueService = node.GetService <IJSValueService>();
var result = new AsyncResult <T>();
Action <T> fullfilledCallback = (x) =>
{
result.SetResult(x);
callback(result);
};
Action <JavaScriptValue> rejectedCallback = (s) =>
{
try
{
valueService.ThrowIfErrorValue(s);
}
catch (JavaScriptFatalException ex)
{
result.SetError(ex.Message);
}
if (s.ValueType == JavaScriptValueType.String)
{
result.SetError(s.ToString());
}
else
{
result.SetError(string.Empty);
}
callback(result);
};
var pObj = converter.FromJSValue <JSValue>(promiseObject);
pObj.CallMethod("then", fullfilledCallback, rejectedCallback);
System.Diagnostics.Debug.WriteLine("[Then] called");
return(result);
}
public static T WithContext <T>(this IServiceNode node, Func <T> f)
{
return(node.GetService <IContextSwitchService>().With <T>(f));
}
public static void WithContext(this IServiceNode node, Action a)
{
node.GetService <IContextSwitchService>().With(a);
}
