blob: a69b38d0d96d21401bd13e521362b39aa5ad1d3d [file] [log] [blame]
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.net;
import static android.annotation.SystemApi.Client.MODULE_LIBRARIES;
import android.annotation.NonNull;
import android.annotation.SuppressLint;
import android.annotation.SystemApi;
import android.annotation.TestApi;
import android.app.DownloadManager;
import android.app.backup.BackupManager;
import android.app.usage.NetworkStatsManager;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.Context;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.Build;
import android.os.RemoteException;
import android.os.StrictMode;
import android.util.Log;
import java.io.FileDescriptor;
import java.io.IOException;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;
/**
* Class that provides network traffic statistics. These statistics include
* bytes transmitted and received and network packets transmitted and received,
* over all interfaces, over the mobile interface, and on a per-UID basis.
* <p>
* These statistics may not be available on all platforms. If the statistics are
* not supported by this device, {@link #UNSUPPORTED} will be returned.
* <p>
* Note that the statistics returned by this class reset and start from zero
* after every reboot. To access more robust historical network statistics data,
* use {@link NetworkStatsManager} instead.
*/
public class TrafficStats {
static {
System.loadLibrary("framework-connectivity-tiramisu-jni");
}
private static final String TAG = TrafficStats.class.getSimpleName();
/**
* The return value to indicate that the device does not support the statistic.
*/
public final static int UNSUPPORTED = -1;
/** @hide @deprecated use {@code DataUnit} instead to clarify SI-vs-IEC */
@Deprecated
public static final long KB_IN_BYTES = 1024;
/** @hide @deprecated use {@code DataUnit} instead to clarify SI-vs-IEC */
@Deprecated
public static final long MB_IN_BYTES = KB_IN_BYTES * 1024;
/** @hide @deprecated use {@code DataUnit} instead to clarify SI-vs-IEC */
@Deprecated
public static final long GB_IN_BYTES = MB_IN_BYTES * 1024;
/** @hide @deprecated use {@code DataUnit} instead to clarify SI-vs-IEC */
@Deprecated
public static final long TB_IN_BYTES = GB_IN_BYTES * 1024;
/** @hide @deprecated use {@code DataUnit} instead to clarify SI-vs-IEC */
@Deprecated
public static final long PB_IN_BYTES = TB_IN_BYTES * 1024;
/**
* Special UID value used when collecting {@link NetworkStatsHistory} for
* removed applications.
*
* @hide
*/
public static final int UID_REMOVED = -4;
/**
* Special UID value used when collecting {@link NetworkStatsHistory} for
* tethering traffic.
*
* @hide
*/
public static final int UID_TETHERING = NetworkStats.UID_TETHERING;
/**
* Tag values in this range are reserved for the network stack. The network stack is
* running as UID {@link android.os.Process.NETWORK_STACK_UID} when in the mainline
* module separate process, and as the system UID otherwise.
*/
/** @hide */
@SystemApi
public static final int TAG_NETWORK_STACK_RANGE_START = 0xFFFFFD00;
/** @hide */
@SystemApi
public static final int TAG_NETWORK_STACK_RANGE_END = 0xFFFFFEFF;
/**
* Tags between 0xFFFFFF00 and 0xFFFFFFFF are reserved and used internally by system services
* like DownloadManager when performing traffic on behalf of an application.
*/
// Please note there is no enforcement of these constants, so do not rely on them to
// determine that the caller is a system caller.
/** @hide */
@SystemApi
public static final int TAG_SYSTEM_IMPERSONATION_RANGE_START = 0xFFFFFF00;
/** @hide */
@SystemApi
public static final int TAG_SYSTEM_IMPERSONATION_RANGE_END = 0xFFFFFF0F;
/**
* Tag values between these ranges are reserved for the network stack to do traffic
* on behalf of applications. It is a subrange of the range above.
*/
/** @hide */
@SystemApi
public static final int TAG_NETWORK_STACK_IMPERSONATION_RANGE_START = 0xFFFFFF80;
/** @hide */
@SystemApi
public static final int TAG_NETWORK_STACK_IMPERSONATION_RANGE_END = 0xFFFFFF8F;
/**
* Default tag value for {@link DownloadManager} traffic.
*
* @hide
*/
public static final int TAG_SYSTEM_DOWNLOAD = 0xFFFFFF01;
/**
* Default tag value for {@link MediaPlayer} traffic.
*
* @hide
*/
public static final int TAG_SYSTEM_MEDIA = 0xFFFFFF02;
/**
* Default tag value for {@link BackupManager} backup traffic; that is,
* traffic from the device to the storage backend.
*
* @hide
*/
public static final int TAG_SYSTEM_BACKUP = 0xFFFFFF03;
/**
* Default tag value for {@link BackupManager} restore traffic; that is,
* app data retrieved from the storage backend at install time.
*
* @hide
*/
public static final int TAG_SYSTEM_RESTORE = 0xFFFFFF04;
/**
* Default tag value for code (typically APKs) downloaded by an app store on
* behalf of the app, such as updates.
*
* @hide
*/
public static final int TAG_SYSTEM_APP = 0xFFFFFF05;
// TODO : remove this constant when Wifi code is updated
/** @hide */
public static final int TAG_SYSTEM_PROBE = 0xFFFFFF42;
private static INetworkStatsService sStatsService;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 130143562)
private synchronized static INetworkStatsService getStatsService() {
if (sStatsService == null) {
throw new IllegalStateException("TrafficStats not initialized, uid="
+ Binder.getCallingUid());
}
return sStatsService;
}
/**
* Snapshot of {@link NetworkStats} when the currently active profiling
* session started, or {@code null} if no session active.
*
* @see #startDataProfiling(Context)
* @see #stopDataProfiling(Context)
*/
private static NetworkStats sActiveProfilingStart;
private static Object sProfilingLock = new Object();
private static final String LOOPBACK_IFACE = "lo";
/**
* Initialization {@link TrafficStats} with the context, to
* allow {@link TrafficStats} to fetch the needed binder.
*
* @param context a long-lived context, such as the application context or system
* server context.
* @hide
*/
@SystemApi(client = MODULE_LIBRARIES)
@SuppressLint("VisiblySynchronized")
public static synchronized void init(@NonNull final Context context) {
if (sStatsService != null) {
throw new IllegalStateException("TrafficStats is already initialized, uid="
+ Binder.getCallingUid());
}
final NetworkStatsManager statsManager =
context.getSystemService(NetworkStatsManager.class);
if (statsManager == null) {
// TODO: Currently Process.isSupplemental is not working yet, because it depends on
// process to run in a certain UID range, which is not true for now. Change this
// to Log.wtf once Process.isSupplemental is ready.
Log.e(TAG, "TrafficStats not initialized, uid=" + Binder.getCallingUid());
return;
}
sStatsService = statsManager.getBinder();
}
/**
* Attach the socket tagger implementation to the current process, to
* get notified when a socket's {@link FileDescriptor} is assigned to
* a thread. See {@link SocketTagger#set(SocketTagger)}.
*
* @hide
*/
@SystemApi(client = MODULE_LIBRARIES)
public static void attachSocketTagger() {
dalvik.system.SocketTagger.set(new SocketTagger());
}
private static class SocketTagger extends dalvik.system.SocketTagger {
// TODO: set to false
private static final boolean LOGD = true;
SocketTagger() {
}
@Override
public void tag(FileDescriptor fd) throws SocketException {
final UidTag tagInfo = sThreadUidTag.get();
if (LOGD) {
Log.d(TAG, "tagSocket(" + fd.getInt$() + ") with statsTag=0x"
+ Integer.toHexString(tagInfo.tag) + ", statsUid=" + tagInfo.uid);
}
if (tagInfo.tag == -1) {
StrictMode.noteUntaggedSocket();
}
if (tagInfo.tag == -1 && tagInfo.uid == -1) return;
final int errno = native_tagSocketFd(fd, tagInfo.tag, tagInfo.uid);
if (errno < 0) {
Log.i(TAG, "tagSocketFd(" + fd.getInt$() + ", "
+ tagInfo.tag + ", "
+ tagInfo.uid + ") failed with errno" + errno);
}
}
@Override
public void untag(FileDescriptor fd) throws SocketException {
if (LOGD) {
Log.i(TAG, "untagSocket(" + fd.getInt$() + ")");
}
final UidTag tagInfo = sThreadUidTag.get();
if (tagInfo.tag == -1 && tagInfo.uid == -1) return;
final int errno = native_untagSocketFd(fd);
if (errno < 0) {
Log.w(TAG, "untagSocket(" + fd.getInt$() + ") failed with errno " + errno);
}
}
}
private static native int native_tagSocketFd(FileDescriptor fd, int tag, int uid);
private static native int native_untagSocketFd(FileDescriptor fd);
private static class UidTag {
public int tag = -1;
public int uid = -1;
}
private static ThreadLocal<UidTag> sThreadUidTag = new ThreadLocal<UidTag>() {
@Override
protected UidTag initialValue() {
return new UidTag();
}
};
/**
* Set active tag to use when accounting {@link Socket} traffic originating
* from the current thread. Only one active tag per thread is supported.
* <p>
* Changes only take effect during subsequent calls to
* {@link #tagSocket(Socket)}.
* <p>
* Tags between {@code 0xFFFFFF00} and {@code 0xFFFFFFFF} are reserved and
* used internally by system services like {@link DownloadManager} when
* performing traffic on behalf of an application.
*
* @see #clearThreadStatsTag()
*/
public static void setThreadStatsTag(int tag) {
getAndSetThreadStatsTag(tag);
}
/**
* Set active tag to use when accounting {@link Socket} traffic originating
* from the current thread. Only one active tag per thread is supported.
* <p>
* Changes only take effect during subsequent calls to
* {@link #tagSocket(Socket)}.
* <p>
* Tags between {@code 0xFFFFFF00} and {@code 0xFFFFFFFF} are reserved and
* used internally by system services like {@link DownloadManager} when
* performing traffic on behalf of an application.
*
* @return the current tag for the calling thread, which can be used to
* restore any existing values after a nested operation is finished
*/
public static int getAndSetThreadStatsTag(int tag) {
final int old = sThreadUidTag.get().tag;
sThreadUidTag.get().tag = tag;
return old;
}
/**
* Set active tag to use when accounting {@link Socket} traffic originating
* from the current thread. The tag used internally is well-defined to
* distinguish all backup-related traffic.
*
* @hide
*/
@SystemApi
public static void setThreadStatsTagBackup() {
setThreadStatsTag(TAG_SYSTEM_BACKUP);
}
/**
* Set active tag to use when accounting {@link Socket} traffic originating
* from the current thread. The tag used internally is well-defined to
* distinguish all restore-related traffic.
*
* @hide
*/
@SystemApi
public static void setThreadStatsTagRestore() {
setThreadStatsTag(TAG_SYSTEM_RESTORE);
}
/**
* Set active tag to use when accounting {@link Socket} traffic originating
* from the current thread. The tag used internally is well-defined to
* distinguish all code (typically APKs) downloaded by an app store on
* behalf of the app, such as updates.
*
* @hide
*/
@SystemApi
public static void setThreadStatsTagApp() {
setThreadStatsTag(TAG_SYSTEM_APP);
}
/**
* Set active tag to use when accounting {@link Socket} traffic originating
* from the current thread. The tag used internally is well-defined to
* distinguish all download provider traffic.
*
* @hide
*/
@SystemApi(client = MODULE_LIBRARIES)
public static void setThreadStatsTagDownload() {
setThreadStatsTag(TAG_SYSTEM_DOWNLOAD);
}
/**
* Get the active tag used when accounting {@link Socket} traffic originating
* from the current thread. Only one active tag per thread is supported.
* {@link #tagSocket(Socket)}.
*
* @see #setThreadStatsTag(int)
*/
public static int getThreadStatsTag() {
return sThreadUidTag.get().tag;
}
/**
* Clear any active tag set to account {@link Socket} traffic originating
* from the current thread.
*
* @see #setThreadStatsTag(int)
*/
public static void clearThreadStatsTag() {
sThreadUidTag.get().tag = -1;
}
/**
* Set specific UID to use when accounting {@link Socket} traffic
* originating from the current thread. Designed for use when performing an
* operation on behalf of another application, or when another application
* is performing operations on your behalf.
* <p>
* Any app can <em>accept</em> blame for traffic performed on a socket
* originally created by another app by calling this method with the
* {@link android.system.Os#getuid()} value. However, only apps holding the
* {@code android.Manifest.permission#UPDATE_DEVICE_STATS} permission may
* <em>assign</em> blame to another UIDs.
* <p>
* Changes only take effect during subsequent calls to
* {@link #tagSocket(Socket)}.
*/
@SuppressLint("RequiresPermission")
public static void setThreadStatsUid(int uid) {
sThreadUidTag.get().uid = uid;
}
/**
* Get the active UID used when accounting {@link Socket} traffic originating
* from the current thread. Only one active tag per thread is supported.
* {@link #tagSocket(Socket)}.
*
* @see #setThreadStatsUid(int)
*/
public static int getThreadStatsUid() {
return sThreadUidTag.get().uid;
}
/**
* Set specific UID to use when accounting {@link Socket} traffic
* originating from the current thread as the calling UID. Designed for use
* when another application is performing operations on your behalf.
* <p>
* Changes only take effect during subsequent calls to
* {@link #tagSocket(Socket)}.
*
* @removed
* @deprecated use {@link #setThreadStatsUid(int)} instead.
*/
@Deprecated
public static void setThreadStatsUidSelf() {
setThreadStatsUid(android.os.Process.myUid());
}
/**
* Clear any active UID set to account {@link Socket} traffic originating
* from the current thread.
*
* @see #setThreadStatsUid(int)
*/
@SuppressLint("RequiresPermission")
public static void clearThreadStatsUid() {
setThreadStatsUid(-1);
}
/**
* Tag the given {@link Socket} with any statistics parameters active for
* the current thread. Subsequent calls always replace any existing
* parameters. When finished, call {@link #untagSocket(Socket)} to remove
* statistics parameters.
*
* @see #setThreadStatsTag(int)
*/
public static void tagSocket(@NonNull Socket socket) throws SocketException {
SocketTagger.get().tag(socket);
}
/**
* Remove any statistics parameters from the given {@link Socket}.
* <p>
* In Android 8.1 (API level 27) and lower, a socket is automatically
* untagged when it's sent to another process using binder IPC with a
* {@code ParcelFileDescriptor} container. In Android 9.0 (API level 28)
* and higher, the socket tag is kept when the socket is sent to another
* process using binder IPC. You can mimic the previous behavior by
* calling {@code untagSocket()} before sending the socket to another
* process.
*/
public static void untagSocket(@NonNull Socket socket) throws SocketException {
SocketTagger.get().untag(socket);
}
/**
* Tag the given {@link DatagramSocket} with any statistics parameters
* active for the current thread. Subsequent calls always replace any
* existing parameters. When finished, call
* {@link #untagDatagramSocket(DatagramSocket)} to remove statistics
* parameters.
*
* @see #setThreadStatsTag(int)
*/
public static void tagDatagramSocket(@NonNull DatagramSocket socket) throws SocketException {
SocketTagger.get().tag(socket);
}
/**
* Remove any statistics parameters from the given {@link DatagramSocket}.
*/
public static void untagDatagramSocket(@NonNull DatagramSocket socket) throws SocketException {
SocketTagger.get().untag(socket);
}
/**
* Tag the given {@link FileDescriptor} socket with any statistics
* parameters active for the current thread. Subsequent calls always replace
* any existing parameters. When finished, call
* {@link #untagFileDescriptor(FileDescriptor)} to remove statistics
* parameters.
*
* @see #setThreadStatsTag(int)
*/
public static void tagFileDescriptor(@NonNull FileDescriptor fd) throws IOException {
SocketTagger.get().tag(fd);
}
/**
* Remove any statistics parameters from the given {@link FileDescriptor}
* socket.
*/
public static void untagFileDescriptor(@NonNull FileDescriptor fd) throws IOException {
SocketTagger.get().untag(fd);
}
/**
* Start profiling data usage for current UID. Only one profiling session
* can be active at a time.
*
* @hide
*/
public static void startDataProfiling(Context context) {
synchronized (sProfilingLock) {
if (sActiveProfilingStart != null) {
throw new IllegalStateException("already profiling data");
}
// take snapshot in time; we calculate delta later
sActiveProfilingStart = getDataLayerSnapshotForUid(context);
}
}
/**
* Stop profiling data usage for current UID.
*
* @return Detailed {@link NetworkStats} of data that occurred since last
* {@link #startDataProfiling(Context)} call.
* @hide
*/
public static NetworkStats stopDataProfiling(Context context) {
synchronized (sProfilingLock) {
if (sActiveProfilingStart == null) {
throw new IllegalStateException("not profiling data");
}
// subtract starting values and return delta
final NetworkStats profilingStop = getDataLayerSnapshotForUid(context);
final NetworkStats profilingDelta = NetworkStats.subtract(
profilingStop, sActiveProfilingStart, null, null);
sActiveProfilingStart = null;
return profilingDelta;
}
}
/**
* Increment count of network operations performed under the accounting tag
* currently active on the calling thread. This can be used to derive
* bytes-per-operation.
*
* @param operationCount Number of operations to increment count by.
*/
public static void incrementOperationCount(int operationCount) {
final int tag = getThreadStatsTag();
incrementOperationCount(tag, operationCount);
}
/**
* Increment count of network operations performed under the given
* accounting tag. This can be used to derive bytes-per-operation.
*
* @param tag Accounting tag used in {@link #setThreadStatsTag(int)}.
* @param operationCount Number of operations to increment count by.
*/
public static void incrementOperationCount(int tag, int operationCount) {
final int uid = android.os.Process.myUid();
try {
getStatsService().incrementOperationCount(uid, tag, operationCount);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** {@hide} */
public static void closeQuietly(INetworkStatsSession session) {
// TODO: move to NetworkStatsService once it exists
if (session != null) {
try {
session.close();
} catch (RuntimeException rethrown) {
throw rethrown;
} catch (Exception ignored) {
}
}
}
private static long addIfSupported(long stat) {
return (stat == UNSUPPORTED) ? 0 : stat;
}
/**
* Return number of packets transmitted across mobile networks since device
* boot. Counts packets across all mobile network interfaces, and always
* increases monotonically since device boot. Statistics are measured at the
* network layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getMobileTxPackets() {
long total = 0;
for (String iface : getMobileIfaces()) {
total += addIfSupported(getTxPackets(iface));
}
return total;
}
/**
* Return number of packets received across mobile networks since device
* boot. Counts packets across all mobile network interfaces, and always
* increases monotonically since device boot. Statistics are measured at the
* network layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getMobileRxPackets() {
long total = 0;
for (String iface : getMobileIfaces()) {
total += addIfSupported(getRxPackets(iface));
}
return total;
}
/**
* Return number of bytes transmitted across mobile networks since device
* boot. Counts packets across all mobile network interfaces, and always
* increases monotonically since device boot. Statistics are measured at the
* network layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getMobileTxBytes() {
long total = 0;
for (String iface : getMobileIfaces()) {
total += addIfSupported(getTxBytes(iface));
}
return total;
}
/**
* Return number of bytes received across mobile networks since device boot.
* Counts packets across all mobile network interfaces, and always increases
* monotonically since device boot. Statistics are measured at the network
* layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getMobileRxBytes() {
long total = 0;
for (String iface : getMobileIfaces()) {
total += addIfSupported(getRxBytes(iface));
}
return total;
}
/** {@hide} */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public static long getMobileTcpRxPackets() {
return UNSUPPORTED;
}
/** {@hide} */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public static long getMobileTcpTxPackets() {
return UNSUPPORTED;
}
/**
* Return the number of packets transmitted on the specified interface since the interface
* was created. Statistics are measured at the network layer, so both TCP and
* UDP usage are included.
*
* Note that the returned values are partial statistics that do not count data from several
* sources and do not apply several adjustments that are necessary for correctness, such
* as adjusting for VPN apps, IPv6-in-IPv4 translation, etc. These values can be used to
* determine whether traffic is being transferred on the specific interface but are not a
* substitute for the more accurate statistics provided by the {@link NetworkStatsManager}
* APIs.
*
* @param iface The name of the interface.
* @return The number of transmitted packets.
*/
public static long getTxPackets(@NonNull String iface) {
try {
return getStatsService().getIfaceStats(iface, TYPE_TX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return the number of packets received on the specified interface since the interface was
* created. Statistics are measured at the network layer, so both TCP
* and UDP usage are included.
*
* Note that the returned values are partial statistics that do not count data from several
* sources and do not apply several adjustments that are necessary for correctness, such
* as adjusting for VPN apps, IPv6-in-IPv4 translation, etc. These values can be used to
* determine whether traffic is being transferred on the specific interface but are not a
* substitute for the more accurate statistics provided by the {@link NetworkStatsManager}
* APIs.
*
* @param iface The name of the interface.
* @return The number of received packets.
*/
public static long getRxPackets(@NonNull String iface) {
try {
return getStatsService().getIfaceStats(iface, TYPE_RX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return the number of bytes transmitted on the specified interface since the interface
* was created. Statistics are measured at the network layer, so both TCP and
* UDP usage are included.
*
* Note that the returned values are partial statistics that do not count data from several
* sources and do not apply several adjustments that are necessary for correctness, such
* as adjusting for VPN apps, IPv6-in-IPv4 translation, etc. These values can be used to
* determine whether traffic is being transferred on the specific interface but are not a
* substitute for the more accurate statistics provided by the {@link NetworkStatsManager}
* APIs.
*
* @param iface The name of the interface.
* @return The number of transmitted bytes.
*/
public static long getTxBytes(@NonNull String iface) {
try {
return getStatsService().getIfaceStats(iface, TYPE_TX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return the number of bytes received on the specified interface since the interface
* was created. Statistics are measured at the network layer, so both TCP
* and UDP usage are included.
*
* Note that the returned values are partial statistics that do not count data from several
* sources and do not apply several adjustments that are necessary for correctness, such
* as adjusting for VPN apps, IPv6-in-IPv4 translation, etc. These values can be used to
* determine whether traffic is being transferred on the specific interface but are not a
* substitute for the more accurate statistics provided by the {@link NetworkStatsManager}
* APIs.
*
* @param iface The name of the interface.
* @return The number of received bytes.
*/
public static long getRxBytes(@NonNull String iface) {
try {
return getStatsService().getIfaceStats(iface, TYPE_RX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** {@hide} */
@TestApi
public static long getLoopbackTxPackets() {
try {
return getStatsService().getIfaceStats(LOOPBACK_IFACE, TYPE_TX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** {@hide} */
@TestApi
public static long getLoopbackRxPackets() {
try {
return getStatsService().getIfaceStats(LOOPBACK_IFACE, TYPE_RX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** {@hide} */
@TestApi
public static long getLoopbackTxBytes() {
try {
return getStatsService().getIfaceStats(LOOPBACK_IFACE, TYPE_TX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** {@hide} */
@TestApi
public static long getLoopbackRxBytes() {
try {
return getStatsService().getIfaceStats(LOOPBACK_IFACE, TYPE_RX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of packets transmitted since device boot. Counts packets
* across all network interfaces, and always increases monotonically since
* device boot. Statistics are measured at the network layer, so they
* include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getTotalTxPackets() {
try {
return getStatsService().getTotalStats(TYPE_TX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of packets received since device boot. Counts packets
* across all network interfaces, and always increases monotonically since
* device boot. Statistics are measured at the network layer, so they
* include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getTotalRxPackets() {
try {
return getStatsService().getTotalStats(TYPE_RX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of bytes transmitted since device boot. Counts packets
* across all network interfaces, and always increases monotonically since
* device boot. Statistics are measured at the network layer, so they
* include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getTotalTxBytes() {
try {
return getStatsService().getTotalStats(TYPE_TX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of bytes received since device boot. Counts packets across
* all network interfaces, and always increases monotonically since device
* boot. Statistics are measured at the network layer, so they include both
* TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
*/
public static long getTotalRxBytes() {
try {
return getStatsService().getTotalStats(TYPE_RX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of bytes transmitted by the given UID since device boot.
* Counts packets across all network interfaces, and always increases
* monotonically since device boot. Statistics are measured at the network
* layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
* return {@link #UNSUPPORTED} on devices where statistics aren't available.
* <p>
* Starting in {@link android.os.Build.VERSION_CODES#N} this will only
* report traffic statistics for the calling UID. It will return
* {@link #UNSUPPORTED} for all other UIDs for privacy reasons. To access
* historical network statistics belonging to other UIDs, use
* {@link NetworkStatsManager}.
*
* @see android.os.Process#myUid()
* @see android.content.pm.ApplicationInfo#uid
*/
public static long getUidTxBytes(int uid) {
try {
return getStatsService().getUidStats(uid, TYPE_TX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of bytes received by the given UID since device boot.
* Counts packets across all network interfaces, and always increases
* monotonically since device boot. Statistics are measured at the network
* layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may return
* {@link #UNSUPPORTED} on devices where statistics aren't available.
* <p>
* Starting in {@link android.os.Build.VERSION_CODES#N} this will only
* report traffic statistics for the calling UID. It will return
* {@link #UNSUPPORTED} for all other UIDs for privacy reasons. To access
* historical network statistics belonging to other UIDs, use
* {@link NetworkStatsManager}.
*
* @see android.os.Process#myUid()
* @see android.content.pm.ApplicationInfo#uid
*/
public static long getUidRxBytes(int uid) {
try {
return getStatsService().getUidStats(uid, TYPE_RX_BYTES);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of packets transmitted by the given UID since device boot.
* Counts packets across all network interfaces, and always increases
* monotonically since device boot. Statistics are measured at the network
* layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may return
* {@link #UNSUPPORTED} on devices where statistics aren't available.
* <p>
* Starting in {@link android.os.Build.VERSION_CODES#N} this will only
* report traffic statistics for the calling UID. It will return
* {@link #UNSUPPORTED} for all other UIDs for privacy reasons. To access
* historical network statistics belonging to other UIDs, use
* {@link NetworkStatsManager}.
*
* @see android.os.Process#myUid()
* @see android.content.pm.ApplicationInfo#uid
*/
public static long getUidTxPackets(int uid) {
try {
return getStatsService().getUidStats(uid, TYPE_TX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return number of packets received by the given UID since device boot.
* Counts packets across all network interfaces, and always increases
* monotonically since device boot. Statistics are measured at the network
* layer, so they include both TCP and UDP usage.
* <p>
* Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may return
* {@link #UNSUPPORTED} on devices where statistics aren't available.
* <p>
* Starting in {@link android.os.Build.VERSION_CODES#N} this will only
* report traffic statistics for the calling UID. It will return
* {@link #UNSUPPORTED} for all other UIDs for privacy reasons. To access
* historical network statistics belonging to other UIDs, use
* {@link NetworkStatsManager}.
*
* @see android.os.Process#myUid()
* @see android.content.pm.ApplicationInfo#uid
*/
public static long getUidRxPackets(int uid) {
try {
return getStatsService().getUidStats(uid, TYPE_RX_PACKETS);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidTxBytes(int)
*/
@Deprecated
public static long getUidTcpTxBytes(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidRxBytes(int)
*/
@Deprecated
public static long getUidTcpRxBytes(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidTxBytes(int)
*/
@Deprecated
public static long getUidUdpTxBytes(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidRxBytes(int)
*/
@Deprecated
public static long getUidUdpRxBytes(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidTxPackets(int)
*/
@Deprecated
public static long getUidTcpTxSegments(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidRxPackets(int)
*/
@Deprecated
public static long getUidTcpRxSegments(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidTxPackets(int)
*/
@Deprecated
public static long getUidUdpTxPackets(int uid) {
return UNSUPPORTED;
}
/**
* @deprecated Starting in {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2},
* transport layer statistics are no longer available, and will
* always return {@link #UNSUPPORTED}.
* @see #getUidRxPackets(int)
*/
@Deprecated
public static long getUidUdpRxPackets(int uid) {
return UNSUPPORTED;
}
/**
* Return detailed {@link NetworkStats} for the current UID. Requires no
* special permission.
*/
private static NetworkStats getDataLayerSnapshotForUid(Context context) {
// TODO: take snapshot locally, since proc file is now visible
final int uid = android.os.Process.myUid();
try {
return getStatsService().getDataLayerSnapshotForUid(uid);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Return set of any ifaces associated with mobile networks since boot.
* Interfaces are never removed from this list, so counters should always be
* monotonic.
*/
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 130143562)
private static String[] getMobileIfaces() {
try {
return getStatsService().getMobileIfaces();
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
// NOTE: keep these in sync with {@code com_android_server_net_NetworkStatsService.cpp}.
/** {@hide} */
public static final int TYPE_RX_BYTES = 0;
/** {@hide} */
public static final int TYPE_RX_PACKETS = 1;
/** {@hide} */
public static final int TYPE_TX_BYTES = 2;
/** {@hide} */
public static final int TYPE_TX_PACKETS = 3;
}