Beispiel #1
0
        /// <summary>
        ///  0:2G 1:3G 2:4G  3:wifi  4:无连接
        /// </summary>
        /// <returns></returns>
        private int GetConnectionGeneration()
        {
            try
            {
                ConnectionProfile profile = NetworkInformation.GetInternetConnectionProfile();

                if (profile.IsWwanConnectionProfile)
                {
                    WwanDataClass connectionClass = profile.WwanConnectionProfileDetails.GetCurrentDataClass();
                    switch (connectionClass)
                    {
                    //2G-equivalent
                    case WwanDataClass.Edge:
                    case WwanDataClass.Gprs:
                        return(0);

                    //3G-equivalent
                    case WwanDataClass.Cdma1xEvdo:
                    case WwanDataClass.Cdma1xEvdoRevA:
                    case WwanDataClass.Cdma1xEvdoRevB:
                    case WwanDataClass.Cdma1xEvdv:
                    case WwanDataClass.Cdma1xRtt:
                    case WwanDataClass.Cdma3xRtt:
                    case WwanDataClass.CdmaUmb:
                    case WwanDataClass.Umts:
                    case WwanDataClass.Hsdpa:
                    case WwanDataClass.Hsupa:
                        return(1);

                    //4G-equivalent
                    case WwanDataClass.LteAdvanced:
                        return(2);

                    //not connected
                    case WwanDataClass.None:
                        return(4);

                    //unknown
                    case WwanDataClass.Custom:
                    default:
                        return(4);
                    }
                }
                else if (profile.IsWlanConnectionProfile)
                {
                    return(3);
                }
                else if (profile.GetNetworkConnectivityLevel() == NetworkConnectivityLevel.InternetAccess)
                {
                    return(3);
                }
                return(4);
            }
            catch (Exception)
            {
                return(4); //as default
            }
        }
Beispiel #2
0
        /// <summary>
        /// 获取网络连接类型
        /// </summary>
        /// <returns></returns>
        public static string GetNetWorkType()
        {
            try
            {
                ConnectionProfile profile = NetworkInformation.GetInternetConnectionProfile();
                if (profile == null)
                {
                    return("未知");
                }
                if (profile.IsWwanConnectionProfile)
                {
                    WwanDataClass connectionClass = profile.WwanConnectionProfileDetails.GetCurrentDataClass();
                    switch (connectionClass)
                    {
                    //2G-equivalent
                    case WwanDataClass.Edge:
                    case WwanDataClass.Gprs:
                        return("2G");

                    //3G-equivalent
                    case WwanDataClass.Cdma1xEvdo:
                    case WwanDataClass.Cdma1xEvdoRevA:
                    case WwanDataClass.Cdma1xEvdoRevB:
                    case WwanDataClass.Cdma1xEvdv:
                    case WwanDataClass.Cdma1xRtt:
                    case WwanDataClass.Cdma3xRtt:
                    case WwanDataClass.CdmaUmb:
                    case WwanDataClass.Umts:
                    case WwanDataClass.Hsdpa:
                    case WwanDataClass.Hsupa:
                        return("3G");

                    //4G-equivalent
                    case WwanDataClass.LteAdvanced:
                        return("4G");

                    //not connected
                    case WwanDataClass.None:
                        return("未连接");

                    //unknown
                    case WwanDataClass.Custom:
                    default:
                        return("未知");
                    }
                }
                else if (profile.IsWlanConnectionProfile)
                {
                    return("WIFI");
                }
                return("未知");
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
                return("未知");
            }
        }
Beispiel #3
0
        /// <summary>
        /// 获取网络连接类型
        /// </summary>
        /// <returns></returns>
        public static NetworkType GetNetWorkType()
        {
            try
            {
                ConnectionProfile profile = NetworkInformation.GetInternetConnectionProfile();
                if (profile == null)
                {
                    return(NetworkType.Unknow);
                }
                if (profile.IsWwanConnectionProfile)
                {
                    WwanDataClass connectionClass = profile.WwanConnectionProfileDetails.GetCurrentDataClass();
                    switch (connectionClass)
                    {
                    //2G-equivalent
                    case WwanDataClass.Edge:
                    case WwanDataClass.Gprs:
                        return(NetworkType.Other);

                    //3G-equivalent
                    case WwanDataClass.Cdma1xEvdo:
                    case WwanDataClass.Cdma1xEvdoRevA:
                    case WwanDataClass.Cdma1xEvdoRevB:
                    case WwanDataClass.Cdma1xEvdv:
                    case WwanDataClass.Cdma1xRtt:
                    case WwanDataClass.Cdma3xRtt:
                    case WwanDataClass.CdmaUmb:
                    case WwanDataClass.Umts:
                    case WwanDataClass.Hsdpa:
                    case WwanDataClass.Hsupa:
                        return(NetworkType.Other);

                    //4G-equivalent
                    case WwanDataClass.LteAdvanced:
                        return(NetworkType.Other);

                    //not connected
                    case WwanDataClass.None:
                        return(NetworkType.NotNetwork);

                    //unknown
                    case WwanDataClass.Custom:
                    default:
                        return(NetworkType.Unknow);
                    }
                }
                else if (profile.IsWlanConnectionProfile)
                {
                    return(NetworkType.Wifi);
                }
                return(NetworkType.Unknow);
            }
            catch (Exception)
            {
                return(NetworkType.Unknow); //as default
            }
        }
