private void NetworkChanged(NetworkInfo info, bool fireMissiles = true)
{
if (info == null) return;
ChangeConnectivityStatus(info.IsConnected, info.Type == ConnectivityType.Wifi,
info.Type == ConnectivityType.Mobile, fireMissiles);
}
void HandleConnectedToNetwork(NetworkInfo networkInfo)
{
statusText.color = Color.white;
statusText.text = "Connected!";
Messenger<int>.Broadcast("LoadLevel", networkInfo.CurrentLevelId);
}
private void SetFromInfo(NetworkInfo network) {
this.SetStatus(
network.IsConnected,
(network != null && network.Type == ConnectivityType.Wifi),
(network != null && network.Type == ConnectivityType.Mobile)
);
}
protected override void OnResponded(int responseId)
{
if (responseId == (int)ResponseType.Ok) {
newNetwork = new NetworkInfo ();
newNetwork.NetworkName = NetworkName;
}
}
public bool Check()
{
ConnectivityManager manager =
(ConnectivityManager)this.Context.GetSystemService(Context.ConnectivityService);
NetworkInfo ni = manager.ActiveNetworkInfo;
return(ni != null ? ni.IsConnectedOrConnecting : false);
}
public bool IsNetworkAvailable()
{
ConnectivityManager connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
NetworkInfo activeNetworkInfo = connectivityManager.ActiveNetworkInfo;
return(activeNetworkInfo == null ? false : activeNetworkInfo.IsConnectedOrConnecting);
}
public static bool IsNetworkAvailable(Context context)
{
ConnectivityManager connectivityManager
= (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);
NetworkInfo activeNetworkInfo = connectivityManager.ActiveNetworkInfo;
return(activeNetworkInfo != null && activeNetworkInfo.IsConnected);
}
private void SetFromInfo(NetworkInfo network)
{
this.SetStatus(
network.IsConnected,
(network != null && network.Type == ConnectivityType.Wifi),
(network != null && network.Type == ConnectivityType.Mobile)
);
}
public void simple_synchronous_call_getnetworkinfo_returns_result()
{
SimpleClient client = new SimpleClient();
NetworkInfo network = client.GetNetworkInfo(Network.BitcoinTest);
Assert.IsNotNull(network);
Assert.IsTrue(network.Status == Consts.Success);
}
public bool GetConnectionStatus()
{
ConnectivityManager connectivityManager = (ConnectivityManager)GetSystemService(ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
bool isOnline = (activeConnection != null) && activeConnection.IsConnected;
return(isOnline);
}
/// <summary>
/// Conectados the red.
/// </summary>
/// <returns><c>true</c>, if red was conectadoed, <c>false</c> otherwise.</returns>
public bool ConectadoRed()
{
ConnectivityManager connectivityManager =
(ConnectivityManager)Android.App.Application.Context.GetSystemService(Context.ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
return(activeConnection != null && activeConnection.IsConnected);
}
private void FrmNetwork_Load(object sender, EventArgs e)
{
ns = new NetworkSpeed();
ns.NotityInfoEvent += Ns_NotityInfoEvent;
ns.Start();
lblPublicIP.Text = NetworkInfo.GetPublicIP();
}
//checking internet connection
private void checkInternetConnection()
{
ConnectivityManager connectivityManager = (ConnectivityManager)GetSystemService(ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
isOnline = (activeConnection != null) && activeConnection.IsConnected;
}
public static Boolean RevisarConexion()
{
ConnectivityManager connectivityManager = (ConnectivityManager)Android.App.Application.Context.GetSystemService(Context.ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
var r = (activeConnection.Type == Android.Net.ConnectivityType.Wifi) && activeConnection.IsConnected;
return(r);
}
protected override void OnResponded(int responseId)
{
if (responseId == (int)ResponseType.Ok)
{
newNetwork = new NetworkInfo();
newNetwork.NetworkName = NetworkName;
}
}
public bool CheckInternet()
{
ConnectivityManager cm = (ConnectivityManager)Context.GetSystemService(Context.ConnectivityService);
NetworkInfo activeNetwork = cm.ActiveNetworkInfo;
return(activeNetwork != null && activeNetwork.IsConnectedOrConnecting);
}
/// <summary>
/// Determines whether this instance is connected.
/// </summary>
/// <returns><c>true</c> if this instance is connected; otherwise, <c>false</c>.</returns>
public bool IsConnected()
{
var connectivityManager = (ConnectivityManager)GetSystemService(ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
bool conn = (activeConnection != null) && activeConnection.IsConnected;
return(conn);
}
private bool isNetworkAvailable()
{
var connectivityManager
= (ConnectivityManager)this.Activity.GetSystemService(Context.ConnectivityService);
NetworkInfo activeNetworkInfo = connectivityManager.ActiveNetworkInfo;
return(activeNetworkInfo != null && activeNetworkInfo.IsConnected);
}
public bool CheckConnection()
{
var connectivityManager = (ConnectivityManager)Forms.Context.ApplicationContext.GetSystemService(Context.ConnectivityService);
NetworkInfo networkInfo = connectivityManager.ActiveNetworkInfo;
bool isConnected = networkInfo != null && networkInfo.IsConnectedOrConnecting;
return(isConnected);
}
public bool CheckConnection()
{
var connectivityManager = (ConnectivityManager)MainActivity.Instance.GetSystemService(Context.ConnectivityService);
NetworkInfo netWorkInfo = connectivityManager.ActiveNetworkInfo;
return((netWorkInfo != null) && netWorkInfo.IsConnected);
}
public bool CheckInternetConnection()
{
ConnectivityManager connectivityManager
= (ConnectivityManager)Activity.GetSystemService(Context.ConnectivityService);
NetworkInfo activeNetworkInfo = connectivityManager.ActiveNetworkInfo;
return(activeNetworkInfo != null && activeNetworkInfo.IsConnected);
}
public bool HasNetworkAccess()
{
Context c = Android.App.Application.Context;
ConnectivityManager cm = (ConnectivityManager)c.GetSystemService(Context.ConnectivityService);
NetworkInfo netInfo = cm.ActiveNetworkInfo;
return(netInfo != null && netInfo.IsConnectedOrConnecting);
}
public void StartHostGame()
{
var endpoint = NetworkEndPoint.LoopbackIpv4;
endpoint.Port = NetworkInfo.Port;
NetworkInfo.SetPoint(endpoint);
StartCoroutine(StartHost());
}
public SystemMonitorService()
{
Info = new SysInfo();
Battery = new BatteryInfo();
Processor = new ProcessorInfo();
Memory = new MemoryInfo();
Network = new NetworkInfo();
}
public static Node Connect(NetworkInfo network,
string endpoint,
ProtocolVersion myVersion = ProtocolVersion.PROTOCOL_VERSION,
bool isRelay = true,
CancellationToken cancellation = default(CancellationToken))
{
return(Connect(network, Utils.ParseIpEndpoint(endpoint, network.DefaultPort), myVersion, isRelay, cancellation));
}
public static bool InternetConnected()
{
ConnectivityManager connectivityManager = ConnectivityManager.FromContext(Application.Context);
NetworkInfo networkInfo = connectivityManager.ActiveNetworkInfo;
return(networkInfo != null && networkInfo.IsConnected);
}
//Проверка доступа к сети интернет
public Boolean checkInternet()
{
ConnectivityManager connectivityManager = (ConnectivityManager)GetSystemService(ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
bool isOnline = (activeConnection != null) && activeConnection.IsConnected;
return(isOnline);
}
public bool IsOnline()
{
ConnectivityManager cm =
(ConnectivityManager)GetSystemService(ConnectivityService);
NetworkInfo netInfo = cm.ActiveNetworkInfo;
return(netInfo != null && netInfo.IsConnectedOrConnecting);
}
public bool checkNetwork()
{
NetworkInfo activeNetwork = cm.ActiveNetworkInfo;
bool isConnected = activeNetwork != null &&
activeNetwork.IsConnectedOrConnecting;
return(isConnected);
}
public bool IsOnline()
{
ConnectivityManager connectivityManager = (ConnectivityManager)sampleContext.GetSystemService(Context.ConnectivityService);
NetworkInfo networkInfo = connectivityManager.ActiveNetworkInfo;
var isConnected = networkInfo == null ? false : networkInfo.IsConnected;
return(isConnected);
}
public bool IsConnected()
{
ConnectivityManager connectivityManager = (ConnectivityManager)LocalApp.GetInstance().GetSystemService(LocalApp.ConnectivityService);
NetworkInfo activeConnection = connectivityManager.ActiveNetworkInfo;
bool isOnline = (activeConnection != null) && activeConnection.IsConnected;
return(isOnline);
}
public static bool IsConnectionAvailable(Context context)
{
ConnectivityManager cm = (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);
NetworkInfo activeNetwork = cm.ActiveNetworkInfo;
return(activeNetwork != null &&
activeNetwork.IsConnectedOrConnecting);
}
#pragma warning disable CS0618 // Type or member is obsolete
static ConnectionProfile?ProcessNetworkInfo(NetworkInfo info)
{
if (info == null || !info.IsAvailable || !info.IsConnectedOrConnecting)
{
return(null);
}
return(GetConnectionType(info.Type, info.TypeName));
}
/// <summary>
/// Helper method to convert a <see cref="NetworkInfo"/> instance
/// to a <see cref="NetworkData"/> instance.
/// </summary>
/// <param name="info">The full data instance.</param>
/// <returns>The converted data.</returns>
public static NetworkData ToNetworkData(this NetworkInfo info)
{
return(new NetworkData()
{
Uuid = info?.Uuid,
Link = info?.Link,
Name = info?.Name
});
}
private void SetFromInfo(NetworkInfo network) {
if (network == null || !network.IsConnected)
this.IsConnected = false;
else {
this.IsConnected = true;
this.IsRoaming = network.IsRoaming;
this.IsWifi = (network.Type == ConnectivityType.Wifi);
this.IsMobile = (network.Type == ConnectivityType.Mobile);
}
this.PostUpdateStates();
}
private void SetNetworkInfo(SystemInfo systemInfo, SystemInformation systemInformation)
{
foreach (NetworkInterface network in systemInformation.Interfaces)
{
NetworkInfo networkInfo = new NetworkInfo();
networkInfo.MacAddress = network.MacAddress;
networkInfo.Name = network.Name;
networkInfo.IpAddress = network.IpAddress;
systemInfo.NetworkInterfaces.Add(networkInfo);
}
}
void OnJoinedRoom()
{
var networkInfo = new NetworkInfo
{
CurrentLevelId = (int)PhotonNetwork.room.customProperties["CurrentLevelId"]
};
Log.Write("Connected to nework");
Messenger<NetworkInfo>.Broadcast("ConnectedToNetwork", networkInfo);
}
public EditNetworkDialog(Window parentWindow, NetworkInfo networkInfo)
: base(parentWindow, "EditNetworkDialog")
{
this.networkInfo = networkInfo;
Dialog.Title = String.Format ("Editing network: {0}", networkInfo.NetworkName);
trustedNodesList.AppendColumn ("Name", new CellRendererText (), new TreeCellDataFunc (NameFunc));
trustedNodesListStore = new ListStore (typeof (TrustedNodeInfo));
foreach (TrustedNodeInfo trustedNode in networkInfo.TrustedNodes.Values) {
trustedNodesListStore.AppendValues (trustedNode);
}
trustedNodesList.Model = trustedNodesListStore;
}
/// <summary>
/// Updates the network type based upon the info returned from the
/// connectivity manager.
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
protected override NetworkState GetNetworkState(NetworkInfo info)
{
var state = NetworkState.Disconnected;
if (info.Type == ConnectivityType.Mobile)
{
var networkType = (NetworkType)info.Subtype;
switch (networkType)
{
case NetworkType.Hspap:
case NetworkType.Ehrpd:
case NetworkType.Lte:
state = NetworkState.Is3G | NetworkState.Is4G;
break;
}
}
return base.GetNetworkState(info) | state;
}
/// <summary>
/// Compute psudo hessian matrix and its gradient
/// </summary>
/// <param name="info">NetworkInfo - information about neural network</param>
/// <param name="inp">Input - input data patterns used for learn</param>
/// <param name="dout">Output - output data patterns used for learn</param>
/// <param name="topo">Topography - neural network topography</param>
/// <param name="ww">Weights - weights</param>
/// <param name="act">Activation - activation function selection</param>
/// <param name="gain">Gain - neuron gain</param>
/// <param name="iw">Index - topography indexes</param>
public void Compute(ref NetworkInfo info, ref Input inp, ref Output dout, ref Topography topo,
Weights ww, ref Activation act, ref Gain gain, ref Index iw)
{
GradientMat = MatrixMB.Zeros(info.nw, 1);
HessianMat = MatrixMB.Zeros(info.nw, info.nw);
np = info.np;//number of patterns
ni = info.ni;//number of inputs
no = info.no;//number of outputs
nw = info.nw;//number of weights
nn = info.nn;//number of neurons
nio = nn + ni - no;
zeros = ni.Zeros();
delo = MatrixMB.Zeros(1, nio + 1);
J = MatrixMB.Zeros(1, nw);
for (p = 0; p < np; p++)
{
node.Clear();
node.AddRange(inp.Data[p]);
CalculateFunctionValuesAndDerivates(ref ww, ref iw, ref topo, ref act, ref gain);
for (k = 0; k < no; k++)
{
o = nio + k;
error = dout.Data[p][k] - node[o];
J.ClearWithZeros();
s = iw.Pos(o - ni);
J.Data[0][s] = -derivates[o];
delo.ClearWithZeros();
CalculateJacobian(ref ww, ref iw, ref topo);
CalculateForHiddenLayer(ref iw, ref topo, ref ww);
if (dout[p, 0] > 0.5) J = J * ratio;
var JT = J.Transposed;
GradientMat = GradientMat + JT * error;
HessianMat = HessianMat + JT * J;
}
}
}
/// <summary>
/// Total error calculation
/// </summary>
/// <param name="info">NetworkInfo</param>
/// <param name="inp">ref Input - input data patterns</param>
/// <param name="dout">ref Output - output data</param>
/// <param name="topo">ref Topography - topo is network topology in the form of one vector</param>
/// <param name="ww">ref Weights weights</param>
/// <param name="act">ref Activation - type of activation function</param>
/// <param name="gain">ref Gain - strengthening the activation function</param>
/// <param name="iw">ref WeightsPointers - index pointers used for network topology stored in top in the form of one vector</param>
/// <remarks>Network error will be overriden so please save it</remarks>
public double CalculateError(ref NetworkInfo info, ref Input inp, ref Output dout, ref Topography topo,
Weights ww, ref Activation act, ref Gain gain, ref Index iw)
{
try
{
Error = 0;
for (p = 0; p < info.np; p++)
{
node.Clear();
node.AddRange(inp.Data[p]);
for (n = 0; n < info.nn; n++)
{
net = ww[iw.Pos(n)];
int from = iw.Pos(n) + 1;
int to = iw.Pos(n + 1) - 1;
for (i = from; i <= to; i++)
{
net += node[(int)topo[i]] * ww[i];
}
node.Add(ActivationFunction.computeFunction(ref n, ref net, ref act, ref gain));
}
for (k = 0; k < info.no; k++)
{
Error += System.Math.Pow((dout.Data[p][k] - node[info.nio + k]), 2);
}
}
return Error;
}
catch (System.Exception ex)
{
throw new NeuralNetworkError("Błąd uaktualnienia błędu sieci neuronowej. " + ex.Message, ex);
}
}
private async void CallDeleteFriendFromFriendList()
{
connectivityManager = (ConnectivityManager) GetSystemService(ConnectivityService);
activeNetworkInfo = connectivityManager.ActiveNetworkInfo;
if (activeNetworkInfo == null || !activeNetworkInfo.IsConnected)
{
Toast.MakeText(this, GetString(Resource.String.NoConnectionInfo), ToastLength.Long).Show();
return;
}
apiMessage = await DeleteFriendFromFriendList(mItems[(int)info.Id].Id);
if (apiMessage.IsSuccessStatusCode)
{
Toast.MakeText(this, GetString(Resource.String.FriendDeleteOkInfo), ToastLength.Long).Show();
GetMyFriends();
}
else if (apiMessage.StatusCode == HttpStatusCode.Unauthorized)
{
Toast.MakeText(this, GetString(Resource.String.LoginTokenOrTravelerFailure),ToastLength.Long).Show();
Finish();
StartActivity(typeof(LoginActivity));
}
else Toast.MakeText(this, GetString(Resource.String.FriendDeleteNotOkInfo), ToastLength.Long).Show();
}
internal ConnectionProfile(NetworkInfo info)
{
_info = info;
}
private async void GetMyFriends()
{
var traveler = JsonConvert.DeserializeObject<Traveler>(preferences.GetString("traveler", null));
connectivityManager = (ConnectivityManager) GetSystemService(ConnectivityService);
activeNetworkInfo = connectivityManager.ActiveNetworkInfo;
if (traveler == null || token == null)
{
Toast.MakeText(this, GetString(Resource.String.LoginTokenOrTravelerFailure), ToastLength.Long).Show();
Finish();
StartActivity(typeof(LoginActivity));
}
else if (activeNetworkInfo == null || !activeNetworkInfo.IsConnected)
Toast.MakeText(this, GetString(Resource.String.NoConnectionInfo),ToastLength.Long).Show();
else
{
var url = string.Format(GetString(Resource.String.ApiLink)
+ "/api/friendlist/getfriendlist?ownerId={0}", traveler.Id);
client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(token.TokenType, token.AccessToken);
var loadingMessage = ProgressDialog.Show(this, GetString(Resource.String.LoadingFriendListTitle),
GetString(Resource.String.LoadingFriendListContent), true, false);
var response = await client.GetAsync(new Uri(url));
loadingMessage.Dismiss();
mItems.Clear();
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var friendListItems = JsonConvert.DeserializeObject<List<FriendListItem>>(content);
foreach (var friendListItem in friendListItems)
{
mItems.Add(new FriendListItem
{
Id = friendListItem.Id,
OwnerId = friendListItem.OwnerId,
FriendId = friendListItem.FriendId,
Owner = friendListItem.Owner,
Friend = friendListItem.Friend
});
}
}
else if (response.StatusCode == HttpStatusCode.NotFound)
Toast.MakeText(this, GetString(Resource.String.LoadingFriendListEmptyInfo), ToastLength.Long).Show();
else
Toast.MakeText(this, GetString(Resource.String.LoadingFriendListNotOkInfo), ToastLength.Long).Show();
var adapter = new MyFriendsListViewAdapter(this, mItems);
mMyFriendsList.Adapter = adapter;
}
}
/// <summary>
/// Copy neural network information
/// </summary>
/// <returns>NetworkInfo</returns>
public NetworkInfo Copy()
{
NetworkInfo info = new NetworkInfo();
info.np = this.np;
info.no = this.no;
info.ni = this.ni;
info.nn = this.nn;
info.nw = this.nw;
return info;
}
public static async Task<IList<NetworkInfo>> GetNetworkInformation()
{
var networkList = new Dictionary<Guid, NetworkInfo>();
var hostNamesList = NetworkInformation.GetHostNames();
var resourceLoader = ResourceLoader.GetForCurrentView();
foreach (var hostName in hostNamesList)
{
if ((hostName.Type == HostNameType.Ipv4 || hostName.Type == HostNameType.Ipv6) &&
(hostName != null && hostName.IPInformation != null && hostName.IPInformation.NetworkAdapter != null))
{
var profile = await hostName.IPInformation.NetworkAdapter.GetConnectedProfileAsync();
if (profile != null)
{
NetworkInfo info;
var found = networkList.TryGetValue(hostName.IPInformation.NetworkAdapter.NetworkAdapterId, out info);
if (!found)
{
info = new NetworkInfo();
networkList[hostName.IPInformation.NetworkAdapter.NetworkAdapterId] = info;
if (hostName.IPInformation.NetworkAdapter.IanaInterfaceType == WirelessInterfaceIanaType &&
profile.ProfileName.Equals("Ethernet"))
{
info.NetworkName = "Wireless LAN Adapter";
}
else
{
info.NetworkName = profile.ProfileName;
}
var statusTag = profile.GetNetworkConnectivityLevel().ToString();
info.NetworkStatus = resourceLoader.GetString("NetworkConnectivityLevel_" + statusTag);
}
if (hostName.Type == HostNameType.Ipv4)
{
info.NetworkIpv4 = hostName.CanonicalName;
}
else
{
info.NetworkIpv6 = hostName.CanonicalName;
}
}
}
}
var res = new List<NetworkInfo>();
res.AddRange(networkList.Values);
return res;
}
private static bool IsNetworkConnected (NetworkInfo networkInfo)
{
return networkInfo != null && networkInfo.IsConnected;
}
public NetworkInfo GetNetworkInfo()
{
var wmiSystemInfo = new WmiSystemInfo();
var networkInfo = new NetworkInfo();
networkInfo.ComputerName = Environment.MachineName;
networkInfo.MacAddress = wmiSystemInfo.GetMACAddress();
networkInfo.IpAddress = GetIpAddress();
return networkInfo;
}
/// <summary>
/// An extremely simple network setup
/// </summary>
void NetworkUpdate(NetworkInfo.StatusType status)
{
switch (status)
{
case NetworkInfo.StatusType.JoinedRoom:
statusLabel.text = "Joined Room";
statusLabel.gameObject.SetActive(false);
SpawnPlayer();
break;
default:
statusLabel.gameObject.SetActive(true);
statusLabel.text = status.ToString();
break;
}
}
/// <summary>
/// Updates the network type based upon the info returned from the
/// connectivity manager.
/// </summary>
/// <param name="info">
/// </param>
/// <returns>
/// The ExpansionDownloader.Service.DownloaderService+NetworkState.
/// </returns>
protected virtual NetworkState GetNetworkState(NetworkInfo info)
{
var state = NetworkState.Disconnected;
switch (info.Type)
{
case ConnectivityType.Wimax:
state = NetworkState.Is3G | NetworkState.Is3G | NetworkState.IsCellular;
break;
case ConnectivityType.Mobile:
state = NetworkState.IsCellular;
switch ((NetworkType)info.Subtype)
{
case NetworkType.Hsdpa:
case NetworkType.Hsupa:
case NetworkType.Hspa:
case NetworkType.Evdo0:
case NetworkType.EvdoA:
case NetworkType.Umts:
state |= NetworkState.Is3G;
break;
}
break;
}
return state;
}
public NetworkInforMarshalled(NetworkInfo list)
{
this.deleg = list;
}
private static void SerializeNetwork(NetworkInfo line, string file)
{
XmlSerializer xs = new XmlSerializer(typeof(NetworkInfo));
if (File.Exists(file))
{
File.Delete(file);
}
StreamWriter writer = File.AppendText(file);
xs.Serialize(writer, line);
writer.Close();
}
/// <summary>
/// The update network state.
/// </summary>
/// <param name="info">
/// The info.
/// </param>
private void UpdateNetworkState(NetworkInfo info)
{
NetworkState tempState = this.networkState;
this.networkState = NetworkState.Disconnected;
if (info != null && info.IsConnected)
{
this.networkState = NetworkState.Connected;
if (info.IsRoaming)
{
this.networkState |= NetworkState.Roaming;
}
if (info.IsFailover)
{
this.networkState |= NetworkState.IsFailOver;
}
this.networkState |= this.GetNetworkState(info);
}
this.stateChanged = this.stateChanged || this.networkState != tempState;
if (this.stateChanged)
{
Log.Debug(Tag,"LVLDL Network state changed: ");
Log.Debug(Tag,"LVLDL Starting State: {0}", tempState);
Log.Debug(Tag,"LVLDL Ending State: {0}", this.networkState);
if (this.IsServiceRunning)
{
if (this.networkState.HasFlag(NetworkState.Roaming))
{
this.Status = DownloadStatus.WaitingForNetwork;
this.Control = ControlAction.Paused;
}
else if (this.networkState.HasFlag(NetworkState.IsCellular))
{
ServiceFlags flags = DownloadsDatabase.Flags;
if (!flags.HasFlag(ServiceFlags.FlagsDownloadOverCellular))
{
this.Status = DownloadStatus.QueuedForWifi;
this.Control = ControlAction.Paused;
}
}
}
}
}
private void ComposeNetworkData()
{
m_Networks = new List<NetworkInfo>();
var networks = new List<XenAPI.Network>(Connection.Cache.Networks);
networks.Sort();
foreach (XenAPI.Network network in networks)
{
if (Cancelling)
throw new CancelledException();
// CA-218956 - Expose HIMN when showing hidden objects
if (network.IsGuestInstallerNetwork && !XenAdmin.Properties.Settings.Default.ShowHiddenVMs)
{
PercentComplete = Convert.ToInt32((++itemIndex) * baseIndex / itemCount);
continue;
}
List<PIF> pifs = network.Connection.ResolveAll(network.PIFs);
string type;
if (Cancelling)
throw new CancelledException();
if (network.IsBond)
type = Messages.BOND;
else if (network.IsVLAN)
type = Messages.EXTERNAL_NETWORK;
else if (pifs.Count != 0 && pifs[0].IsPhysical)
type = Messages.BUILTIN_NETWORK;
else if (pifs.Count != 0 && pifs[0].IsTunnelAccessPIF)
type = Messages.CHIN;
else if (pifs.Count == 0)
type = Messages.SINGLE_SERVER_PRIVATE_NETWORK;
else
type = Messages.HYPHEN;
string location = "";
foreach (XenAPI.Host host in Connection.Cache.Hosts)
{
if (host.CanSeeNetwork(network))
location += host.name_label + ":" + host.uuid + ";";
}
if (location.Length == 0)
location = Messages.HYPHEN;
NetworkInfo buf;
if (pifs.Count != 0)
buf = new NetworkInfo(network.Name, Helpers.VlanString(pifs[0]), network.LinkStatusString, pifs[0].MAC, network.MTU.ToString(), type, location);
else
buf = new NetworkInfo(network.Name, Messages.HYPHEN, network.LinkStatusString, Messages.HYPHEN, network.MTU.ToString(), type, location);
m_Networks.Add(buf);
PercentComplete = Convert.ToInt32((++itemIndex) * baseIndex / itemCount);
}
}
/// <summary>
/// Updates the network type based upon the info returned from the
/// connectivity manager.
/// </summary>
/// <param name="info">
/// </param>
/// <returns>
/// The ExpansionDownloader.Service.DownloaderService+NetworkState.
/// </returns>
private NetworkState GetNetworkState(NetworkInfo info)
{
var state = NetworkState.Disconnected;
switch (info.Type)
{
case ConnectivityType.Wifi:
#if __ANDROID_13__
case ConnectivityType.Ethernet:
case ConnectivityType.Bluetooth:
#endif
break;
case ConnectivityType.Wimax:
state = NetworkState.Is3G | NetworkState.Is4G | NetworkState.IsCellular;
break;
case ConnectivityType.Mobile:
state = NetworkState.IsCellular;
switch ((NetworkType)info.Subtype)
{
case NetworkType.OneXrtt:
case NetworkType.Cdma:
case NetworkType.Edge:
case NetworkType.Gprs:
case NetworkType.Iden:
break;
case NetworkType.Hsdpa:
case NetworkType.Hsupa:
case NetworkType.Hspa:
case NetworkType.Evdo0:
case NetworkType.EvdoA:
case NetworkType.Umts:
state |= NetworkState.Is3G;
break;
#if __ANDROID_11__
case NetworkType.Lte:
case NetworkType.Ehrpd:
state |= NetworkState.Is3G | NetworkState.Is4G;
break;
#endif
#if __ANDROID_13__
case NetworkType.Hspap:
state |= NetworkState.Is3G | NetworkState.Is4G;
break;
#endif
}
break;
}
return state;
}
/// <summary>
/// Computes Hessian matrix - outputs from computin can be accessed by GradientMat and HessianMat properties
/// </summary>
/// <param name="info">NetworkInfo - info about network</param>
public Hessian(ref NetworkInfo info)
{
}
