private TiResponse staticProperty(TiRequestParams data)
{
if (!data.ContainsKey("className"))
{
throw new ReflectionException("\"staticProperty\" request missing \"className\" param");
}
string className = (string)data["className"];
var classType = InstanceRegistry.lookupType(className);
if (classType == null)
{
throw new ReflectionException("\"staticProperty\" request invalid classname \"" + className + "\"");
}
if (!data.ContainsKey("property"))
{
throw new ReflectionException("\"staticProperty\" request missing \"property\" param");
}
PropertyInfo propertyInfo = classType.GetProperty((string)data["property"]);
if (propertyInfo == null)
{
throw new ReflectionException("\"staticProperty\" request invalid property \"" + data["property"] + "\"");
}
object val = propertyInfo.GetValue(null);
return(InstanceRegistry.createReturnType(val));
}
private TiResponse removeEventListener(TiRequestParams data)
{
if (!data.ContainsKey("handle"))
{
throw new ReflectionException("\"addEventListener\" request missing \"handle\" param");
}
string handle = (string)data["handle"];
object instance = InstanceRegistry.getInstance(handle);
if (instance == null)
{
throw new ReflectionException("\"addEventListener\" request invalid handle \"" + handle + "\"");
}
if (!data.ContainsKey("name"))
{
throw new ReflectionException("\"addEventListener\" request missing \"name\" param");
}
string eventName = (string)data["name"];
var eventInfo = instance.GetType().GetEvent(eventName);
Delegate handler = InstanceRegistry.getDelegate(handle + "." + eventName);
if (handler != null)
{
eventInfo.RemoveEventHandler(instance, handler);
InstanceRegistry.removeDelegate(handle + "." + eventName);
}
return(null);
}
protected override void InitializeCore()
{
InitializeCommandManager();
OnAttach <EditorPresenter>(editor => {
_editor = editor;
_editor.SyncCurrentProject += EditorSyncCurrentProject;
InitializeCommandManager(editor);
});
OnDetach <EditorPresenter>(editor => {
BindProject(null);
_editor.SyncCurrentProject -= EditorSyncCurrentProject;
_editor = null;
});
Components = new InstanceRegistry <ProjectExplorerComponent>();
_libraryEventBindings = new Dictionary <EventBindings, EventHandler <ResourceEventArgs <Library> > >()
{
{ EventBindings.LibraryAdded, (s, e) => OnLibraryAdded(new ResourceEventArgs <Library>(e.Resource)) },
{ EventBindings.LibraryRemoved, (s, e) => OnLibraryRemoved(new ResourceEventArgs <Library>(e.Resource)) },
{ EventBindings.LibraryModified, (s, e) => OnLibraryModified(new ResourceEventArgs <Library>(e.Resource)) },
};
LibraryManagerTag = Guid.NewGuid();
ProjectManagerTag = Guid.NewGuid();
}
public void InitializeProjectPanelComponents(InstanceRegistry <ProjectPanelComponent> manager)
{
foreach (var component in _projectPanelComponents)
{
manager.Register(component.Value);
}
}
private void CheckBox_Click(object sender, RoutedEventArgs e)
{
InstanceRegistry instanceRegistry = this.ParentWindow.EngineInstanceRegistry;
bool? isChecked = this.mMinimzeOnCloseCheckBox.IsChecked;
bool flag = true;
int num = !(isChecked.GetValueOrDefault() == flag & isChecked.HasValue) ? 1 : 0;
instanceRegistry.IsShowMinimizeBlueStacksPopupOnClose = num != 0;
BlueStacks.Common.Stats.SendCommonClientStatsAsync("notification_mode", "donotshow_checkbox", this.ParentWindow.mVmName, string.Empty, (!this.ParentWindow.EngineInstanceRegistry.IsShowMinimizeBlueStacksPopupOnClose).ToString((IFormatProvider)CultureInfo.InvariantCulture), "", "");
}
private TiResponse addEventListener(TiRequestParams data)
{
if (!data.ContainsKey("handle"))
{
throw new ReflectionException("\"addEventListener\" request missing \"handle\" param");
}
string handle = (string)data["handle"];
object instance = InstanceRegistry.getInstance(handle);
if (instance == null)
{
throw new ReflectionException("\"addEventListener\" request invalid handle \"" + handle + "\"");
}
if (!data.ContainsKey("name"))
{
throw new ReflectionException("\"addEventListener\" request missing \"name\" param");
}
string eventName = (string)data["name"];
var eventInfo = instance.GetType().GetEvent(eventName);
// create an array of parameters based on the event info
var parameters = eventInfo.EventHandlerType.GetMethod("Invoke").GetParameters().
Select((p, i) => Expression.Parameter(p.ParameterType, "p" + i)).ToArray();
// construct a new array of parameters to the method we are actually going to call
// need to pass in extra information so the Proxy knows which callback to fire
Expression[] pass = new Expression[5];
parameters.CopyTo(pass, 0);
pass[2] = Expression.Constant(eventInfo.Name);
pass[3] = Expression.Constant(handle);
pass[4] = Expression.Constant(InstanceRegistry.getInstance("browser"));
// Get method info of the handler we want to call
MethodInfo methodInfo = this.GetType().GetMethod("eventHandler", BindingFlags.NonPublic | BindingFlags.Instance);
MethodCallExpression methodCall = Expression.Call(Expression.Constant(this), methodInfo, pass);
// Construct a delegate using a lambda expression
// (Object, EventArgs) => dummyHandler(Object, EventArgs, String, String, WebBrowser)
var lambda = Expression.Lambda(
eventInfo.EventHandlerType,
methodCall,
parameters
).Compile();
// Hook the event to the delegate
eventInfo.AddEventHandler(instance, lambda);
// Store the delegate to remove it later
InstanceRegistry.addDelegate(handle + "." + eventName, lambda);
return(null);
}
private TiResponse destroy(TiRequestParams data)
{
if (!data.ContainsKey("handle"))
{
throw new ReflectionException("\"invokeMethod\" request missing \"handle\" param");
}
string handle = (string)data["handle"];
object instance = InstanceRegistry.getInstance(handle);
if (instance == null)
{
throw new ReflectionException("\"invokeMethod\" request invalid handle \"" + handle + "\"");
}
// remove from parent view
var propertyInfo = instance.GetType().GetProperty("Parent");
if (propertyInfo != null)
{
var parent = propertyInfo.GetValue(instance);
if (parent != null)
{
propertyInfo = parent.GetType().GetProperty("Children");
if (propertyInfo != null)
{
var children = propertyInfo.GetValue(parent);
var remove = children.GetType().GetMethod("Remove");
remove.Invoke(children, new object[] { instance });
}
}
}
// call Dispose method
var dispose = instance.GetType().GetMethod("Dispose");
if (dispose != null)
{
dispose.Invoke(instance, null);
}
// call Finalize method
var finalize = instance.GetType().GetMethod("Finalize");
if (finalize != null)
{
finalize.Invoke(instance, null);
}
// remove global reference
InstanceRegistry.removeInstance(handle);
return(null);
}
private void eventHandler(Object sender, EventArgs e, String eventName, String handle, WebBrowser browser)
{
TiResponse response = new TiResponse();
response["_hnd"] = handle;
response["type"] = eventName;
string senderHandle = "";
bool senderExists = InstanceRegistry.containsInstance(sender);
if (senderExists)
{
senderHandle = InstanceRegistry.getInstanceHandleByValue(sender);
}
else
{
senderHandle = InstanceRegistry.createHandle(sender);
}
response["sender"] = senderHandle;
string eventArgsHandle = "";
bool eventArgsExists = InstanceRegistry.containsInstance(e);
if (eventArgsExists)
{
eventArgsHandle = InstanceRegistry.getInstanceHandleByValue(e);
}
else
{
eventArgsHandle = InstanceRegistry.createHandle(e);
}
response["eventArgs"] = eventArgsHandle;
response["error"] = null;
if (e.GetType() == typeof(ErrorEventArgs))
{
response["error"] = ((ErrorEventArgs)e).error;
}
browser.InvokeScript("execScript", new string[] { "tiwp8.fireEvent(" + JsonConvert.SerializeObject(response, Formatting.None) + ")" });
if (!senderExists)
{
InstanceRegistry.removeInstance(senderHandle);
}
if (!eventArgsExists)
{
InstanceRegistry.removeInstance(eventArgsHandle);
}
}
public ProjectPanel()
{
InitializeComponent();
_tree.NodeMouseDoubleClick += TreeNodeDoubleClickHandler;
_tree.NodeMouseClick += TreeNodeClickHandler;
_commandController = new UICommandController();
ComponentManager = new InstanceRegistry <ProjectPanelComponent>();
ComponentManager.InstanceRegistered += (s, e) => {
e.Instance.Initialize(_rootNode);
if (_controller != null)
{
BindingHelper.TryBindAny(e.Instance, _controller.Components.Select(c => new KeyValuePair <Type, object>(c.Key, c.Value)));
}
};
ResetComponent();
}
private TiResponse getEnum(TiRequestParams data)
{
if (!data.ContainsKey("name"))
{
throw new ReflectionException("\"getEnum\" request missing \"name\" param");
}
if (!data.ContainsKey("value"))
{
throw new ReflectionException("\"getEnum\" request missing \"value\" param");
}
string name = (string)data["name"];
string value = (string)data["value"];
Type t = InstanceRegistry.lookupType(name);
if (t == null)
{
throw new ReflectionException("\"getEnum\" request failed because \"" + name + "\" is an invalid class name");
}
object val = null;
if (t.IsEnum)
{
val = Enum.Parse(t, value);
}
else
{
var prop = t.GetProperty(value);
if (prop != null)
{
val = prop.GetValue(null, null);
}
}
return(InstanceRegistry.createReturnType(val));
}
private TiResponse invokeMethod(TiRequestParams data)
{
if (!data.ContainsKey("handle"))
{
throw new ReflectionException("\"invokeMethod\" request missing \"handle\" param");
}
string handle = (string)data["handle"];
object instance = InstanceRegistry.getInstance(handle);
if (instance == null)
{
throw new ReflectionException("\"invokeMethod\" request invalid handle \"" + handle + "\"");
}
if (!data.ContainsKey("method"))
{
throw new ReflectionException("\"invokeMethod\" request missing \"method\" param");
}
if (!data.ContainsKey("args"))
{
throw new ReflectionException("\"invokeMethod\" request missing \"args\" param");
}
JArray args = (JArray)data["args"];
if (args.Count % 2 != 0)
{
throw new ReflectionException("\"invokeMethod\" 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 = instance.GetType().GetMethod((string)data["method"], fnArgumentTypes);
if (methodInfo.ReturnType.GetInterfaces().Contains(typeof(IAsyncInfo)))
{
throw new Exception("Use invokeMethodAsync() to call this method");
}
// 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]);
}
}
}
// invoke the method
var result = methodInfo.Invoke(instance, fnArguments);
if (methodInfo.ReturnType == typeof(void))
{
result = null;
}
return(InstanceRegistry.createReturnType(result));
}
public void InitializeProjectPanelComponents(InstanceRegistry<ProjectPanelComponent> manager)
{
foreach (var component in _projectPanelComponents)
manager.Register(component.Value);
}
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);
});
}
public TiResponse process(TiRequestParams data)
{
if (!data.ContainsKey("url"))
{
throw new DownloadException("Request missing 'url' param");
}
string url = (string)data["url"];
if (!url.StartsWith("http://") && !url.StartsWith("https://"))
{
throw new DownloadException("'url' param must start with 'http://' or 'https://'");
}
string saveTo = "";
int p;
if (data.ContainsKey("saveTo"))
{
saveTo = (string)data["saveTo"];
}
else
{
// try to determine the filename based on the URL
p = url.LastIndexOf('/');
if (p > 8 && p != -1) // make sure the last / is after the ://
{
saveTo = url.Substring(p + 1);
}
else
{
throw new DownloadException("Request missing 'saveTo' param");
}
}
if (saveTo == null || saveTo == "")
{
throw new DownloadException("Invalid 'saveTo' param");
}
saveTo = saveTo.Replace('\\', '/');
IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication();
p = saveTo.LastIndexOf('\\');
if (p != -1)
{
string dir = saveTo.Substring(0, p);
try {
if (!isf.DirectoryExists(dir))
{
isf.CreateDirectory(dir);
}
} catch (IsolatedStorageException) {
throw new DownloadException("Unable to create destination directory '" + dir + "' because of insufficient permissions or the isolated storage has been disabled or removed");
}
}
if (isf.FileExists(saveTo))
{
if (data.ContainsKey("overwrite") && (bool)data["overwrite"])
{
isf.DeleteFile(saveTo);
}
else
{
throw new DownloadException("File '" + saveTo + "' already exists");
}
}
IsolatedStorageFileStream fileStream = null;
try {
fileStream = isf.CreateFile(saveTo);
} catch (IsolatedStorageException) {
throw new DownloadException("Unable to create file '" + saveTo + "' because the isolated storage has been disabled or removed");
} catch (DirectoryNotFoundException) {
throw new DownloadException("Unable to create file '" + saveTo + "' because the directory does not exist");
} catch (ObjectDisposedException) {
throw new DownloadException("Unable to create file '" + saveTo + "' because the isolated storage has been disposed");
}
TiResponse response = new TiResponse();
DownloadFile df = new DownloadFile(SynchronizationContext.Current, new Uri(url), fileStream);
response["handle"] = InstanceRegistry.createHandle(df);
return(response);
}
private TiResponse property(TiRequestParams data)
{
if (!data.ContainsKey("handle"))
{
throw new ReflectionException("\"property\" request missing \"handle\" param");
}
string handle = (string)data["handle"];
object instance = InstanceRegistry.getInstance(handle);
if (instance == null)
{
throw new ReflectionException("\"property\" request invalid handle \"" + handle + "\"");
}
if (!data.ContainsKey("name"))
{
throw new ReflectionException("\"property\" request missing \"name\" param");
}
var obj = data["name"];
if (obj == null)
{
throw new ReflectionException("\"property\" request \"name\" is null");
}
Type instanceType = instance.GetType();
Type propType = instanceType.GetType();
TiResponse response = new TiResponse();
response["value"] = null;
switch (obj.GetType().ToString())
{
case "Newtonsoft.Json.Linq.JArray":
{
// get multiple props
JArray arr = (JArray)obj;
Dictionary <string, TiResponse> value = new Dictionary <string, TiResponse>();
for (var i = 0; i < arr.Count; i++)
{
string propName = arr[i].ToString();
var propertyInfo = instanceType.GetProperty(propName);
if (propertyInfo == null)
{
throw new ReflectionException("Invalid property \"" + propName + "\"");
}
object val = propertyInfo.GetValue(instance);
value[propName] = InstanceRegistry.createReturnType(val);
}
response["value"] = value;
return(response);
}
case "Newtonsoft.Json.Linq.JObject":
{
// set multiple props
JObject props = (JObject)obj;
foreach (JProperty prop in props.Properties())
{
var propertyInfo = instanceType.GetProperty(prop.Name);
if (propertyInfo == null)
{
throw new ReflectionException("Invalid property \"" + prop.Name + "\"");
}
JObject value = (JObject)prop.Value;
if (value["valueHnd"] != null)
{
propertyInfo.SetValue(instance, InstanceRegistry.getInstance((string)value["valueHnd"]));
}
else if (value["valuePrimitive"] != null)
{
var valuePrimitive = value["valuePrimitive"];
if (propertyInfo.PropertyType == typeof(Uri))
{
propertyInfo.SetValue(instance, Convert.ChangeType(new Uri(valuePrimitive.ToObject <string>(), UriKind.RelativeOrAbsolute), propertyInfo.PropertyType));
}
else
{
propertyInfo.SetValue(instance, valuePrimitive.ToObject(propertyInfo.PropertyType));
}
}
}
return(null);
}
case "System.String":
{
string name = (string)obj;
var propertyInfo = instanceType.GetProperty(name);
if (propertyInfo == null)
{
throw new ReflectionException("Invalid property \"" + name + "\"");
}
// setting a single prop
if (data.ContainsKey("valueHnd") && data["valueHnd"] != null)
{
propertyInfo.SetValue(instance, InstanceRegistry.getInstance((string)data["valueHnd"]));
return(null);
}
else if (data.ContainsKey("valuePrimitive"))
{
var valuePrimitive = data["valuePrimitive"];
if (propertyInfo.PropertyType == typeof(Uri))
{
valuePrimitive = new Uri((string)valuePrimitive, UriKind.RelativeOrAbsolute);
}
propertyInfo.SetValue(instance, Convert.ChangeType(valuePrimitive, propertyInfo.PropertyType));
return(null);
}
// getting a single prop
object val = propertyInfo.GetValue(instance);
return(InstanceRegistry.createReturnType(val));
}
}
return(null);
}
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);
}
public ReflectionRequestHandler(Microsoft.Phone.Controls.PhoneApplicationPage app, WebBrowser browser, System.Windows.Controls.Grid root)
{
InstanceRegistry.addInstance("app", app);
InstanceRegistry.addInstance("browser", browser);
InstanceRegistry.addInstance("root", root);
}
protected override void InitializeCore()
{
InitializeCommandManager();
OnAttach<EditorPresenter>(editor => {
_editor = editor;
_editor.SyncCurrentProject += EditorSyncCurrentProject;
InitializeCommandManager(editor);
});
OnDetach<EditorPresenter>(editor => {
BindProject(null);
_editor.SyncCurrentProject -= EditorSyncCurrentProject;
_editor = null;
});
Components = new InstanceRegistry<ProjectExplorerComponent>();
_libraryEventBindings = new Dictionary<EventBindings, EventHandler<ResourceEventArgs<Library>>>() {
{ EventBindings.LibraryAdded, (s, e) => OnLibraryAdded(new ResourceEventArgs<Library>(e.Resource)) },
{ EventBindings.LibraryRemoved, (s, e) => OnLibraryRemoved(new ResourceEventArgs<Library>(e.Resource)) },
{ EventBindings.LibraryModified, (s, e) => OnLibraryModified(new ResourceEventArgs<Library>(e.Resource)) },
};
LibraryManagerTag = Guid.NewGuid();
ProjectManagerTag = Guid.NewGuid();
}
private TiResponse createInstance(TiRequestParams data)
{
if (!data.ContainsKey("className"))
{
throw new ReflectionException("\"createInstance\" request missing \"className\" param");
}
string className = (string)data["className"];
var classType = InstanceRegistry.lookupType(className);
if (classType == null)
{
throw new ReflectionException("\"createInstance\" request invalid classname \"" + classType + "\"");
}
if (!data.ContainsKey("args"))
{
throw new ReflectionException("\"createInstance\" request missing \"args\" param");
}
JArray args = (JArray)data["args"];
if (args.Count % 2 != 0)
{
throw new ReflectionException("\"createInstance\" request arguments must contain an even number of type-values");
}
// create the argument types array
Type[] ctorArgumentTypes = new Type[args.Count / 2];
for (int i = 0, j = 0; i < args.Count; i += 2, j++)
{
ctorArgumentTypes[j] = InstanceRegistry.lookupType((string)args[i]);
}
// create the argument values array
object[] ctorArguments = 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)
{
ctorArguments[j] = InstanceRegistry.getInstance((string)arg["valueHnd"]);
}
else if (ctorArgumentTypes[j] == typeof(Uri))
{
ctorArguments[j] = new Uri((string)arg["valuePrimitive"], UriKind.RelativeOrAbsolute);
}
else
{
ctorArguments[j] = ((JValue)arg["valuePrimitive"]).Value;
}
if (ctorArguments[j] != null)
{
ctorArguments[j] = Convert.ChangeType(ctorArguments[j], ctorArgumentTypes[j]);
}
}
// Invoke the constructor and return the result
var instance = classType.GetConstructor(ctorArgumentTypes).Invoke(ctorArguments);
TiResponse response = new TiResponse();
response["handle"] = InstanceRegistry.createHandle(instance);
return(response);
}
