管理网络使用

本课程介绍如何编写对网络资源的使用具有细粒度控制的应用。如果您的应用执行大量网络操作，您应该提供用户设置，让用户可以控制您的应用的数据习惯，例如您的应用同步数据的频率，是否只在 Wi-Fi 网络下执行上传/下载，是否在漫游时使用数据，等等。有了这些控制功能，用户更有可能在接近数据限制时不会禁用您的应用访问后台数据，因为他们可以精确地控制您的应用使用多少数据。

要详细了解您的应用的网络使用情况，包括一段时间内的网络连接数量和类型，请阅读 网络应用 和 使用网络分析器检查网络流量。有关如何编写最大限度地减少下载和网络连接对电池寿命影响的应用的通用指南，请参阅 优化电池寿命 和 传输数据而不耗尽电池.

您还可以查看 NetworkConnect 示例.

检查设备的网络连接

设备可以有多种类型的网络连接。本课程重点介绍如何使用 Wi-Fi 或移动网络连接。有关所有可能的网络类型的完整列表，请参阅 ConnectivityManager.

Wi-Fi 通常更快。此外，移动数据通常是计量的，这可能会很昂贵。应用的常见策略是仅在 Wi-Fi 网络可用时才获取大型数据。

在执行网络操作之前，最好检查网络连接状态。除其他事项外，这可以防止您的应用无意中使用错误的无线电。如果网络连接不可用，您的应用应该优雅地响应。要检查网络连接，您通常使用以下类

• ConnectivityManager: 回答有关网络连接状态的查询。它还在网络连接发生变化时通知应用。
• NetworkInfo: 描述给定类型（目前为移动或 Wi-Fi）的网络接口的状态。

此代码片段测试 Wi-Fi 和移动网络的网络连接。它确定这些网络接口是否可用（即，网络连接是否可能）和/或已连接（即，网络连接是否存在，以及是否可以建立套接字并传递数据）

private const val DEBUG_TAG = "NetworkStatusExample"
...
val connMgr = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
var isWifiConn: Boolean = false
var isMobileConn: Boolean = false
connMgr.allNetworks.forEach { network ->
    connMgr.getNetworkInfo(network).apply {
        if (type == ConnectivityManager.TYPE_WIFI) {
            isWifiConn = isWifiConn or isConnected
        }
        if (type == ConnectivityManager.TYPE_MOBILE) {
            isMobileConn = isMobileConn or isConnected
        }
    }
}
Log.d(DEBUG_TAG, "Wifi connected: $isWifiConn")
Log.d(DEBUG_TAG, "Mobile connected: $isMobileConn")

private static final String DEBUG_TAG = "NetworkStatusExample";
...
ConnectivityManager connMgr =
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
boolean isWifiConn = false;
boolean isMobileConn = false;
for (Network network : connMgr.getAllNetworks()) {
    NetworkInfo networkInfo = connMgr.getNetworkInfo(network);
    if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
        isWifiConn |= networkInfo.isConnected();
    }
    if (networkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
        isMobileConn |= networkInfo.isConnected();
    }
}
Log.d(DEBUG_TAG, "Wifi connected: " + isWifiConn);
Log.d(DEBUG_TAG, "Mobile connected: " + isMobileConn);

请注意，您不应该根据网络是否“可用”来做出决定。在执行网络操作之前，您应该始终检查 isConnected()，因为 isConnected() 处理诸如不稳定的移动网络、飞行模式和受限的后台数据之类的案例。

检查网络接口是否可用的更简洁方法如下。方法 getActiveNetworkInfo() 返回一个 NetworkInfo 实例，该实例表示它能找到的第一个已连接的网络接口，如果没有任何接口连接（意味着没有可用的互联网连接），则返回 null。

fun isOnline(): Boolean {
    val connMgr = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val networkInfo: NetworkInfo? = connMgr.activeNetworkInfo
    return networkInfo?.isConnected == true
}

public boolean isOnline() {
    ConnectivityManager connMgr = (ConnectivityManager)
            getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
    return (networkInfo != null && networkInfo.isConnected());
}

要查询更细粒度的状态，可以使用 NetworkInfo.DetailedState，但这很少需要。

管理网络使用

您可以实现一个偏好设置活动，让用户显式控制您的应用程序对网络资源的使用。例如

• 您可能允许用户仅在设备连接到 Wi-Fi 网络时上传视频。
• 您可能根据特定的标准（如网络可用性、时间间隔等）进行同步（或不进行同步）。

要编写支持网络访问和管理网络使用的应用程序，您的清单必须具有正确的权限和意图过滤器。

