public void Invoke(HttpClient client, string url, JSObject ajaxOptions, JSFunction success, JSFunction failed, JSFunction progress)
{
Device.BeginInvokeOnMainThread(async() => {
try {
string method = ajaxOptions.GetJSPropertyValue("method").ToString().ToLower();
var m = HttpMethod.Get;
HttpContent hc = null;
switch (method)
{
case "post":
m = HttpMethod.Post;
hc = CreateContent(ajaxOptions);
break;
case "put":
m = HttpMethod.Put;
hc = CreateContent(ajaxOptions);
break;
case "delete":
m = HttpMethod.Delete;
hc = CreateContent(ajaxOptions);
break;
case "head":
m = HttpMethod.Head;
break;
case "options":
m = HttpMethod.Options;
break;
}
var msg = new HttpRequestMessage(m, url);
msg.Content = hc;
var res = await client.SendAsync(msg, HttpCompletionOption.ResponseHeadersRead);
ajaxOptions.SetJSPropertyValue("status", (int)res.StatusCode);
var ct = res.Content.Headers.ContentType?.ToString();
if (ct != null)
{
ajaxOptions.SetJSPropertyValue("responseType", ct);
}
//if (!res.IsSuccessStatusCode) {
// string error = await res.Content.ReadAsStringAsync();
// ajaxOptions.SetJSPropertyValue("responseText", error);
// success.Call(null, new Java.Lang.Object[] { error });
// return;
//}
string text = await res.Content.ReadAsStringAsync();
ajaxOptions.SetJSPropertyValue("responseText", text);
success.Call(null, new Java.Lang.Object[] { ajaxOptions });
}
catch (Exception ex) {
failed.Call(null, new Java.Lang.Object[] { ex.ToString() });
}
});
}
public JSDisposable WatchProperty(JSWrapper objTarget, string name, JSValue events, JSFunction callback)
{
object obj = objTarget.As <object>();
if (obj is INotifyPropertyChanged element)
{
var pinfo = obj.GetProperty(name);
PropertyChangedEventHandler handler = (s, e) =>
{
if (e.PropertyName == name)
{
var value = pinfo.GetValue(obj);
callback.Call(null, new Java.Lang.Object[] { value.Wrap(Engine) });
}
};
element.PropertyChanged += handler;
return(new JSDisposable(Engine, () =>
{
element.PropertyChanged -= handler;
}));
}
return(new JSDisposable(Engine, () => { }));
}
/// <summary>
/// 创建分析报表查询的JS函数
/// </summary>
/// <param name="pGetQueryConditionsJSFunction">获取查询条件的JS函数</param>
/// <param name="pAjaxHandlerUrl">Ajax请求的url</param>
/// <param name="pFunctionName">函数的名称</param>
/// <param name="pLoadingMessage">执行Ajax请求时的加载中的信息</param>
/// <returns>JS函数</returns>
public static JSFunction CreateQuery(JSFunction pGetQueryConditionsJSFunction, string pAjaxHandlerUrl, string pFunctionName = "__fnAnalysisReportQuery", string pLoadingMessage = "数据加载中,请稍后...")
{
JSFunction script = new JSFunction();
script.Type = JSFunctionTypes.Common;
script.FunctionName = pFunctionName;
//组织回传参数
script.AddSentence("var param={0};", pGetQueryConditionsJSFunction.Call().ToScriptBlock(0));
//阴影遮罩
script.AddSentence("var mask=new Ext.LoadMask(Ext.getBody(),{");
script.AddSentence("{0}msg:'{1}'", Keyboard.TAB, pLoadingMessage);
script.AddSentence("});");
//开启遮罩
script.AddSentence("mask.show();");
//执行Ajax请求
script.AddSentence("Ext.Ajax.request({");
script.AddSentence("{0}url:'{1}'", Keyboard.TAB, pAjaxHandlerUrl);
script.AddSentence("{0},params:Ext.JSON.encode(param)", Keyboard.TAB);
script.AddSentence("{0},method:'POST'", Keyboard.TAB);
script.AddSentence("{0},callback:function(options,success,response){{", Keyboard.TAB);
script.AddSentence("{0}{0}if(success){{", Keyboard.TAB);
script.AddSentence("{0}{0}{0}eval(response.responseText);", Keyboard.TAB);
script.AddSentence("{0}{0}}}else{{", Keyboard.TAB);
script.AddSentence("{0}{0}{0}alert('请求失败.');", Keyboard.TAB);
script.AddSentence("{0}{0}}}", Keyboard.TAB);
script.AddSentence("{0}{0}mask.hide();", Keyboard.TAB);
script.AddSentence("{0}}}", Keyboard.TAB);
script.AddSentence("});");
//返回
return(script);
}
public void VisitDescendents(JSWrapper target, JSFunction action)
{
Element element = target?.As <Element>();
if (element == null)
{
throw new ObjectDisposedException("Cannot visit descendents of null");
}
var views = element as IViewContainer <View>;
if (views == null)
{
return;
}
foreach (var e in views.Children)
{
var ac = WAContext.GetAtomControl(e);
var child = e.Wrap(Engine);
var r = action.Call(null, new Java.Lang.Object[] {
child,
(JSValue)ac
});
if ((bool)r.IsUndefined() || (bool)r.IsNull() || !((bool)r.ToBoolean()))
{
continue;
}
VisitDescendents(JSWrapper.Register(e), action);
}
}
public void SetTemplate(JSWrapper elementWrapper, string name, JSFunction factory)
{
var element = elementWrapper.As <Element>();
PropertyInfo p = element.GetType().GetProperty(name);
p.SetValue(element, new DataTemplate(() => {
try
{
var ac = (factory.Call(null) as JSValue).ToObject();
var eid = ac.GetJSPropertyValue("element");
var e = JSWrapper.FromKey(eid.ToString()).As <View>();
return(new TemplateView
{
View = e,
SetBindingContext = (obj) =>
{
ac.SetJSPropertyValue("data", (Java.Lang.Object)obj);
}
});
}
catch (Exception ex) {
System.Diagnostics.Debug.WriteLine(ex);
throw;
}
}));
}
public int SetInterval(JSFunction value, int milliSeconds, bool once)
{
System.Threading.CancellationTokenSource cancellation = new System.Threading.CancellationTokenSource();
Device.BeginInvokeOnMainThread(async() => {
while (!cancellation.IsCancellationRequested)
{
try
{
await Task.Delay(TimeSpan.FromMilliseconds(milliSeconds), cancellation.Token);
value.Call(null, new Java.Lang.Object[] { });
if (once)
{
break;
}
}
catch (TaskCanceledException) { }
}
});
lock (intervalCancells) {
intervalCancells.Add(intervalId, cancellation);
return(intervalId++);
}
}
public void Close(JSWrapper wrapper, JSFunction success, JSFunction error)
{
Device.BeginInvokeOnMainThread(async() => {
try {
var e = wrapper.As <Element>();
await WebAtoms.WAContext.Current.PopAsync(e, true);
success.Call(null, new Java.Lang.Object[] { });
} catch (Exception ex) {
error.Call(null, new Java.Lang.Object[] { ex.ToString() });
}
});
}
public void Confirm(string message, string title, JSFunction success, JSFunction error)
{
Device.BeginInvokeOnMainThread(async() => {
try
{
bool result = await Application.Current.MainPage.DisplayAlert(title, message, "Yes", "No");
success.Call(null, new Java.Lang.Object[] { result });
}
catch (Exception ex)
{
error.Call(null, new Java.Lang.Object[] { ex.ToString() });
}
});
}
public void LoadModuleScript(string name, string url, JSFunction success, JSFunction error)
{
Device.BeginInvokeOnMainThread(async() => {
try {
string script = await Client.GetStringAsync(url);
success.Call(null, new Java.Lang.Object[] { new JSClrFunction(Engine, (args) =>
{
Execute(script, url);
return(new JSValue(Engine));
}) });
}
catch (JSException ex) {
var msg = $"Failed to load url {url}\r\n{ex.Stack()}\r\n{ex}";
System.Diagnostics.Debug.WriteLine(msg);
error.Call(null, new Java.Lang.Object[] { msg });
} catch (Exception ex) {
var msg = $"Failed to load url {url}\r\n{ex}";
System.Diagnostics.Debug.WriteLine(msg);
error.Call(null, new Java.Lang.Object[] { msg });
}
});
}
public void SetImport(JSWrapper elementWrapper, string name, JSFunction factory)
{
var element = elementWrapper.As <Element>();
var d = WAContext.GetImports(element);
if (d == null)
{
d = new Dictionary <string, Func <Element> >();
WAContext.SetImports(element, d);
}
d[name] = () => {
var t = WAContext.GetAtomControl(element);
var jv = factory.Call((JSObject)t.Wrap(Engine)) as JSValue;
return(JSWrapper.FromKey(jv.ToObject().GetJSPropertyValue("element").ToString()).As <Element>());
};
}
// Static function that performs some validation
// on 'document' objects.
public static bool IsHtmlDocument(JSObject jsObject)
{
if (!jsObject || !jsObject.Owner.IsLive)
{
return(false);
}
// Create a helper Function.
JSFunction evaluatorFunction = jsObject.Owner.ExecuteJavascriptWithResult("new Function('return this instanceof HTMLDocument;')");
if (!evaluatorFunction)
{
return(false);
}
// Call it as a member of the passed object.
return(evaluatorFunction.Call(jsObject));
}
public JSDisposable AddEventHandler(
JSWrapper elementTarget,
string name, JSFunction callback, bool?capture)
{
Element element = elementTarget.As <Element>();
var e = element.GetType().GetEvent(name);
if (e == null)
{
var disposable = WAContext.Current.AddEventHandler(element, name, () => {
try
{
callback.Call(null);
}
catch (Exception ex) {
System.Diagnostics.Debug.WriteLine(ex);
Engine.ThrowJSException(new JSException(Engine, ex.Message));
}
});
return(new JSDisposable(Engine, () => {
disposable.Dispose();
}));
}
var pe = new AtomDelegate()
{
callback = callback
};
var handler = Delegate.CreateDelegate(e.EventHandlerType, pe, AtomDelegate.OnEventMethod);
e.AddEventHandler(element, handler);
return(new JSDisposable(Engine, () => {
e.RemoveEventHandler(element, handler);
pe.callback = null;
}));
}
public void OnEvent(Object sender, Object arg)
{
callback.Call(null);
}