- Web and HTTP
- HomeGroup
- Connectivity and Data Plans
- Sockets
- Proximity (Near Field Communications)
- Background Transfers
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
Connectivity and Data Plans
Windows Store apps can be connected in a number of ways. Although traditional wired connections (Ethernet LAN) and Wireless Fidelity (Wi-Fi) connections (also known as wireless local area connections, or WLAN) are still popular, many devices offer wireless wide area network (WWAN) connections over cellular technologies such as Global System for Mobile Communications (GSM) and Long Term Evolution (LTE). Many of these data plans have data limits and may charge for bandwidth usage. If users roam outside their regular coverage area, they could incur additional charges.
Windows Store apps should be aware of the type of connection they are using to access information over the Internet so they can implement specific behaviors that are suitable for the type of connection. An app might consider implementing this typical set of behaviors:
- Offline—The app cannot connect to the Internet and must rely on local cached data to function.
- High Cost—The app is connected to the Internet, but the data plan is either roaming, approaching a fixed data limit, or over the data limit and, therefore, might incur additional charges. The app should limit network activity to only extremely low bandwidth scenarios (such as loading a set of headers but deferring the details).
- Conservative—The app is connected to the Internet over a metered connection. Downloading data is fine but should be done only as needed and based on user-configurable preferences (the user must have a way to disable large downloads when the connection is metered). Lower-resolution images and lesser-bandwidth movies should be used when available.
- Standard—The app is connected to the Internet, and no charges appear to be associated with data usage; therefore, the application can download or upload data as needed.
The Windows.Networking.Connectivity namespace contains the APIs necessary to determine the types of connections that are available and examine data plans and usage. You interact with the NetworkInformation class to determine the available connections, the connection your app will use to access the Internet, and what type of connection is being used. The example app that demonstrates this API is called NetworkInfoExample; you can find it in the Chapter 10 solution folder.
Each network that your device either is currently connected to or has connected to in the past (as long as you did not ask Windows to forget the connection) has a ConnectionProfile instance associated with it. The UpdateNetworkInformation method in the ViewModel class in the Data folder demonstrates how to access this API. A simple call retrieves the full list of available profiles:
var profiles = NetworkInformation.GetConnectionProfiles();
You can iterate the various profiles and acquire information from each of them, but the most interesting profile is the one used to gain access to the Internet. You can use the GetInternetConnectionProfile call to get the profile associated with the active connection, if one exists. If the result is null, the user is not currently connected. In the example app, this call is used to get the identifier for the network adapter that is being used to connect and then select that connection from the list. If your connection is bridged for any reason (for example, you might be running Hyper-V virtual machines that use virtual adapters to connect to your wireless connection), the bridged connection might show up as the active connection instead of the connection you were expecting.
The ConnectionProfile has a name that matches what you see in the various network dialogs (either the list of available connections from the Control Panel or the list of networks in the Networks flyout accessed from the Charms bar). It indicates whether the network is a WLAN (wireless) or a WWAN (wide area network or cellular) connection. If it is neither, it is likely a wired Ethernet or Bluetooth connection.
You can quickly access information about the connected network adapter, as well as the security settings for the connection. For example, the wireless access point I run in my house uses RSNA-PSK authentication with CCMP encryption. You might have security settings available for both wired and wireless networks. The FromConnectionProfile method on the ConnectionInfo class demonstrates how these values are obtained.
if (profile.NetworkSecuritySettings != null)
{
connectionInfo.AuthenticationType = profile
.NetworkSecuritySettings.NetworkAuthenticationType.ToString();
connectionInfo.EncryptionType = profile
.NetworkSecuritySettings.NetworkEncryptionType.ToString();
}
Other information is available through method calls. To get the signal strength from the connection (a value that ranges from 0 for no signal to 5 for maximum signal strength), you call the GetSignalBars method. The example app shows only four of five possible bars because it uses the built-in symbol library, and that provides only four bars.
connectionInfo.SignalBars = profile.GetSignalBars();
The main reason for examining the connection is likely to understand whether costs are associated with it. To find out, call the GetConnectionCost method. This returns a class that contains an enumeration and several flags. The enumeration provides you with details about how the connection is metered.
- Unrestricted—No costs are associated with data usage.
- Fixed—A data limit exists; until that limit is reached, usage is unrestricted.
- Variable—Data usage is charged on a per-byte basis.
- Unknown—No cost information is available for the connection.
Additional flags provide further insights into the current plan:
- Roaming—This flag is set when the user is outside the normal usage area. You can assume that additional charges will apply.
- ApproachingDataLimit—The plan has almost reached its limit; additional costs might be incurred.
- OverDataLimit—The plan has exceeded the data limit, and the user is likely being charged for any additional usage.
Use this information to strategize how you will access the Internet from your Windows Store app. When the type is fixed or variable, you should follow a conservative behavior. When the flags indicate that the connection is roaming or over the data limit, you should implement the high-cost behavior and allow the user to opt in to any data usage. Other scenarios can follow the standard or offline behavior, depending on the status of the connection.
If you need to find out more details about the plan, you can call the GetDataPlanStatus method, as shown in the FromProfile method on the DataPlanInfo class in the example app. The result gives you more details when available, including the data limit and how much has been used against the limit, the available speeds of the connection, and even when the next billing cycle begins so you know when the usage is reset.
You can also query for historical usage of any connection. The GetNetworkUsageAsync method enables you to specify a time range and a sample frequency (increments in minutes, hours, or days, or a total for the time period). Depending on how you call the method, you can get a list of NetworkUsage instances for each data sample. If you requested hourly samples, each instance represents a sample taken for a given hour. The instance contains the duration it represents, along with the bytes received and sent during that period. The ConnectionInfo class in the example app retrieves a total for the previous day:
var usage =
await profile.GetNetworkUsageAsync(
DateTimeOffset.Now.AddDays(-1),
DateTimeOffset.Now,
DataUsageGranularity.Total,
new NetworkUsageStates { Roaming = TriStates.DoNotCare,
Shared = TriStates.DoNotCare });
You might not sample data earlier than 60 days before the current date (about 2 months), and minute granularity is available for only the previous 2 hours. You can also specify what network states you want to sample. You can restrict the data to times when the connection was roaming or part of a shared connection, or indicate that you “do not care,” as in the example code.
The advantage of many Windows 8.1 devices is that they are highly mobile. For this reason, it’s common for the current active connection to change frequently. The user might be using a cellular connection and might come into range of a wireless connection that is lower cost, or the user might travel and switch to different connections. The NetworkInformation class raises an event when the current connection status changes. The ViewModel class in the example app registers for this event:
NetworkInformation.NetworkStatusChanged +=
this.NetworkInformationNetworkStatusChanged;
The event itself does not provide other information. The typical practice is to query for the current Internet connection again to determine whether the app behavior should change. You can prompt the user or restrict data usage when you find that the user has roamed or moved from an unrestricted connection to a metered one. By default, Windows 8.1 prefers unrestricted networks over metered networks and automatically connects to the fastest available network in its category when multiple choices are available.