• 本节后面摘录的清单包含以下权限
  • android.permission.INTERNET — 允许应用程序打开网络套接字。
  • android.permission.ACCESS_NETWORK_STATE — 允许应用程序访问有关网络的信息。
• 您可以为 ACTION_MANAGE_NETWORK_USAGE 操作声明意图过滤器，以指示您的应用程序定义了一个提供控制数据使用选项的活动。 ACTION_MANAGE_NETWORK_USAGE 显示用于管理特定应用程序的网络数据使用的设置。当您的应用程序具有允许用户控制网络使用的设置活动时，您应该为此活动声明此意图过滤器。

在示例应用程序中，此操作由类 SettingsActivity 处理，该类显示一个偏好设置 UI，让用户决定何时下载提要。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.android.networkusage"
    ...>

    <uses-sdk android:minSdkVersion="4"
           android:targetSdkVersion="14" />

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    <application
        ...>
        ...
        <activity android:label="SettingsActivity" android:name=".SettingsActivity">
             <intent-filter>
                <action android:name="android.intent.action.MANAGE_NETWORK_USAGE" />
                <category android:name="android.intent.category.DEFAULT" />
          </intent-filter>
        </activity>
    </application>
</manifest>

处理敏感用户数据的应用程序以及面向 Android 11 及更高版本的应用程序可以授予每个进程的网络访问权限。通过明确指定允许哪些进程访问网络，您可以隔离所有不需要上传数据的代码。

虽然不能保证防止您的应用程序意外上传数据，但它确实为您提供了一种减少应用程序中错误导致数据泄露的可能性。

以下是使用每个进程功能的清单文件的示例

<processes>
    <process />
    <deny-permission android:name="android.permission.INTERNET" />
    <process android:process=":withoutnet1" />
    <process android:process="com.android.cts.useprocess.withnet1">
        <allow-permission android:name="android.permission.INTERNET" />
    </process>
    <allow-permission android:name="android.permission.INTERNET" />
    <process android:process=":withoutnet2">
        <deny-permission android:name="android.permission.INTERNET" />
    </process>
    <process android:process="com.android.cts.useprocess.withnet2" />
</processes>

实现一个偏好设置活动

正如您在本主题前面摘录的清单中所看到的，示例应用程序的活动 SettingsActivity 具有用于 ACTION_MANAGE_NETWORK_USAGE 操作的意图过滤器。 SettingsActivity 是 PreferenceActivity 的子类。它显示一个偏好设置屏幕（如图 1 所示），允许用户指定以下内容

• 是否为每个 XML 提要条目显示摘要，或仅为每个条目显示链接。
• 是否在任何网络连接可用时下载 XML 提要，或者仅在 Wi-Fi 可用时下载。

图 1. 偏好设置活动。

以下是 SettingsActivity。请注意，它实现了 OnSharedPreferenceChangeListener。当用户更改偏好设置时，它会触发 onSharedPreferenceChanged()，这会将 refreshDisplay 设置为 true。这会导致用户返回主活动时显示内容刷新。

class SettingsActivity : PreferenceActivity(), OnSharedPreferenceChangeListener {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Loads the XML preferences file
        addPreferencesFromResource(R.xml.preferences)
    }

    override fun onResume() {
        super.onResume()

        // Registers a listener whenever a key changes
        preferenceScreen?.sharedPreferences?.registerOnSharedPreferenceChangeListener(this)
    }

    override fun onPause() {
        super.onPause()

        // Unregisters the listener set in onResume().
        // It's best practice to unregister listeners when your app isn't using them to cut down on
        // unnecessary system overhead. You do this in onPause().
        preferenceScreen?.sharedPreferences?.unregisterOnSharedPreferenceChangeListener(this)
    }

    // When the user changes the preferences selection,
    // onSharedPreferenceChanged() restarts the main activity as a new
    // task. Sets the refreshDisplay flag to "true" to indicate that
    // the main activity should update its display.
    // The main activity queries the PreferenceManager to get the latest settings.

    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String) {
        // Sets refreshDisplay to true so that when the user returns to the main
        // activity, the display refreshes to reflect the new settings.
        NetworkActivity.refreshDisplay = true
    }
}

public class SettingsActivity extends PreferenceActivity implements OnSharedPreferenceChangeListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Loads the XML preferences file
        addPreferencesFromResource(R.xml.preferences);
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Registers a listener whenever a key changes
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    protected void onPause() {
        super.onPause();

       // Unregisters the listener set in onResume().
       // It's best practice to unregister listeners when your app isn't using them to cut down on
       // unnecessary system overhead. You do this in onPause().
       getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
    }

    // When the user changes the preferences selection,
    // onSharedPreferenceChanged() restarts the main activity as a new
    // task. Sets the refreshDisplay flag to "true" to indicate that
    // the main activity should update its display.
    // The main activity queries the PreferenceManager to get the latest settings.

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        // Sets refreshDisplay to true so that when the user returns to the main
        // activity, the display refreshes to reflect the new settings.
        NetworkActivity.refreshDisplay = true;
    }
}

