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); }