public static void POST(string url, WWWForm form, CallbackEventHandler callback)
{
CreateInstance();
instance.StartCoroutine(StartSend(url, form));
Callback += callback;
}
public static void GET(string url, CallbackEventHandler callback)
{
CreateInstance();
instance.StartCoroutine(StartSend(url));
Callback += callback;
}
public static void RegisterChangeEventCallback(CallbackEventHandler eventHandler, Type type, EventCallback <IChangeEvent> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown)
{
foreach (var method in eventHandler.GetType().GetMethods())
{
if (method.Name != nameof(CallbackEventHandler.RegisterCallback))
{
continue;
}
var genericArguments = method.GetGenericArguments();
if (genericArguments.Length == 1)
{
var constructedGenericType = typeof(ChangeEvent <>).MakeGenericType(type);
var typedMethod = method.MakeGenericMethod(constructedGenericType);
typedMethod.Invoke(eventHandler, new object[]
{
callback,
useTrickleDown
});
return;
}
}
throw new NotImplementedException();
}
private void OnEventLineReceived(string line)
{
DateTime received = DateTime.Now;
string[] args = line.Split(' ');
if (args.Length > 0)
{
CallbackEventHandler <RawCallbackArgs> handler = CallbackReceived;
if (handler != null)
{
RawCallbackArgs c = new RawCallbackArgs(received, args);
handler(this, new RawCallbackArgs(received, args));
if (c.Handled)
{
return;
}
}
EventInfo info;
if (_events.TryGetValue(args[0], out info))
{
info.RaiseMethod(info.Handler, received, args);
}
}
}
private void Raise <T>(Delegate handler, T args) where T : CallbackArgs
{
CallbackEventHandler <T> typedHandler = (CallbackEventHandler <T>)handler;
if (typedHandler != null)
{
typedHandler(this, args);
}
}
/// <summary>
///
/// </summary>
/// <param name="ImagePath">Send ImagePath that need to Edit</param>
/// <param name="callbackEventHandler">return imagepath after click save button</param>
/// <returns>return ImagePath on callback(imagepath)</returns>
public static async Task EditImage(string ImagePath, CallbackEventHandler callbackEventHandler)
{
var imgviewmodel = new Current(ImagePath);
imgviewmodel.Callback += callbackEventHandler;
var imgpage = new ImageEditorPage(ImagePath);
imgpage.BindingContext = imgviewmodel;
await App.Current.MainPage.Navigation.PushModalAsync(imgpage, true);
}
/// <summary>
/// Subscribes to a property in the <see cref="WObject"/>.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="propertyName">The name of a property to subscribe to.</param>
/// <param name="callback">The <c>OnChanged</c> callback.</param>
public void Subscribe(object instance, string propertyName, CallbackEventHandler callback)
{
// If the given property doesn't exist, just return.
if (instance.GetType().GetProperty(propertyName) == null)
{
return;
}
CallbackManager.Subscribe(instance, instance.GetType().GetProperty(propertyName), callback);
}
public VideoInputMedia(IntPtr hMediaLib)
: base(hMediaLib)
{
CallbackEventHandler pLock = LockCallback;
CallbackEventHandler pUnlock = UnlockCallback;
m_pLock = Marshal.GetFunctionPointerForDelegate(pLock);
m_pUnlock = Marshal.GetFunctionPointerForDelegate(pUnlock);
m_callbacks.Add(pLock);
m_callbacks.Add(pUnlock);
}
public void Subscribe(string topic, CallbackEventHandler callback)
{
lock (mqttClient)
{
getLogger().LogDebug("### SUBSCRIBING topic='" + topic + "' ###");
mqttClient.SubscribeAsync(new TopicFilter(topic, MqttQualityOfServiceLevel.AtMostOnce));
if (subscriptions.ContainsKey(topic))
{
subscriptions.Remove(topic);
}
subscriptions.Add(topic, callback);
Console.WriteLine("### SUBSCRIBED topic='" + topic + "' ###");
}
}
public async Task SubscribeAsync(string topic, CallbackEventHandler callback)
{
getLogger().LogDebug("### SUBSCRIBING topic='" + topic + "' ###");
if (subscriptions.ContainsKey(topic))
{
Unsubscribe(topic);
subscriptions.Remove(topic);
}
subscriptions.Add(topic, callback);
await mqttClient.SubscribeAsync(new TopicFilter(topic, MqttQualityOfServiceLevel.AtMostOnce));
getLogger().LogInformation("### SUBSCRIBED topic='" + topic + "' ###");
}
/// <summary>
///
/// </summary>
/// <param name="ImagePath">Send ImagePath that need to Edit</param>
/// <param name="callbackEventHandler">return imagepath after click save button</param>
/// <returns>return ImagePath on callback(imagepath)</returns>
public static async Task EditImage(ImageData data, CallbackEventHandler callbackEventHandler)
{
var imgviewmodel = new CurrentWithoutDetail(data);
imgviewmodel.Callback += callbackEventHandler;
if (Device.RuntimePlatform == Device.Android)
{
var imgpage = new ImageEditorPageWithoutDetail(string.Empty);
imgpage.BindingContext = imgviewmodel;
await App.Current.MainPage.Navigation.PushAsync(imgpage, true);
}
if (Device.RuntimePlatform == Device.iOS)
{
var imgpage = new ImageEditorPageWithoutDetail(string.Empty);
imgpage.BindingContext = imgviewmodel;
await App.Current.MainPage.Navigation.PushAsync(imgpage, true);
}
}
/// <summary>
/// Subscribes to a <see cref="PropertyInfo"/> inside a specific instance.
/// </summary>
/// <param name="instance">The parent instance.</param>
/// <param name="property">The property to subscribe to.</param>
/// <param name="callback">The callback.</param>
public void Subscribe(object instance, PropertyInfo property, CallbackEventHandler callback)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
if (IsSubscribed(property))
{
return;
}
var pcb = new PropertyCallback(instance, property);
pcb.Changed += callback;
_items.Add(pcb);
}
// ctor
public AsyncProcess(string Command,
string Options = "",
CallbackEventHandler OnOutput = null,
CallbackEventHandler OnError = null,
int Timeout = Timeout.Infinite)
{
status = new ProcStatus();
cmd = Command;
opt = Options;
if (OnOutput != null)
{
OutputCallback += OnOutput;
}
if (OnError != null)
{
ErrorCallback += OnError;
}
timeout = Timeout;
}
/// <summary>
///
/// </summary>
/// <param name="ImagePath">Send ImagePath that need to Edit</param>
/// <param name="callbackEventHandler">return imagepath after click save button</param>
/// <returns>return ImagePath on callback(imagepath)</returns>
public static async Task EditImage(ImageData data, CallbackEventHandler callbackEventHandler)
{
var imgviewmodel = new Current(data);
imgviewmodel.Callback += callbackEventHandler;
if (Device.RuntimePlatform == Device.Android)
{
var imgpage = new ImageEditorPage(string.Empty, data.Name, data.Description);
imgpage.BindingContext = imgviewmodel;
await App.Current.MainPage.Navigation.PushAsync(imgpage, true);
}
if (Device.RuntimePlatform == Device.iOS)
{
var imgpage = new ImageEditorPageForIOS(string.Empty, data.Name, data.Description);
imgpage.BindingContext = imgviewmodel;
await App.Current.MainPage.Navigation.PushAsync(imgpage, true);
}
// var imgpage = new ImageEditorPage(string.Empty,data.Name,data.Description);
//imgpage.BindingContext = imgviewmodel;
//await App.Current.MainPage.Navigation.PushAsync(imgpage, true);
}
/// <summary> Returns info about all callbacks registered to the event handler. </summary>
public static IEnumerable <EventFunctor> GetCallbacks(CallbackEventHandler handler)
{
var registry = CallbackEventHandlerRef.GetCallbackRegistry(handler);
var callbackList = EventCallbackRegistryRef.GetCallbackListForWriting(registry);
var list = EventCallbackListRef.GetList(callbackList);
// Avoids modified collection error on unregister
var tempList = new List <object>(list.Count);
foreach (var item in list)
{
tempList.Add(item);
}
foreach (var functor in tempList)
{
var functorType = functor.GetType();
if (!FunctorCache.infos.TryGetValue(functorType, out var info))
{
info = new FunctorInfo(functorType);
FunctorCache.infos.Add(functorType, info);
}
// TODO: Should it be optimized with lambdas? It might eat up a chunk of memory in extreme cases.. Need some benchmarking.
var callback = (Delegate)info.m_Callback.GetValue(functor);
var eventTypeId = (long)info.m_EventTypeId.GetValue(functor);
var phase = (CallbackPhase)info.phase.GetValue(functor);
yield return(new EventFunctor()
{
handler = handler,
callback = callback,
eventTypeId = eventTypeId,
phase = phase,
callbackRegistry = registry,
});
}
}
public void AddNewEventHandler(string PropertyName, string SettingsName, string MemberBindingName, CallbackEventHandler Handler)
{
EventHandlerInfo info = new EventHandlerInfo();
info.Property = PropertyName;
info.Settings = SettingsName;
info.MemberBindingName = MemberBindingName;
info.Handler = Handler;
Handlers.Add(info);
}
public static void UnregisterCallback(CallbackEventHandler handler, long eventTypeId, Delegate callback, TrickleDown trickle)
{
var registry = CallbackEventHandlerRef.GetCallbackRegistry(handler);
EventCallbackRegistryRef.UnregisterCallback(registry, eventTypeId, callback, trickle);
}
internal static object GetCallbackRegistry(CallbackEventHandler handler)
{
return(getCallbackRegistryFunc(handler));
}
public void Subscribe(string topic, CallbackEventHandler callback)
{
Task t = SubscribeAsync(topic, callback);
t.Wait();
}
public CallbackCommand(CallbackEventHandler callback, bool shouldPauseGame = false, float lifeTime = float.MaxValue) :
base(shouldPauseGame, lifeTime)
{
Callback += callback;
}
/// <summary>
/// Subscribes to a <see cref="MethodInfo"/> inside a specific instance.
/// </summary>
/// <param name="instance">The parent instance.</param>
/// <param name="method">The method to subscribe to.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="callback">The callback.</param>
public void Subscribe(object instance, MethodInfo method, object[] parameters, CallbackEventHandler callback)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (IsSubscribed(method))
{
return;
}
var mcb = new MethodCallback(instance, method, parameters);
mcb.Changed += callback;
_items.Add(mcb);
}
public void Setup(CallbackEventHandler eventHandler, int dueTime, int period)
{
_eventHandler = eventHandler;
_timer = new Timer(Callback, null, dueTime, period);
}
