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