public async void run(object instance, MethodInfo methodInfo, object[] fnArguments)
{
SynchronizationContext ctx = SynchronizationContext.Current;
if (!methodInfo.ReturnType.GetInterfaces().Contains(typeof(IAsyncInfo)))
{
// this should be easy, just run it as if it was synchronous
var result = methodInfo.Invoke(instance, fnArguments);
InvokeAsyncEventArgs eventArgs = new InvokeAsyncEventArgs();
if (methodInfo.ReturnType == typeof(void))
{
eventArgs.primitiveValue = null;
}
else
{
Type type = result.GetType();
if (type.IsPrimitive || type == typeof(string) || type == typeof(decimal))
{
eventArgs.primitiveValue = result;
}
else if (InstanceRegistry.containsInstance(result))
{
eventArgs.handle = InstanceRegistry.getInstanceHandleByValue(result);
}
else
{
string handle = InstanceRegistry.createHandle(result);
eventArgs.handle = handle;
}
}
this.OnComplete(eventArgs);
return;
}
MethodInfo castMethod = Type.GetType("TitaniumApp.TiRequestHandlers.AsyncAwaiter").GetMethod("awaitTask");
castMethod = castMethod.MakeGenericMethod(methodInfo.ReturnType.GenericTypeArguments[0]);
InvokeAsync _this = this;
Task.Run(() => {
var comObject = methodInfo.Invoke(instance, fnArguments);
Task <object> obj = (Task <object>)castMethod.Invoke(null, new object[] { comObject });
obj.Wait();
var result = obj.Result;
InvokeAsyncEventArgs eventArgs = new InvokeAsyncEventArgs();
if (methodInfo.ReturnType == typeof(void))
{
eventArgs.primitiveValue = null;
}
else
{
Type type = result.GetType();
if (type.IsPrimitive || type == typeof(string) || type == typeof(decimal))
{
eventArgs.primitiveValue = result;
}
else if (InstanceRegistry.containsInstance(result))
{
eventArgs.handle = InstanceRegistry.getInstanceHandleByValue(result);
}
else
{
string handle = InstanceRegistry.createHandle(result);
eventArgs.handle = handle;
}
}
ctx.Post(args => {
_this.OnComplete((InvokeAsyncEventArgs)args);
}, eventArgs);
});
}
private TiResponse invokeStaticAsync(TiRequestParams data)
{
if (!data.ContainsKey("className"))
{
throw new ReflectionException("\"invokeStatic\" request missing \"className\" param");
}
string className = (string)data["className"];
var classType = InstanceRegistry.lookupType(className);
if (classType == null)
{
throw new ReflectionException("\"invokeStatic\" request invalid classname \"" + className + "\"");
}
if (!data.ContainsKey("method"))
{
throw new ReflectionException("\"invokeStatic\" request missing \"method\" param");
}
if (!data.ContainsKey("args"))
{
throw new ReflectionException("\"invokeStatic\" request missing \"args\" param");
}
JArray args = (JArray)data["args"];
if (args.Count % 2 != 0)
{
throw new ReflectionException("\"invokeStatic\" request arguments must contain an even number of type-values");
}
// create the argument types array
Type[] fnArgumentTypes = new Type[args.Count / 2];
for (int i = 0, j = 0; i < args.Count; i += 2, j++)
{
fnArgumentTypes[j] = InstanceRegistry.lookupType((string)args[i]);
}
// get the method info
MethodInfo methodInfo = classType.GetMethod((string)data["method"], fnArgumentTypes);
// create the argument values array
object[] fnArguments = new object[args.Count / 2];
for (int i = 1, j = 0; i < args.Count; i += 2, j++)
{
JObject arg = (JObject)args[i];
if (arg["valueHnd"] != null)
{
fnArguments[j] = InstanceRegistry.getInstance((string)arg["valueHnd"]);
}
else if (fnArgumentTypes[j] == typeof(Uri))
{
fnArguments[j] = new Uri((string)arg["valuePrimitive"], UriKind.RelativeOrAbsolute);
}
else
{
fnArguments[j] = ((JValue)arg["valuePrimitive"]).Value;
}
if (fnArguments[j] != null)
{
IConvertible convertible = fnArguments[j] as IConvertible;
if (convertible != null)
{
fnArguments[j] = Convert.ChangeType(fnArguments[j], fnArgumentTypes[j]);
}
}
}
TiResponse response = new TiResponse();
InvokeAsync ia = new InvokeAsync();
response["handle"] = InstanceRegistry.createHandle(ia);
ia.run(null, methodInfo, fnArguments);
return(response);
}