响应偏好设置更改

当用户在设置屏幕中更改偏好设置时，它通常会对应用程序的行为产生影响。在此代码段中，应用程序在 onStart() 中检查偏好设置设置。如果设置和设备的网络连接之间存在匹配（例如，如果设置是 "Wi-Fi" 并且设备具有 Wi-Fi 连接），应用程序将下载提要并刷新显示内容。

class NetworkActivity : Activity() {

    // The BroadcastReceiver that tracks network connectivity changes.
    private lateinit var receiver: NetworkReceiver

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Registers BroadcastReceiver to track network connection changes.
        val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
        receiver = NetworkReceiver()
        this.registerReceiver(receiver, filter)
    }

    public override fun onDestroy() {
        super.onDestroy()
        // Unregisters BroadcastReceiver when app is destroyed.
        this.unregisterReceiver(receiver)
    }

    // Refreshes the display if the network connection and the
    // pref settings allow it.

    public override fun onStart() {
        super.onStart()

        // Gets the user's network preference settings
        val sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this)

        // Retrieves a string value for the preferences. The second parameter
        // is the default value to use if a preference value is not found.
        sPref = sharedPrefs.getString("listPref", "Wi-Fi")

        updateConnectedFlags()

        if (refreshDisplay) {
            loadPage()
        }
    }

    // Checks the network connection and sets the wifiConnected and mobileConnected
    // variables accordingly.
    fun updateConnectedFlags() {
        val connMgr = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

        val activeInfo: NetworkInfo? = connMgr.activeNetworkInfo
        if (activeInfo?.isConnected == true) {
            wifiConnected = activeInfo.type == ConnectivityManager.TYPE_WIFI
            mobileConnected = activeInfo.type == ConnectivityManager.TYPE_MOBILE
        } else {
            wifiConnected = false
            mobileConnected = false
        }
    }

    // Uses AsyncTask subclass to download the XML feed from stackoverflow.com.
    fun loadPage() {
        if (sPref == ANY && (wifiConnected || mobileConnected) || sPref == WIFI && wifiConnected) {
            // AsyncTask subclass
            DownloadXmlTask().execute(URL)
        } else {
            showErrorPage()
        }
    }

    companion object {

        const val WIFI = "Wi-Fi"
        const val ANY = "Any"
        const val SO_URL = "http://stackoverflow.com/feeds/tag?tagnames=android&sort;=newest"

        // Whether there is a Wi-Fi connection.
        private var wifiConnected = false
        // Whether there is a mobile connection.
        private var mobileConnected = false
        // Whether the display should be refreshed.
        var refreshDisplay = true

        // The user's current network preference setting.
        var sPref: String? = null
    }
...

}

public class NetworkActivity extends Activity {
    public static final String WIFI = "Wi-Fi";
    public static final String ANY = "Any";
    private static final String URL = "http://stackoverflow.com/feeds/tag?tagnames=android&sort;=newest";

    // Whether there is a Wi-Fi connection.
    private static boolean wifiConnected = false;
    // Whether there is a mobile connection.
    private static boolean mobileConnected = false;
    // Whether the display should be refreshed.
    public static boolean refreshDisplay = true;

    // The user's current network preference setting.
    public static String sPref = null;

    // The BroadcastReceiver that tracks network connectivity changes.
    private NetworkReceiver receiver = new NetworkReceiver();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Registers BroadcastReceiver to track network connection changes.
        IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
        receiver = new NetworkReceiver();
        this.registerReceiver(receiver, filter);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // Unregisters BroadcastReceiver when app is destroyed.
        if (receiver != null) {
            this.unregisterReceiver(receiver);
        }
    }

    // Refreshes the display if the network connection and the
    // pref settings allow it.

    @Override
    public void onStart () {
        super.onStart();

        // Gets the user's network preference settings
        SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);

        // Retrieves a string value for the preferences. The second parameter
        // is the default value to use if a preference value is not found.
        sPref = sharedPrefs.getString("listPref", "Wi-Fi");

        updateConnectedFlags();

        if(refreshDisplay){
            loadPage();
        }
    }

    // Checks the network connection and sets the wifiConnected and mobileConnected
    // variables accordingly.
    public void updateConnectedFlags() {
        ConnectivityManager connMgr = (ConnectivityManager)
                getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo activeInfo = connMgr.getActiveNetworkInfo();
        if (activeInfo != null && activeInfo.isConnected()) {
            wifiConnected = activeInfo.getType() == ConnectivityManager.TYPE_WIFI;
            mobileConnected = activeInfo.getType() == ConnectivityManager.TYPE_MOBILE;
        } else {
            wifiConnected = false;
            mobileConnected = false;
        }
    }

    // Uses AsyncTask subclass to download the XML feed from stackoverflow.com.
    public void loadPage() {
        if (((sPref.equals(ANY)) && (wifiConnected || mobileConnected))
                || ((sPref.equals(WIFI)) && (wifiConnected))) {
            // AsyncTask subclass
            new DownloadXmlTask().execute(URL);
        } else {
            showErrorPage();
        }
    }
