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 void OnNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e)
{
this.SetStatus(
DeviceNetworkInformation.IsNetworkAvailable,
DeviceNetworkInformation.IsWiFiEnabled,
DeviceNetworkInformation.IsCellularDataEnabled
);
}
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);
}
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;
}
}
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 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;
}
}
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;
}
}
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;
}
}
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 InternetConnectionManager_ConnectionStateChanged(object sender, NetworkNotificationEventArgs e)
{
if (_internetConnectionManagerLocator.InternetConnectionManager.IsInternetConnectionAvailable() == false)
{
_informerManagerLocator.InformerManager.AddMessage("Error", "Connection lost");
}
}
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();
}
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)
{
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 OnNetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e)
{
this.UpdateStatus();
}
/// <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();
}
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 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 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)
{
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 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();
}
}
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();
}
}
void NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e)
{
UpdateStatus();
}