Beispiel #4
0
        /// <summary>
        /// Detect the current connection type
        /// </summary>
        /// <returns>
        /// 2 for 2G, 3 for 3G, 4 for 4G
        /// 100 for WiFi
        /// 0 for unknown or not connected</returns>
        internal static byte GetConnectionGeneration()
        {
            ConnectionProfile profile = NetworkInformation.GetInternetConnectionProfile();

            if (profile.IsWwanConnectionProfile)
            {
                WwanDataClass connectionClass = profile.WwanConnectionProfileDetails.GetCurrentDataClass();
                switch (connectionClass)
                {
                //2G-equivalent
                case WwanDataClass.Edge:
                case WwanDataClass.Gprs:
                    return(2);

                //3G-equivalent
                case WwanDataClass.Cdma1xEvdo:
                case WwanDataClass.Cdma1xEvdoRevA:
                case WwanDataClass.Cdma1xEvdoRevB:
                case WwanDataClass.Cdma1xEvdv:
                case WwanDataClass.Cdma1xRtt:
                case WwanDataClass.Cdma3xRtt:
                case WwanDataClass.CdmaUmb:
                case WwanDataClass.Umts:
                case WwanDataClass.Hsdpa:
                case WwanDataClass.Hsupa:
                    return(3);

                //4G-equivalent
                case WwanDataClass.LteAdvanced:
                    return(4);

                //not connected
                case WwanDataClass.None:
                    return(0);

                //unknown
                case WwanDataClass.Custom:
                default:
                    return(0);
                }
            }
            else if (profile.IsWlanConnectionProfile)
            {
                return(100);
            }
            return(0);
        }
Beispiel #5
0
        private NetworkType GetConnectionGeneration()
        {
            bool        isConnected = false;
            NetworkType nt          = NetworkType.Unknown;

            ConnectionProfile profile = NetworkInformation.GetInternetConnectionProfile();

            if (profile == null)
            {
                nt = NetworkType.NotConnected;
            }
            else
            {
                NetworkConnectivityLevel cl = profile.GetNetworkConnectivityLevel();
                isConnected = (cl != NetworkConnectivityLevel.None);
            }

            if (!isConnected)
            {
                nt = NetworkType.NotConnected;
                return(nt);
            }

            if (profile.IsWwanConnectionProfile)
            {
                if (null == profile.WwanConnectionProfileDetails)
                {
                    nt = NetworkType.Unknown;
                }
                WwanDataClass connectionClass = profile.WwanConnectionProfileDetails.GetCurrentDataClass();
                switch (connectionClass)
                {
                // 2G
                case WwanDataClass.Gprs:
                case WwanDataClass.Edge:
                    nt = NetworkType.Wwan2G;
                    break;

                // 3G
                case WwanDataClass.Cdma1xRtt:
                case WwanDataClass.Cdma1xEvdo:
                case WwanDataClass.Cdma1xEvdoRevA:
                case WwanDataClass.Cdma1xEvdv:
                case WwanDataClass.Cdma3xRtt:
                case WwanDataClass.Cdma1xEvdoRevB:
                case WwanDataClass.CdmaUmb:
                case WwanDataClass.Hsdpa:
                case WwanDataClass.Hsupa:
                case WwanDataClass.Umts:
                    nt = NetworkType.Wwan3G;
                    break;

                // 4G
                case WwanDataClass.LteAdvanced:
                    nt = NetworkType.Wwan4G;
                    break;

                // No Internet Connection
                case WwanDataClass.None:
                    nt = NetworkType.Unknown;
                    break;

                case WwanDataClass.Custom:
                default:
                    nt = NetworkType.Unknown;
                    break;
                }
            }
            else if (profile.IsWlanConnectionProfile)
            {
                nt = NetworkType.WLAN;
            }
            else
            {
                //不是Wifi也不是蜂窝数据判断为Lan
                nt = NetworkType.LAN;
            }

            return(nt);
        }