...

}

检测连接更改

拼图的最后一块是 BroadcastReceiver 子类 NetworkReceiver。当设备的网络连接发生变化时，NetworkReceiver 会截取操作 CONNECTIVITY_ACTION，确定网络连接状态是什么，并相应地将标志 wifiConnected 和 mobileConnected 设置为 true/false。最终结果是，用户下次返回应用程序时，应用程序只会在 NetworkActivity.refreshDisplay 设置为 true 的情况下下载最新的提要并更新显示内容。

设置一个不必要调用的 BroadcastReceiver 会消耗系统资源。示例应用程序在 onCreate() 中注册 BroadcastReceiver NetworkReceiver，并在 onDestroy() 中取消注册。这比在清单中声明 <receiver> 更轻量级。当您在清单中声明 <receiver> 时，它可以随时唤醒您的应用程序，即使您已经好几周没有运行它了。通过在主活动中注册和取消注册 NetworkReceiver，您可以确保在用户离开应用程序后，应用程序不会被唤醒。如果您确实在清单中声明了 <receiver> 并且您确切地知道在哪里需要它，您可以使用 setComponentEnabledSetting() 在适当的时候启用和禁用它。

以下是 NetworkReceiver

class NetworkReceiver : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        val conn = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val networkInfo: NetworkInfo? = conn.activeNetworkInfo

        // Checks the user prefs and the network connection. Based on the result, decides whether
        // to refresh the display or keep the current display.
        // If the userpref is Wi-Fi only, checks to see if the device has a Wi-Fi connection.
        if (WIFI == sPref && networkInfo?.type == ConnectivityManager.TYPE_WIFI) {
            // If device has its Wi-Fi connection, sets refreshDisplay
            // to true. This causes the display to be refreshed when the user
            // returns to the app.
            refreshDisplay = true
            Toast.makeText(context, R.string.wifi_connected, Toast.LENGTH_SHORT).show()

            // If the setting is ANY network and there is a network connection
            // (which by process of elimination would be mobile), sets refreshDisplay to true.
        } else if (ANY == sPref && networkInfo != null) {
            refreshDisplay = true

            // Otherwise, the app can't download content--either because there is no network
            // connection (mobile or Wi-Fi), or because the pref setting is WIFI, and there
            // is no Wi-Fi connection.
            // Sets refreshDisplay to false.
        } else {
            refreshDisplay = false
            Toast.makeText(context, R.string.lost_connection, Toast.LENGTH_SHORT).show()
        }
    }
}

public class NetworkReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        ConnectivityManager conn =  (ConnectivityManager)
            context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = conn.getActiveNetworkInfo();

        // Checks the user prefs and the network connection. Based on the result, decides whether
        // to refresh the display or keep the current display.
        // If the userpref is Wi-Fi only, checks to see if the device has a Wi-Fi connection.
        if (WIFI.equals(sPref) && networkInfo != null
            && networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
            // If device has its Wi-Fi connection, sets refreshDisplay
            // to true. This causes the display to be refreshed when the user
            // returns to the app.
            refreshDisplay = true;
            Toast.makeText(context, R.string.wifi_connected, Toast.LENGTH_SHORT).show();

        // If the setting is ANY network and there is a network connection
        // (which by process of elimination would be mobile), sets refreshDisplay to true.
        } else if (ANY.equals(sPref) && networkInfo != null) {
            refreshDisplay = true;

        // Otherwise, the app can't download content--either because there is no network
        // connection (mobile or Wi-Fi), or because the pref setting is WIFI, and there
        // is no Wi-Fi connection.
        // Sets refreshDisplay to false.
        } else {
            refreshDisplay = false;
            Toast.makeText(context, R.string.lost_connection, Toast.LENGTH_SHORT).show();
        }
    }
}