void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (e.NotificationType == NetworkNotificationType.InterfaceConnected) { ReLogin(); } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (downloadingItem != null) { downloadingItem.DownloadNetwork = GetNetworkTypeName(e.NotificationType, e.NetworkInterface.InterfaceType); } }
private void OnNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { this.SetStatus( DeviceNetworkInformation.IsNetworkAvailable, DeviceNetworkInformation.IsWiFiEnabled, DeviceNetworkInformation.IsCellularDataEnabled ); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NetworkInterface.InterfaceSubtype) { case NetworkInterfaceSubType.Cellular_1XRTT: case NetworkInterfaceSubType.Cellular_EDGE: case NetworkInterfaceSubType.Cellular_GPRS: NetworkType = "Cellular (2.5G)"; break; case NetworkInterfaceSubType.Cellular_3G: case NetworkInterfaceSubType.Cellular_EVDO: case NetworkInterfaceSubType.Cellular_EVDV: NetworkType = "Cellular (3G)"; break; case NetworkInterfaceSubType.Cellular_HSPA: NetworkType = "Cellular (3.5G)"; break; case NetworkInterfaceSubType.WiFi: NetworkType = "WiFi"; break; case NetworkInterfaceSubType.Desktop_PassThru: NetworkType = "Desktop Connection"; break; } }
void InternetConnectionManager_ConnectionStateChanged(object sender, NetworkNotificationEventArgs e) { if (_internetConnectionManagerLocator.InternetConnectionManager.IsInternetConnectionAvailable() == false) { _informerManagerLocator.InformerManager.AddMessage("Error", "Connection lost"); } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { var handlerTmp = InternetAvailabilityChanged; if (handlerTmp != null) handlerTmp(this, new EventArgs()); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: LogMessage("Network", SocketServer.MessageImportance.Medium, "Network was Connected at {0}\r\n", DateTime.Now); if ((XMPPClient != null) && (XMPPClient.XMPPState == XMPPState.Unknown) && (XMPPClient.XMPPAccount != null) && (XMPPClient.XMPPAccount.HaveSuccessfullyConnectedAndAuthenticated == true)) { XMPPClient.Connect(this); } break; case NetworkNotificationType.InterfaceDisconnected: LogMessage("Network", SocketServer.MessageImportance.Medium, "Network was Disconnected at {0}\r\n", DateTime.Now); if ((XMPPClient != null) && (XMPPClient.XMPPState != XMPPState.Unknown)) { XMPPClient.Disconnect(); XMPPClient.Connect(this); //MessageBox.Show("Network connection lost"); } break; case NetworkNotificationType.CharacteristicUpdate: break; default: break; } }
public static void runOppurtunistic(object sender, NetworkNotificationEventArgs e){ String result = ""; result += "network connected: " +e.NetworkInterface.InterfaceType.ToString()+ "\n"; result += "network connected name: " + e.NetworkInterface.InterfaceName.ToString() + "\n"; switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: case NetworkNotificationType.CharacteristicUpdate: GlobalVar.doTransfer = false; if (DeviceNetworkInformation.IsCellularDataEnabled && NetworksAllowed[(int)Networks.DataConnection] && e.NetworkInterface.Characteristics != NetworkCharacteristics.Roaming) { GlobalVar.doTransfer = true; } if (DeviceNetworkInformation.IsWiFiEnabled && NetworksAllowed[(int)Networks.Wifi]) { GlobalVar.doTransfer = true; } if (DeviceNetworkInformation.IsCellularDataEnabled && NetworksAllowed[(int)Networks.Roaming] && e.NetworkInterface.Characteristics == NetworkCharacteristics.Roaming ) { GlobalVar.doTransfer = true; } break; case NetworkNotificationType.InterfaceDisconnected: GlobalVar.doTransfer = false; break; default : //do nothing must be other events break; } }
void ChangeDetected(object sender, NetworkNotificationEventArgs e) { string change = string.Empty; switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: change = "Connected to "; ChatModel.AzureConnected = true; break; case NetworkNotificationType.InterfaceDisconnected: change = "Disconnected from "; ChatModel.AzureConnected = false; break; case NetworkNotificationType.CharacteristicUpdate: change = "Characteristics changed for "; break; default: change = "Unknown change with "; break; } string changeInformation = String.Format(" {0} {1} {2} ({3})", DateTime.Now.ToString(), change, e.NetworkInterface.InterfaceName, e.NetworkInterface.InterfaceType.ToString()); Guide.BeginShowMessageBox("Network", changeInformation, new string[] { "Yes", "NO" }, 0, MessageBoxIcon.Warning, null, null); }
private static void OnNetworkChanged(object sender, NetworkNotificationEventArgs e) { if (e.NotificationType == NetworkNotificationType.CharacteristicUpdate) return; UpdateNetworkState(e.NetworkInterface.InterfaceType, e.NotificationType == NetworkNotificationType.InterfaceConnected); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { var handlerTmp = InternetAvailabilityChanged; if (handlerTmp != null) { handlerTmp(this, new EventArgs()); } }
private static void OnNetworkChanged(object sender, NetworkNotificationEventArgs e) { if (e.NotificationType == NetworkNotificationType.CharacteristicUpdate) { return; } UpdateNetworkState(e.NetworkInterface.InterfaceType, e.NotificationType == NetworkNotificationType.InterfaceConnected); }
private void OnNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (e.NetworkInterface.InterfaceSubtype == NetworkInterfaceSubType.WiFi) { if (e.NotificationType == NetworkNotificationType.InterfaceConnected || e.NotificationType == NetworkNotificationType.InterfaceDisconnected) { NotifyOfPropertyChange(() => this.ConnectedNetworkName); } } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (DeviceNetworkInformation.IsNetworkAvailable == true) { LineToTarget.Stroke = new SolidColorBrush(Utility.GetColorFromHexString(LineColor_Hex)); } else if (DeviceNetworkInformation.IsNetworkAvailable == false) { LineToTarget.Stroke = new SolidColorBrush(Utility.GetColorFromHexString("FFFFFFFF")); } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { var oldNetworkAvailable = NetworkAvailable; NetworkAvailable = DeviceNetworkInformation.IsNetworkAvailable; if (NetworkAvailable != oldNetworkAvailable && NetworkAvailabilityChanged != null) { NetworkAvailabilityChanged(this, EventArgs.Empty); } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (e.NotificationType == NetworkNotificationType.InterfaceConnected) { } else if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected) { } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (e.NetworkInterface.InterfaceState.Equals(ConnectState.Disconnected)) { _isInternetConnectionAvailable = false; } else { _isInternetConnectionAvailable = true; } ConnectionStateChanged(this, e); }
private void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (!DeviceNetworkInformation.IsNetworkAvailable) { nextConnectIsFirst = true; } else if (DeviceNetworkInformation.IsNetworkAvailable && nextConnectIsFirst) { // Connected to network, dump event queue if any nextConnectIsFirst = false; eventQueue.DumpQueue(); } }
private void OnNetworkStatusChanged(object sender, NetworkNotificationEventArgs e) { if (lastNetworkState != DeviceNetworkInformation.IsNetworkAvailable) { lastNetworkState = DeviceNetworkInformation.IsNetworkAvailable; Debug.WriteLine("[LinphoneManager] Network state changed:" + (lastNetworkState ? "Available" : "Unavailable")); if (lastNetworkState) { ConfigureTunnel(); } LinphoneCore.NetworkReachable = lastNetworkState; } }
// Code to execute when the application detects a Network change. private static void NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: case NetworkNotificationType.InterfaceDisconnected: NetworkService.CheckChangesIP(); break; case NetworkNotificationType.CharacteristicUpdate: default: break; } }
void ChangeDetected(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: updateConnectionType(checkConnectionType(e.NetworkInterface.InterfaceSubtype)); break; case NetworkNotificationType.InterfaceDisconnected: updateConnectionType(NONE); break; default: break; } }
private void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { //_timer.Stop(); try { OnNetworkStatusChanged(e); _lastcellularOperator = DeviceNetworkInformation.CellularMobileOperator; _lastConnectionType = ConnectionType; } catch { } //_timer.Start(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { var status = this.InternetConnectionStatus(); if (status == this.networkStatus) { return; } var handler = this.reachabilityChanged; if (handler != null) { handler(status); } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { System.Diagnostics.Debug.WriteLine(e.NotificationType); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.InterfaceName); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.Description); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.InterfaceState); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.Bandwidth); if (e.NotificationType == NetworkNotificationType.InterfaceConnected) { this.CurrentNetwork = e.NetworkInterface; } else if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected && e.NetworkInterface == this.CurrentNetwork) { this.CurrentNetwork = null; } }
// Code to execute when a Network change is detected. private void NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: UpdateGUI(); break; case NetworkNotificationType.InterfaceDisconnected: UpdateGUI(false); break; case NetworkNotificationType.CharacteristicUpdate: default: break; } }
private void NetWorkAvailibilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: UpdateNetworkValues(); break; case NetworkNotificationType.InterfaceDisconnected: UpdateNetworkValues(); break; case NetworkNotificationType.CharacteristicUpdate: UpdateNetworkValues(); break; default: break; } }
private void OnNetworkChange(object sender, NetworkNotificationEventArgs e) { //reconnect mqtt whenever phone is reconnected without relaunch if (e.NotificationType == NetworkNotificationType.InterfaceConnected && Microsoft.Phone.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable()) { App.MqttManagerInstance.connect(); bool isPushEnabled = true; App.appSettings.TryGetValue <bool>(App.IS_PUSH_ENABLED, out isPushEnabled); if (isPushEnabled) { PushHelper.Instance.registerPushnotifications(); } } else { App.MqttManagerInstance.setConnectionStatus(Mqtt.HikeMqttManager.MQTTConnectionStatus.NOTCONNECTED_WAITINGFORINTERNET); } }
private void ChangeDetected(object sender, NetworkNotificationEventArgs e) { ConnectionEventArgs connectionEventArgs; switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: connectionEventArgs = new ConnectionEventArgs(true); Notify(connectionEventArgs); break; case NetworkNotificationType.InterfaceDisconnected: connectionEventArgs = new ConnectionEventArgs(false); Notify(connectionEventArgs); break; case NetworkNotificationType.CharacteristicUpdate: break; } }
private void DeviceNetworkInformationOnNetworkAvailabilityChanged( object sender, NetworkNotificationEventArgs args) { var networkChangedArgs = new NetworkChangedEventArgs { Bandwidth = args.NetworkInterface.Bandwidth, Connected = IsNetworkAvailable, Description = args.NetworkInterface.Description, InterfaceName = args.NetworkInterface.InterfaceName, Roaming = args.NetworkInterface.Characteristics == NetworkCharacteristics.Roaming }; switch (args.NetworkInterface.InterfaceSubtype) { case NetworkInterfaceSubType.WiFi: networkChangedArgs.ConnectionType = ConnectionType.WiFi; break; case NetworkInterfaceSubType.Desktop_PassThru: networkChangedArgs.ConnectionType = ConnectionType.Desktop; break; case NetworkInterfaceSubType.Unknown: networkChangedArgs.ConnectionType = ConnectionType.Other; break; default: networkChangedArgs.ConnectionType = ConnectionType.Cellular; break; } switch(args.NotificationType) { case NetworkNotificationType.InterfaceConnected: if (Connected != null) Connected(this, EventArgs.Empty); break; case NetworkNotificationType.InterfaceDisconnected: if (Disconnected != null) Disconnected(this, EventArgs.Empty); break; } if (NetworkChanged != null) NetworkChanged(this, networkChangedArgs); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: if (!UniversalData.loaded) { UniversalData.loadData(null, null); } break; case NetworkNotificationType.InterfaceDisconnected: break; case NetworkNotificationType.CharacteristicUpdate: break; default: break; } }
private void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (e.NotificationType != NetworkNotificationType.InterfaceConnected) { return; } this.RefreshCounters(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: LogMessage("Network", SocketServer.MessageImportance.Medium, "Network was Connected at {0}\r\n", DateTime.Now); if ((XMPPClient != null) && (XMPPClient.XMPPState == XMPPState.Unknown) && (XMPPClient.XMPPAccount != null) && (XMPPClient.XMPPAccount.HaveSuccessfullyConnectedAndAuthenticated==true)) { XMPPClient.Connect(this); } break; case NetworkNotificationType.InterfaceDisconnected: LogMessage("Network", SocketServer.MessageImportance.Medium, "Network was Disconnected at {0}\r\n", DateTime.Now); if ((XMPPClient != null) && (XMPPClient.XMPPState != XMPPState.Unknown)) { XMPPClient.Disconnect(); XMPPClient.Connect(this); //MessageBox.Show("Network connection lost"); } break; case NetworkNotificationType.CharacteristicUpdate: break; default: break; } }
/// <summary> /// Raised when the network status change /// </summary> /// <param name="sender"></param> /// <param name="networkNotificationEventArgs">Event args</param> private void DeviceNetworkInformationOnNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs networkNotificationEventArgs) { CheckIsNetworkAvailable(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { updateStatus(); }
private void OnNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { this.UpdateStatus(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { switch (e.NotificationType) { case NetworkNotificationType.InterfaceConnected: { MessageBox.Show("Connected"); break; } case NetworkNotificationType.InterfaceDisconnected: { MessageBox.Show("Geen Internet"); break; } case NetworkNotificationType.CharacteristicUpdate: { MessageBox.Show("Geen Internet"); break; } default: { MessageBox.Show("Fout met de verbinding"); break; } } }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { HandleNetworkStatusViewer(); }
private void NetworkChange(object sender, NetworkNotificationEventArgs e) { CheckNetworkAvailability(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { Debug.WriteLine("NetworkAvailable Changed " +e.NotificationType+" "+e.NetworkInterface.InterfaceName+" "+e.NetworkInterface.InterfaceState); }
void NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { UpdateStatus(); }
// Invoked when a user is connected or disconnected from a network. private void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { Common.CheckNetworkStatus(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { FireCanExecuteChanged(this, EventArgs.Empty); }
public void NetworkChangeDetected(object sender, NetworkNotificationEventArgs e) { NotifOn(); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { Debug.WriteLine("NetworkAvailabilityChanged: " + e.NotificationType); }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { NetworkAvailabilityChanged = e.NotificationType.ToString(); DispatcherHelper.RunAsync(() => RaisePropertyChanged(() => NetworkAvailabilityChanged)); }
/// <summary> /// Trigger newtwork change /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void triggerNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { if (FtpController != null) { FtpController.IsWifiEnabled = DeviceNetworkInformation.IsNetworkAvailable && DeviceNetworkInformation.IsWiFiEnabled; FtpController.IsNetEnabled = DeviceNetworkInformation.IsWiFiEnabled || DeviceNetworkInformation.IsCellularDataEnabled; } if (HttpServerController != null) { HttpServerController.IdentifyDeviceIp(); } }