Beispiel #6
0
        public static string GetConnectionGeneration()
        {
            bool isConnected = false;

            string            InternetType = null;
            ConnectionProfile profile      = NetworkInformation.GetInternetConnectionProfile();

            if (profile == null)
            {
                InternetType = InternetStatus.None;
            }
            else
            {
                NetworkConnectivityLevel cl = profile.GetNetworkConnectivityLevel();
                isConnected = (cl != NetworkConnectivityLevel.None);
            }
            if (!isConnected)
            {
                return(InternetStatus.None);
            }
            if (profile.IsWwanConnectionProfile)
            {
                if (profile.WwanConnectionProfileDetails == null)
                {
                    InternetType = InternetStatus.Unknown;
                }
                WwanDataClass connectionClass = profile.WwanConnectionProfileDetails.GetCurrentDataClass();
                switch (connectionClass)
                {
                //2G
                case WwanDataClass.Edge:
                case WwanDataClass.Gprs:
                    InternetType = InternetStatus.IIG;
                    break;

                //3G
                case WwanDataClass.Cdma1xEvdo:
                case WwanDataClass.Cdma1xEvdoRevA:
                case WwanDataClass.Cdma1xEvdoRevB:
                case WwanDataClass.Cdma1xEvdv:
                case WwanDataClass.Cdma1xRtt:
                case WwanDataClass.Cdma3xRtt:
                case WwanDataClass.CdmaUmb:
                case WwanDataClass.Umts:
                case WwanDataClass.Hsdpa:
                case WwanDataClass.Hsupa:
                    InternetType = InternetStatus.IIIG;
                    break;

                //4G
                case WwanDataClass.LteAdvanced:
                    InternetType = InternetStatus.IVG;
                    break;

                //无网
                case WwanDataClass.None:
                    InternetType = InternetStatus.Unknown;
                    break;

                case WwanDataClass.Custom:
                default:
                    InternetType = InternetStatus.Unknown;
                    break;
                }
            }
            else if (profile.IsWlanConnectionProfile)
            {
                InternetType = InternetStatus.Wifi;
            }
            else
            {
                InternetType = InternetStatus.Lan;
            }
            return(InternetType);
        }
        public async Task <InternetSpeed> CheckInternetSpeedSignalAsync()
        {
            //Initially assuming we have best internet connection
            var internetStability = InternetSpeed.VeryGoodInternet;
            //InternetConnectionProfile
            var InternetConnectionProfile = NetworkInformation.GetInternetConnectionProfile();

            //If no internet found return no internet found
            if (InternetConnectionProfile == null)
            {
                return(InternetSpeed.NoInternet);
            }

            //Check Connectivity Level
            switch (InternetConnectionProfile.GetNetworkConnectivityLevel())
            {
            case NetworkConnectivityLevel.None:
                return(InternetSpeed.NoInternet);

            case NetworkConnectivityLevel.LocalAccess:
                return(InternetSpeed.NoInternet);

            case NetworkConnectivityLevel.ConstrainedInternetAccess:
                internetStability = InternetSpeed.AverageInternet;
                break;

            case NetworkConnectivityLevel.InternetAccess:
                internetStability = InternetSpeed.VeryGoodInternet;
                break;
            }

            //Check Domain Connectivity Level
            switch (InternetConnectionProfile.GetDomainConnectivityLevel())
            {
            case DomainConnectivityLevel.None:
                internetStability = InternetSpeed.VeryGoodInternet;
                break;

            case DomainConnectivityLevel.Unauthenticated:
                return(InternetSpeed.NoInternet);

            case DomainConnectivityLevel.Authenticated:
                break;
            }

            //Connection Cost
            var connectionCost = InternetConnectionProfile.GetConnectionCost();

            //Check Metered network
            if (connectionCost.NetworkCostType == NetworkCostType.Unknown ||
                connectionCost.NetworkCostType == NetworkCostType.Unrestricted &&
                (!connectionCost.Roaming))
            {
                //Connection cost is unknown/unrestricted && Not roaming
                //All good Green banner
                internetStability = InternetSpeed.VeryGoodInternet;
            }
            else if (connectionCost.NetworkCostType == NetworkCostType.Variable || connectionCost.NetworkCostType == NetworkCostType.Fixed &&
                     (!connectionCost.Roaming && !connectionCost.OverDataLimit))
            {
                //Metered Network && Not roaming && Not over data limit
                //Ok but make sure data limit is not reached
                //Yellow banner
                internetStability = InternetSpeed.AverageInternet;
            }
            else if (connectionCost.Roaming || connectionCost.OverDataLimit)
            {
                //roaming or over data limit
                //ToDo://Notify User about roaming internet usage
                //Red banner
                return(InternetSpeed.Unknown);
            }

            //Wifi
            bool isWifi = InternetConnectionProfile.IsWlanConnectionProfile;

            //Mobile
            bool isMobile = InternetConnectionProfile.IsWwanConnectionProfile;

            //WiredLan
            bool isWiredLan = false;

            //Check Wired Lan
            if (!isWifi && !isMobile)
            {
                isWiredLan = true;
            }

            //Check Wifi Signal Strength
            var signalBars = InternetConnectionProfile.GetSignalBars();

            //conditional internet strength check
            if (isWiredLan)
            {
                //currently we cannot check if wired lan is having good/ slow/ fast internet speed
                //ToDo://Find a better way
                //may be check both speed by signal strength and then speed by socket connection
                internetStability = InternetSpeed.VeryGoodInternet;
            }
            else if (isWifi)
            {
                if (signalBars >= (int)WifiSignalStrength.VeryGood)
                {
                    //Very Good Wifi Signal
                    //internetStability = InternetStability.VeryGoodInternet;
                }
                else if (signalBars >= (int)WifiSignalStrength.Good)
                {
                    //Average Wifi Signal
                    internetStability = InternetSpeed.AverageInternet;
                }
                else if (signalBars == (int)WifiSignalStrength.Average)
                {
                    //Average Wifi Signal
                    internetStability = InternetSpeed.SlowInternet;
                }
                else
                {
                    //Low Wifi Signal
                    internetStability = InternetSpeed.VeryPoorInternet;
                }
            }
            else if (isMobile)
            {
                if (signalBars >= (int)MobileSignalStrength.VeryGood)
                {
                    //Very Good Mobile Signal
                    //internetStability = InternetStability.VeryGoodInternet;
                }
                else if (signalBars >= (int)MobileSignalStrength.Good)
                {
                    //Average Mobile Signal
                    internetStability = InternetSpeed.VeryGoodInternet;
                }
                else if (signalBars == (int)MobileSignalStrength.Average)
                {
                    //Average Mobile Signal
                    internetStability = InternetSpeed.AverageInternet;
                }
                else if (signalBars == (int)MobileSignalStrength.VeryWeak)
                {
                    internetStability = InternetSpeed.VeryPoorInternet;
                }
                else if (signalBars <= (int)MobileSignalStrength.Weak)
                {
                    //Low Mobile Signal
                    internetStability = InternetSpeed.SlowInternet;
                }

                WwanDataClass connectionClass = InternetConnectionProfile.WwanConnectionProfileDetails.GetCurrentDataClass();
                switch (connectionClass)
                {
                //2G-equivalent
                case WwanDataClass.Edge:
                case WwanDataClass.Gprs:
                    internetStability = InternetSpeed.SlowInternet;
                    break;

                //3G-equivalent
                case WwanDataClass.Cdma1xEvdo:
                case WwanDataClass.Cdma1xEvdoRevA:
                case WwanDataClass.Cdma1xEvdoRevB:
                case WwanDataClass.Cdma1xEvdv:
                case WwanDataClass.Cdma1xRtt:
                case WwanDataClass.Cdma3xRtt:
                case WwanDataClass.CdmaUmb:
                case WwanDataClass.Umts:
                case WwanDataClass.Hsdpa:
                case WwanDataClass.Hsupa:
                //4G-equivalent
                case WwanDataClass.LteAdvanced:
                    if ((int)internetStability >= (int)InternetSpeed.SlowInternet)
                    {
                        internetStability = InternetSpeed.VeryGoodInternet;
                    }
                    else
                    {
                        internetStability = InternetSpeed.SlowInternet;
                    }
                    break;

                //not connected
                case WwanDataClass.None:
                    internetStability = InternetSpeed.NoInternet;
                    break;

                //unknown
                case WwanDataClass.Custom:
                default:
                    break;
                }
            }

            await Task.CompletedTask;

            return(internetStability);
        }