void Unregister(NetworkAvailabilityChangedEventHandler d)
{
lock (_lock) {
AvailabilityChanged -= d;
MaybeCloseSocket();
}
}
[ConditionalFact(nameof(PlatformDetection) + "." + nameof(PlatformDetection.IsNotWindowsSubsystemForLinux))] // https://github.com/Microsoft/BashOnWindows/issues/308
public void NetworkAvailabilityChanged_AddRemove_Success()
{
NetworkAvailabilityChangedEventHandler handler = NetworkChange_NetworkAvailabilityChanged;
NetworkChange.NetworkAvailabilityChanged += handler;
NetworkChange.NetworkAvailabilityChanged -= handler;
}
private static void ChangedAddress(object sender, EventArgs eventArgs)
{
lock (syncObject){
bool isAvailableNow = SystemNetworkInterface.InternalGetIsNetworkAvailable();
if (isAvailableNow != isAvailable)
{
isAvailable = isAvailableNow;
DictionaryEntry[] callerArray = new DictionaryEntry[s_availabilityCallerArray.Count];
s_availabilityCallerArray.CopyTo(callerArray, 0);
for (int i = 0; i < callerArray.Length; i++)
{
NetworkAvailabilityChangedEventHandler handler = (NetworkAvailabilityChangedEventHandler)callerArray[i].Key;
ExecutionContext context = (ExecutionContext)callerArray[i].Value;
if (context == null)
{
handler(null, new NetworkAvailabilityEventArgs(isAvailable));
}
else
{
ExecutionContext.Run(context.CreateCopy(), s_RunHandlerCallback, handler);
}
}
}
}
}
private static void OnAddressChanged(IntPtr store, IntPtr changedKeys, IntPtr info)
{
Dictionary <NetworkAddressChangedEventHandler, ExecutionContext> addressChangedSubscribers = null;
Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext> availabilityChangedSubscribers = null;
lock (s_lockObj)
{
if (s_addressChangedSubscribers.Count > 0)
{
addressChangedSubscribers = new Dictionary <NetworkAddressChangedEventHandler, ExecutionContext>(s_addressChangedSubscribers);
}
if (s_availabilityChangedSubscribers.Count > 0)
{
availabilityChangedSubscribers = new Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext>(s_availabilityChangedSubscribers);
}
}
if (addressChangedSubscribers != null)
{
foreach (KeyValuePair <NetworkAddressChangedEventHandler, ExecutionContext>
subscriber in addressChangedSubscribers)
{
NetworkAddressChangedEventHandler handler = subscriber.Key;
ExecutionContext ec = subscriber.Value;
if (ec == null) // Flow supressed
{
handler(null, EventArgs.Empty);
}
else
{
ExecutionContext.Run(ec, s_runAddressChangedHandler, handler);
}
}
}
if (availabilityChangedSubscribers != null)
{
bool isAvailable = NetworkInterface.GetIsNetworkAvailable();
NetworkAvailabilityEventArgs args = isAvailable ? s_availableEventArgs : s_notAvailableEventArgs;
ContextCallback callbackContext = isAvailable ? s_runHandlerAvailable : s_runHandlerNotAvailable;
foreach (KeyValuePair <NetworkAvailabilityChangedEventHandler, ExecutionContext>
subscriber in availabilityChangedSubscribers)
{
NetworkAvailabilityChangedEventHandler handler = subscriber.Key;
ExecutionContext ec = subscriber.Value;
if (ec == null) // Flow supressed
{
handler(null, args);
}
else
{
ExecutionContext.Run(ec, callbackContext, handler);
}
}
}
}
public void NetworkAvailabilityChanged()
{
NetworkAvailabilityChangedEventHandler h = (o, e) => {
Console.WriteLine("NetworkAvailabilityChanged called");
};
NetworkChange.NetworkAvailabilityChanged += h;
NetworkChange.NetworkAvailabilityChanged -= h;
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// networkavailabilitychangedeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this NetworkAvailabilityChangedEventHandler networkavailabilitychangedeventhandler, Object sender, NetworkAvailabilityEventArgs e, AsyncCallback callback)
{
if (networkavailabilitychangedeventhandler == null)
{
throw new ArgumentNullException("networkavailabilitychangedeventhandler");
}
return(networkavailabilitychangedeventhandler.BeginInvoke(sender, e, callback, null));
}
void OnAvailabilityChanged(object unused)
{
NetworkAvailabilityChangedEventHandler d = AvailabilityChanged;
if (d != null)
{
d(null, new NetworkAvailabilityEventArgs(GetAvailability()));
}
}
internal static void Stop(NetworkAvailabilityChangedEventHandler caller)
{
lock (syncObject){
s_availabilityCallerArray.Remove(caller);
if (s_availabilityCallerArray.Count == 0)
{
AddressChangeListener.Stop(addressChange);
}
}
}
internal static void Stop(NetworkAvailabilityChangedEventHandler caller)
{
if (caller != null)
{
lock (s_globalLock)
{
s_availabilityChangedSubscribers.Remove(caller);
if (s_availabilityChangedSubscribers.Count == 0)
{
AddressChangeListener.Stop(s_addressChange);
}
}
}
}
internal static void Start(NetworkAvailabilityChangedEventHandler caller)
{
lock (syncObject){
if (s_availabilityCallerArray.Count == 0)
{
isAvailable = NetworkInterface.GetIsNetworkAvailable();
AddressChangeListener.UnsafeStart(addressChange);
}
if ((caller != null) && (!s_availabilityCallerArray.Contains(caller)))
{
s_availabilityCallerArray.Add(caller, ExecutionContext.Capture());
}
}
}
internal static void Start(NetworkAvailabilityChangedEventHandler caller)
{
if (caller != null)
{
lock (s_globalLock)
{
if (s_availabilityChangedSubscribers.Count == 0)
{
s_isAvailable = NetworkInterface.GetIsNetworkAvailable();
AddressChangeListener.UnsafeStart(s_addressChange);
}
s_availabilityChangedSubscribers.TryAdd(caller, ExecutionContext.Capture());
}
}
}
public MainForm()
{
InitializeComponent();
netcore = new NetEngine();
gpscore = new GPSSerialService();
NetworkAvailabilityChangedEventHandler e =new NetworkAvailabilityChangedEventHandler(AvailabilityChangedCallback);
Command.Init();
if (
gpscore.Init(new SerialPort(BasicConf.GetInstance().GetCommGPS(),
int.Parse(BasicConf.GetInstance().GetGPSDataRate()))))
{
gpscore.Start();
}
SetConnnectState(false);
}
private static void ChangedAddress(object?sender, EventArgs eventArgs)
{
Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext?>?availabilityChangedSubscribers = null;
lock (s_globalLock)
{
bool isAvailableNow = SystemNetworkInterface.InternalGetIsNetworkAvailable();
// If there is an Availability Change, need to execute user callbacks.
if (isAvailableNow != s_isAvailable)
{
s_isAvailable = isAvailableNow;
if (s_availabilityChangedSubscribers.Count > 0)
{
availabilityChangedSubscribers = new Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext?>(s_availabilityChangedSubscribers);
}
}
}
// Executing user callbacks if Availability Change event occured.
if (availabilityChangedSubscribers != null)
{
bool isAvailable = s_isAvailable;
NetworkAvailabilityEventArgs args = isAvailable ? s_availableEventArgs : s_notAvailableEventArgs;
ContextCallback callbackContext = isAvailable ? s_runHandlerAvailable : s_runHandlerNotAvailable;
foreach (KeyValuePair <NetworkAvailabilityChangedEventHandler, ExecutionContext?>
subscriber in availabilityChangedSubscribers)
{
NetworkAvailabilityChangedEventHandler handler = subscriber.Key;
ExecutionContext?ec = subscriber.Value;
if (ec == null) // Flow supressed
{
handler(null, args);
}
else
{
ExecutionContext.Run(ec, callbackContext, handler);
}
}
}
}
public MainLogin()
{
InitializeComponent();
NetworkAvailabilityChangedEventHandler myHandler = new NetworkAvailabilityChangedEventHandler(AvailabilityChanged);
NetworkChange.NetworkAvailabilityChanged += myHandler;
//MATERIAL SKINS
// Create a material theme manager and add the form to manage (this)
MaterialSkinManager materialSkinManager = MaterialSkinManager.Instance;
materialSkinManager.AddFormToManage(this);
materialSkinManager.Theme = MaterialSkinManager.Themes.LIGHT;
// Configure color schema
materialSkinManager.ColorScheme = new ColorScheme(
Primary.Blue400, Primary.Blue500,
Primary.Blue500, Accent.Blue200,
TextShade.WHITE);
}
private static void ChangedAddress(object sender, EventArgs eventArgs)
{
DictionaryEntry[] callerArray = null;
lock (s_globalLock) {
bool isAvailableNow = SystemNetworkInterface.InternalGetIsNetworkAvailable();
if (isAvailableNow != isAvailable)
{
isAvailable = isAvailableNow;
callerArray = new DictionaryEntry[s_availabilityCallerArray.Count];
s_availabilityCallerArray.CopyTo(callerArray, 0);
}
}
// Release the s_globalLock before calling into user callback.
if (callerArray != null)
{
// Synchronization dedicated just to the invocation of the callback,
// for back compat reason.
lock (s_protectCallbackLock)
{
Debug.Assert(!Monitor.IsEntered(s_globalLock), "Should not invoke user callback while holding globalLock");
foreach (var entry in callerArray)
{
NetworkAvailabilityChangedEventHandler handler = (NetworkAvailabilityChangedEventHandler)entry.Key;
ExecutionContext context = (ExecutionContext)entry.Value;
if (context == null)
{
handler(null, new NetworkAvailabilityEventArgs(isAvailable));
}
else
{
ExecutionContext.Run(context.CreateCopy(), s_RunHandlerCallback, handler);
}
}
}
}
}
private static void OnAvailabilityTimerFired(object state)
{
Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext> availabilityChangedSubscribers = null;
lock (s_gate)
{
if (s_availabilityHasChanged)
{
s_availabilityHasChanged = false;
if (s_availabilityChangedSubscribers.Count > 0)
{
availabilityChangedSubscribers =
new Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext>(
s_availabilityChangedSubscribers);
}
}
}
if (availabilityChangedSubscribers != null)
{
bool isAvailable = NetworkInterface.GetIsNetworkAvailable();
NetworkAvailabilityEventArgs args = isAvailable ? s_availableEventArgs : s_notAvailableEventArgs;
ContextCallback callbackContext = isAvailable ? s_runHandlerAvailable : s_runHandlerNotAvailable;
foreach (KeyValuePair <NetworkAvailabilityChangedEventHandler, ExecutionContext>
subscriber in availabilityChangedSubscribers)
{
NetworkAvailabilityChangedEventHandler handler = subscriber.Key;
ExecutionContext ec = subscriber.Value;
if (ec == null) // Flow supressed
{
handler(null, args);
}
else
{
ExecutionContext.Run(ec, callbackContext, handler);
}
}
}
}
private static void ChangedAddress(object sender, EventArgs eventArgs)
{
Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext> copy = null;
lock (s_globalLock)
{
bool isAvailableNow = SystemNetworkInterface.InternalGetIsNetworkAvailable();
// If there is an Availability Change, need to execute user callbacks.
if (isAvailableNow != s_isAvailable)
{
s_isAvailable = isAvailableNow;
copy =
new Dictionary <NetworkAvailabilityChangedEventHandler, ExecutionContext>(s_availabilityCallerArray);
}
}
// Executing user callbacks if Availability Change event occured.
if (copy != null)
{
foreach (var entry in copy)
{
NetworkAvailabilityChangedEventHandler handler = entry.Key;
ExecutionContext context = entry.Value;
if (context == null)
{
handler(null, new NetworkAvailabilityEventArgs(s_isAvailable));
}
else
{
ExecutionContext.Run(context, s_RunHandlerCallback, handler);
}
}
}
}
internal static void Stop(NetworkAvailabilityChangedEventHandler caller)
{
lock(syncObject){
s_availabilityCallerArray.Remove(caller);
if(s_availabilityCallerArray.Count == 0){
AddressChangeListener.Stop(addressChange);
}
}
}
internal static void Start(NetworkAvailabilityChangedEventHandler caller){
lock(syncObject){
if (s_availabilityCallerArray.Count == 0) {
isAvailable = NetworkInterface.GetIsNetworkAvailable();
AddressChangeListener.UnsafeStart(addressChange);
}
if ((caller != null) && (!s_availabilityCallerArray.Contains(caller))) {
s_availabilityCallerArray.Add(caller, ExecutionContext.Capture());
}
}
}
void Register(NetworkAvailabilityChangedEventHandler d)
{
EnsureSocket();
AvailabilityChanged += d;
}
void Register (NetworkAvailabilityChangedEventHandler d)
{
EnsureSocket ();
AvailabilityChanged += d;
}
void Unregister (NetworkAvailabilityChangedEventHandler d)
{
lock (_lock) {
AvailabilityChanged -= d;
MaybeCloseSocket ();
}
}
