/// <summary>
/// Call this method in Application_Launching and Application_Activated
/// </summary>
public static void Start()
{
lock (internalLock)
{
if (isTracking) return;
isTracking = true;
isCdmaConnected = false;
isGsmConnected = false;
isWiFiConnected = false;
DeviceNetworkInformation.NetworkAvailabilityChanged += OnNetworkChanged;
NetworkState.GetNetworkInterfaceType(t => UpdateNetworkState(t, true));
}
ThreadPool.QueueUserWorkItem(o =>
{
//var types =
var interfaces = new NetworkInterfaceList();
lock (internalLock)
{
var types = new List<NetworkInterfaceType>();
foreach (var i in interfaces)
{
if (!types.Contains(i.InterfaceType))
UpdateNetworkState(i.InterfaceType, i.InterfaceState == ConnectState.Connected);
types.Add(i.InterfaceType);
}
}
});
}
/// <summary>
/// 是否连接网络
/// </summary>
/// <returns></returns>
public static bool IsOnline()
{
var interfaceList = new NetworkInterfaceList();
var interfaceInfo = interfaceList.First();
bool connected = interfaceInfo.InterfaceState == ConnectState.Connected;
return connected;
}
public string GetCurrentNetworkName()
{
NetworkInterfaceList networkInterfaceList = new NetworkInterfaceList();
StringBuilder networks = new StringBuilder();
foreach (NetworkInterfaceInfo networkInterfaceInfo in networkInterfaceList)
{
if (networkInterfaceInfo.InterfaceType == NetworkInterfaceType.Wireless80211)
return networkInterfaceInfo.InterfaceName;
}
return string.Empty;
}
/// <summary>
/// Gets contacts by the filter
/// </summary>
/// <param name="filter">The search filter</param>
/// <param name="filterKind">The type of the filter.</param>
/// <returns></returns>
public static string GetCurrentWifiName()
{
var wifi = string.Empty;
var list = new List<string>();
var nil = new NetworkInterfaceList();
foreach (var nif in nil)
{
if (nif.InterfaceState == ConnectState.Connected && nif.InterfaceType == NetworkInterfaceType.Wireless80211)
{
wifi = nif.InterfaceName;
}
}
return wifi;
}
public static void CheckNetworkStatus()
{
var list = new NetworkInterfaceList();
foreach (var item in list)
{
if (item.InterfaceState == ConnectState.Connected
&& item.InterfaceType == NetworkInterfaceType.Wireless80211
&& item.InterfaceSubtype == NetworkInterfaceSubType.WiFi)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
ViewModelLocator.ApplicationSettingsStatic.NetworkStatus = ApplicationSettingsViewModel.NetworkType.WIFI);
return;
}
}
Deployment.Current.Dispatcher.BeginInvoke(() =>
ViewModelLocator.ApplicationSettingsStatic.NetworkStatus = ApplicationSettingsViewModel.NetworkType.CELLULAR);
}
public string GetNetworkConnectedType()
{
NetworkInterfaceList networkInterface = new NetworkInterfaceList();
//iterate only connected interface
foreach (NetworkInterfaceInfo netInfo in networkInterface)
{
if (netInfo.InterfaceType == NetworkInterfaceType.Wireless80211)
{
return "WiFi";
}
else if (netInfo.InterfaceType == NetworkInterfaceType.MobileBroadbandGsm || netInfo.InterfaceType == NetworkInterfaceType.MobileBroadbandCdma)
{
switch (netInfo.InterfaceSubtype)
{
case NetworkInterfaceSubType.Cellular_3G:
return "3G";
case NetworkInterfaceSubType.Cellular_EDGE:
return "EDGE";
case NetworkInterfaceSubType.Cellular_EHRPD:
return "EHRPD_4G";
case NetworkInterfaceSubType.Cellular_EVDO:
return "EVDO";
case NetworkInterfaceSubType.Cellular_EVDV:
return "EVDV";
case NetworkInterfaceSubType.Cellular_GPRS:
return "GPRS";
case NetworkInterfaceSubType.Cellular_HSPA:
return "HSPA";
case NetworkInterfaceSubType.Cellular_LTE:
return "LTE";
case NetworkInterfaceSubType.Cellular_1XRTT:
return "1XRTT";
default:
return "Unknown";
}
}
}
return "Offline";
}
private string LoadNetworkInterfaceInfo()
{
StringBuilder builder = new StringBuilder();
NetworkInterfaceList list = new NetworkInterfaceList();
foreach (NetworkInterfaceInfo networkInterface in list)
{
builder.AppendFormat(" {0}-{1} ({2}Mbps)\n",
networkInterface.InterfaceType, networkInterface.InterfaceSubtype, networkInterface.Bandwidth / 1000);
//System.Diagnostics.Debug.WriteLine("{0}, {1}, {2}, {3}, {4}, {5}, {6}",
// networkInterface.Bandwidth, networkInterface.Characteristics, networkInterface.Description,
// networkInterface.InterfaceName, networkInterface.InterfaceState, networkInterface.InterfaceSubtype,
// networkInterface.InterfaceType);
}
return builder.ToString();
}
public ConnectionService(IDeviceInfoService deviceInfoService)
{
if (deviceInfoService != null && deviceInfoService.IsBackground)
{
return;
}
_connectionScheduler = new Timer(CheckConnectionState, this, TimeSpan.FromSeconds(0.0), TimeSpan.FromSeconds(5.0));
#if WINDOWS_PHONE
_isNetworkAwailable = DeviceNetworkInformation.IsNetworkAvailable;
#endif
#if WP8 || WIN_RT
_profile = NetworkInformation.GetInternetConnectionProfile();
_connectivityLevel = _profile != null?_profile.GetNetworkConnectivityLevel() : (NetworkConnectivityLevel?)null;
//var connectivityLevel = _profile.GetNetworkConnectivityLevel();
//_profile.NetworkAdapter.IanaInterfaceType != 71 // mobile data
//_profile.GetConnectionCost().Roaming;
//Helpers.Execute.ShowDebugMessage(string.Format("InternetConnectionProfile={0}", _profile != null ? _profile.GetNetworkConnectivityLevel().ToString() : "null"));
// new solution
NetworkInformation.NetworkStatusChanged += sender =>
{
var previousProfile = _profile;
var previousConnectivityLevel = _connectivityLevel;
_profile = NetworkInformation.GetInternetConnectionProfile();
_connectivityLevel = _profile != null?_profile.GetNetworkConnectivityLevel() : (NetworkConnectivityLevel?)null;
if (_profile != null)
{
if (_mtProtoService == null)
{
return;
}
var activeTransport = _mtProtoService.GetActiveTransport();
if (activeTransport == null)
{
return;
}
if (activeTransport.AuthKey == null)
{
return;
}
var transportId = activeTransport.Id;
var isAuthorized = SettingsHelper.IsAuthorized;
if (!isAuthorized)
{
return;
}
var errorDebugString = string.Format("{0} internet connected", DateTime.Now.ToString("HH:mm:ss.fff"));
TLUtils.WriteLine(errorDebugString, LogSeverity.Error);
var reconnect = _connectivityLevel == NetworkConnectivityLevel.InternetAccess && previousConnectivityLevel != NetworkConnectivityLevel.InternetAccess;
if (reconnect)
{
TLUtils.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff", CultureInfo.InvariantCulture) + " reconnect t" + transportId, LogSeverity.Error);
Logs.Log.Write(string.Format(" Reconnect reason=NetworkStatusChanged profile={0} internet_access={1} previous_profile={2} previous_internet_access={3}",
_profile != null ? _profile.ProfileName : "none",
_profile != null ? _connectivityLevel.ToString() : "none",
previousProfile != null ? previousProfile.ProfileName : "none",
previousProfile != null ? previousConnectivityLevel.ToString() : "none"));
RaiseConnectionFailed();
return;
}
}
else
{
var errorDebugString = string.Format("{0} internet disconnected", DateTime.Now.ToString("HH:mm:ss.fff"));
TLUtils.WriteLine(errorDebugString, LogSeverity.Error);
_mtProtoService.SetMessageOnTime(60.0 * 60, "Waiting for network...");
//Helpers.Execute.ShowDebugMessage(string.Format("NetworkStatusChanged Internet disconnected Profile={0}", _profile));
}
};
#endif
#if WINDOWS_PHONE
// old solution
DeviceNetworkInformation.NetworkAvailabilityChanged += (sender, args) =>
{
return;
var isNetworkAvailable = _isNetworkAwailable;
_isNetworkAwailable = DeviceNetworkInformation.IsNetworkAvailable;
//if (isNetworkAvailable != _isNetworkAwailable)
{
var info = new StringBuilder();
info.AppendLine();
foreach (var networkInterface in new NetworkInterfaceList())
{
info.AppendLine(string.Format(" {0} {1} {2}",
networkInterface.InterfaceName,
networkInterface.InterfaceState,
networkInterface.InterfaceType));
}
var current = new NetworkInterfaceList();
var ni = NetworkInterface.NetworkInterfaceType;
Helpers.Execute.ShowDebugMessage(string.Format("NetworkAwailabilityChanged Interface={0}\n{1}", ni, info.ToString()));
}
var networkString = string.Format("{0}, {1}, ", args.NotificationType,
args.NetworkInterface != null ? args.NetworkInterface.InterfaceState.ToString() : "none");
var mtProtoService = MTProtoService.Instance;
if (mtProtoService != null)
{
if (args.NotificationType == NetworkNotificationType.InterfaceDisconnected)
{
#if DEBUG
var interfaceSubtype = args.NetworkInterface != null
? args.NetworkInterface.InterfaceSubtype.ToString()
: "Interface";
mtProtoService.SetMessageOnTime(2.0, DateTime.Now.ToString("HH:mm:ss.fff ", CultureInfo.InvariantCulture) + interfaceSubtype + " disconnected...");
TLUtils.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff ", CultureInfo.InvariantCulture) + interfaceSubtype + " disconnected", LogSeverity.Error);
#else
//mtProtoService.SetMessageOnTime(2.0, "No Internet connection");
#endif
}
else if (args.NotificationType == NetworkNotificationType.InterfaceConnected)
{
#if DEBUG
var interfaceSubtype = args.NetworkInterface != null
? args.NetworkInterface.InterfaceSubtype.ToString()
: "Interface";
mtProtoService.SetMessageOnTime(2.0, DateTime.Now.ToString("HH:mm:ss.fff ", CultureInfo.InvariantCulture) + interfaceSubtype + " connected...");
TLUtils.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff ", CultureInfo.InvariantCulture) + interfaceSubtype + " connected", LogSeverity.Error);
#else
mtProtoService.SetMessageOnTime(0.0, string.Empty);
#endif
}
else if (args.NotificationType == NetworkNotificationType.CharacteristicUpdate)
{
//#if DEBUG
// mtProtoService.SetMessageOnTime(2.0, "Characteristic update...");
// var networkInterface = args.NetworkInterface;
// if (networkInterface != null)
// {
// var characteristics = new StringBuilder();
// characteristics.AppendLine();
// //characteristics.AppendLine("Description=" + networkInterface.Description);
// characteristics.AppendLine("InterfaceName=" + networkInterface.InterfaceName);
// characteristics.AppendLine("InterfaceState=" + networkInterface.InterfaceState);
// characteristics.AppendLine("InterfaceType=" + networkInterface.InterfaceType);
// characteristics.AppendLine("InterfaceSubtype=" + networkInterface.InterfaceSubtype);
// characteristics.AppendLine("Bandwidth=" + networkInterface.Bandwidth);
// //characteristics.AppendLine("Characteristics=" + networkInterface.Characteristics);
// TLUtils.WriteLine(characteristics.ToString(), LogSeverity.Error);
// }
//#endif
}
}
};
#endif
}
private void m_AppFrame_OnNext(object sender, EventArgs e)
{
spItems.Children.Clear();
string s;
s = "";
//
s += "Cellular Mobile Operator: ";
s += DeviceNetworkInformation.CellularMobileOperator;
//
s += "\r\n";
s += "Is Cellular Data Enabled: ";
if (DeviceNetworkInformation.IsCellularDataEnabled)
{
s += "Yes";
}
else
{
s += "No";
}
//
s += "\r\n";
s += "Is Cellular Data Roaming Enabled: ";
if (DeviceNetworkInformation.IsCellularDataRoamingEnabled)
{
s += "Yes";
}
else
{
s += "No";
}
//
s += "\r\n";
s += "Is Network Available: ";
if (DeviceNetworkInformation.IsNetworkAvailable)
{
s += "Yes";
}
else
{
s += "No";
}
//
s += "\r\n";
s += "Is WiFi Enabled: ";
if (DeviceNetworkInformation.IsWiFiEnabled)
{
s += "Yes";
}
else
{
s += "No";
}
//
AddItem(true, "Device Network Information", s);
NetworkInterfaceList nil = new NetworkInterfaceList();
AddItem(true, "Network Interface List", "");
foreach (NetworkInterfaceInfo nii in nil)
{
s = "";
//
s += "Interface Name: ";
s += nii.InterfaceName;
//
s += "\r\n";
s += "Description: ";
s += nii.Description;
//
s += "\r\n";
s += "Interface State: ";
s += nii.InterfaceState.ToString();
//
s += "\r\n";
s += "Interface Type: ";
s += nii.InterfaceType.ToString();
//
//
s += "\r\n";
s += "Characteristics: ";
s += nii.Characteristics.ToString();
//
s += "\r\n";
s += "Bandwidth: ";
s += nii.Bandwidth.ToString();
//
AddItem(false, nii.InterfaceName, s);
}
}
private void Login_Click(object sender, RoutedEventArgs e)
{
if (!DeviceNetworkInformation.IsWiFiEnabled)
{
MessageBoxResult result = MessageBox.Show(AppResources.WIFI_OFF_MESSAGE, AppResources.WIFI_OFF, MessageBoxButton.OK);
switch (result)
{
case MessageBoxResult.OK:
ConnectionSettingsTask connectionSettingsTask = new ConnectionSettingsTask();
connectionSettingsTask.ConnectionSettingsType = ConnectionSettingsType.WiFi;
connectionSettingsTask.Show();
return;
}
}
else
{
bool found = false;
NetworkInterfaceList netList = new NetworkInterfaceList();
foreach (NetworkInterfaceInfo network in netList)
{
if (network.InterfaceType == NetworkInterfaceType.Wireless80211
&& network.InterfaceState == ConnectState.Connected
&& network.InterfaceName.StartsWith("Rm3Wi-Fi"))
{
found = true;
break;
}
}
if (!found)
{
MessageBox.Show(AppResources.WRONG_WIFI_MESSAGE, AppResources.WRONG_WIFI, MessageBoxButton.OK);
return;
}
}
LoggedInText.Text = String.Empty;
ProgressBar.Visibility = Visibility.Visible;
webClient = new WebClient();
webClient.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
var uri = new Uri("https://authentication.uniroma3.it/login.pl", UriKind.Absolute);
StringBuilder postData = new StringBuilder();
postData.AppendFormat("{0}={1}", "bs_name", HttpUtility.UrlEncode(Username.Text));
postData.AppendFormat("&{0}={1}", "bs_password", HttpUtility.UrlEncode(Password.Password));
postData.AppendFormat("&{0}={1}", "_FORM_SUBMIT", HttpUtility.UrlEncode("1"));
postData.AppendFormat("&{0}={1}", "which_form", HttpUtility.UrlEncode("reg"));
//postData.AppendFormat("&{0}={1}", "source", HttpUtility.UrlEncode("10.8.1.199"));
//postData.AppendFormat("&{0}={1}", "destination", HttpUtility.UrlEncode("www.uniroma3.it"));
webClient.Headers[HttpRequestHeader.ContentLength] = postData.Length.ToString();
webClient.UploadStringCompleted += new UploadStringCompletedEventHandler(webClient_UploadStringCompleted);
try
{
webClient.UploadStringAsync(uri, "POST", postData.ToString());
}
catch (Exception)
{
webClient.UploadStringCompleted -= webClient_UploadStringCompleted;
MessageBox.Show(AppResources.WEB_ERROR_MESSAGE, AppResources.WEB_ERROR, MessageBoxButton.OK);
}
}
public void DeviceNetworkInfo()
{
//ConnectionSettingsTask connectionSettings = new ConnectionSettingsTask();
//connectionSettings.ConnectionSettingsType.ToString();
//DeviceNetworkInformation.ResolveHostNameAsync(
//new DnsEndPoint("microsoft.com", 80),
//new NameResolutionCallback(nrr =>
//{
// NetworkInterfaceInfo info = nrr.NetworkInterface;
// if (info != null)
// {
// switch (info.InterfaceType)
// {
// case NetworkInterfaceType.Ethernet:
// // USB connected
// break;
// case NetworkInterfaceType.MobileBroadbandCdma:
// case NetworkInterfaceType.MobileBroadbandGsm:
// switch (info.InterfaceSubtype)
// {
// case NetworkInterfaceSubType.Cellular_3G:
// case NetworkInterfaceSubType.Cellular_EVDO:
// case NetworkInterfaceSubType.Cellular_EVDV:
// case NetworkInterfaceSubType.Cellular_HSPA:
// // 3g
// break;
// default:
// break;
// }
// break;
// case NetworkInterfaceType.Wireless80211:
// // WIFI
// break;
// default:
// break;
// }
// }
//}), null);
NetworkInterfaceList networkInterfaceList = new NetworkInterfaceList();
foreach (NetworkInterfaceInfo networkInterfaceInfo in networkInterfaceList)
{
//Debug.WriteLine(networkInterfaceInfo.InterfaceName.ToString());
//Debug.WriteLine(networkInterfaceInfo.Bandwidth.ToString());
//Debug.WriteLine(networkInterfaceInfo.Characteristics.ToString());
//Debug.WriteLine(networkInterfaceInfo.Description.ToString());
//Debug.WriteLine(networkInterfaceInfo.InterfaceState.ToString());
//Debug.WriteLine(networkInterfaceInfo.InterfaceSubtype.ToString());
//Debug.WriteLine(networkInterfaceInfo.InterfaceType.ToString());
//Debug.WriteLine(networkInterfaceInfo.ToString());
}
//NetworkInterfaceInfo NetworkInterface = App.Current.Resources;
//int Bandwidth = NetworkInterface.Bandwidth;
//NetworkCharacteristics mNetworkCharacteristics = NetworkInterface.Characteristics;
//string Description = NetworkInterface.Description;
//string InterfaceName = NetworkInterface.InterfaceName;
//Debug.WriteLine(NetworkInterface.ToString());
//Debug.WriteLine(Bandwidth);
//Debug.WriteLine(mNetworkCharacteristics.ToString());
//Debug.WriteLine(Description.ToString());
//Debug.WriteLine(InterfaceName.ToString());
// Microsoft.Phone.Net.NetworkInformation
CellularMobileOperator = Microsoft.Phone.Net.NetworkInformation.DeviceNetworkInformation.CellularMobileOperator;
IsCellularDataEnabled = DeviceNetworkInformation.IsCellularDataEnabled;
IsCellularDataRoamingEnabled = DeviceNetworkInformation.IsCellularDataRoamingEnabled;
IsNetworkAvailable = DeviceNetworkInformation.IsNetworkAvailable;
IsWifiEnabled = DeviceNetworkInformation.IsWiFiEnabled;
}
