| /** |
| * Copyright (C) 2015 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.app.usage; |
| |
| import static android.annotation.SystemApi.Client.MODULE_LIBRARIES; |
| import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR; |
| import static android.net.NetworkCapabilities.TRANSPORT_WIFI; |
| import static android.net.NetworkStats.METERED_YES; |
| import static android.net.NetworkTemplate.MATCH_MOBILE; |
| import static android.net.NetworkTemplate.MATCH_WIFI; |
| |
| import android.Manifest; |
| import android.annotation.CallbackExecutor; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.RequiresPermission; |
| import android.annotation.SystemApi; |
| import android.annotation.SystemService; |
| import android.annotation.WorkerThread; |
| import android.app.usage.NetworkStats.Bucket; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.content.Context; |
| import android.net.ConnectivityManager; |
| import android.net.DataUsageRequest; |
| import android.net.INetworkStatsService; |
| import android.net.Network; |
| import android.net.NetworkStack; |
| import android.net.NetworkStateSnapshot; |
| import android.net.NetworkTemplate; |
| import android.net.UnderlyingNetworkInfo; |
| import android.net.netstats.IUsageCallback; |
| import android.net.netstats.NetworkStatsDataMigrationUtils; |
| import android.net.netstats.provider.INetworkStatsProviderCallback; |
| import android.net.netstats.provider.NetworkStatsProvider; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.RemoteException; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.net.module.util.NetworkIdentityUtils; |
| |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.concurrent.Executor; |
| |
| /** |
| * Provides access to network usage history and statistics. Usage data is collected in |
| * discrete bins of time called 'Buckets'. See {@link NetworkStats.Bucket} for details. |
| * <p /> |
| * Queries can define a time interval in the form of start and end timestamps (Long.MIN_VALUE and |
| * Long.MAX_VALUE can be used to simulate open ended intervals). By default, apps can only obtain |
| * data about themselves. See the below note for special cases in which apps can obtain data about |
| * other applications. |
| * <h3> |
| * Summary queries |
| * </h3> |
| * {@link #querySummaryForDevice} <p /> |
| * {@link #querySummaryForUser} <p /> |
| * {@link #querySummary} <p /> |
| * These queries aggregate network usage across the whole interval. Therefore there will be only one |
| * bucket for a particular key, state, metered and roaming combination. In case of the user-wide |
| * and device-wide summaries a single bucket containing the totalised network usage is returned. |
| * <h3> |
| * History queries |
| * </h3> |
| * {@link #queryDetailsForUid} <p /> |
| * {@link #queryDetails} <p /> |
| * These queries do not aggregate over time but do aggregate over state, metered and roaming. |
| * Therefore there can be multiple buckets for a particular key. However, all Buckets will have |
| * {@code state} {@link NetworkStats.Bucket#STATE_ALL}, |
| * {@code defaultNetwork} {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * {@code metered } {@link NetworkStats.Bucket#METERED_ALL}, |
| * {@code roaming} {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * <p /> |
| * <b>NOTE:</b> Calling {@link #querySummaryForDevice} or accessing stats for apps other than the |
| * calling app requires the permission {@link android.Manifest.permission#PACKAGE_USAGE_STATS}, |
| * which is a system-level permission and will not be granted to third-party apps. However, |
| * declaring the permission implies intention to use the API and the user of the device can grant |
| * permission through the Settings application. |
| * <p /> |
| * Profile owner apps are automatically granted permission to query data on the profile they manage |
| * (that is, for any query except {@link #querySummaryForDevice}). Device owner apps and carrier- |
| * privileged apps likewise get access to usage data for all users on the device. |
| * <p /> |
| * In addition to tethering usage, usage by removed users and apps, and usage by the system |
| * is also included in the results for callers with one of these higher levels of access. |
| * <p /> |
| * <b>NOTE:</b> Prior to API level {@value android.os.Build.VERSION_CODES#N}, all calls to these APIs required |
| * the above permission, even to access an app's own data usage, and carrier-privileged apps were |
| * not included. |
| */ |
| @SystemService(Context.NETWORK_STATS_SERVICE) |
| public class NetworkStatsManager { |
| private static final String TAG = "NetworkStatsManager"; |
| private static final boolean DBG = false; |
| |
| /** @hide */ |
| public static final int CALLBACK_LIMIT_REACHED = 0; |
| /** @hide */ |
| public static final int CALLBACK_RELEASED = 1; |
| |
| /** |
| * Minimum data usage threshold for registering usage callbacks. |
| * |
| * Requests registered with a threshold lower than this will only be triggered once this minimum |
| * is reached. |
| * @hide |
| */ |
| public static final long MIN_THRESHOLD_BYTES = 2 * 1_048_576L; // 2MiB |
| |
| private final Context mContext; |
| private final INetworkStatsService mService; |
| |
| /** |
| * @deprecated Use {@link NetworkStatsDataMigrationUtils#PREFIX_XT} |
| * instead. |
| * @hide |
| */ |
| @Deprecated |
| public static final String PREFIX_DEV = "dev"; |
| |
| /** @hide */ |
| public static final int FLAG_POLL_ON_OPEN = 1 << 0; |
| /** @hide */ |
| public static final int FLAG_POLL_FORCE = 1 << 1; |
| /** @hide */ |
| public static final int FLAG_AUGMENT_WITH_SUBSCRIPTION_PLAN = 1 << 2; |
| |
| /** |
| * Virtual RAT type to represent 5G NSA (Non Stand Alone) mode, where the primary cell is |
| * still LTE and network allocates a secondary 5G cell so telephony reports RAT = LTE along |
| * with NR state as connected. This is a concept added by NetworkStats on top of the telephony |
| * constants for backward compatibility of metrics so this should not be overlapped with any of |
| * the {@code TelephonyManager.NETWORK_TYPE_*} constants. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| public static final int NETWORK_TYPE_5G_NSA = -2; |
| |
| private int mFlags; |
| |
| /** @hide */ |
| @VisibleForTesting |
| public NetworkStatsManager(Context context, INetworkStatsService service) { |
| mContext = context; |
| mService = service; |
| setPollOnOpen(true); |
| setAugmentWithSubscriptionPlan(true); |
| } |
| |
| /** @hide */ |
| public INetworkStatsService getBinder() { |
| return mService; |
| } |
| |
| /** |
| * Set poll on open flag to indicate the poll is needed before service gets statistics |
| * result. This is default enabled. However, for any non-privileged caller, the poll might |
| * be omitted in case of rate limiting. |
| * |
| * @param pollOnOpen true if poll is needed. |
| * @hide |
| */ |
| // The system will ignore any non-default values for non-privileged |
| // processes, so processes that don't hold the appropriate permissions |
| // can make no use of this API. |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| public void setPollOnOpen(boolean pollOnOpen) { |
| if (pollOnOpen) { |
| mFlags |= FLAG_POLL_ON_OPEN; |
| } else { |
| mFlags &= ~FLAG_POLL_ON_OPEN; |
| } |
| } |
| |
| /** |
| * Set poll force flag to indicate that calling any subsequent query method will force a stats |
| * poll. |
| * @hide |
| */ |
| @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) |
| @SystemApi(client = MODULE_LIBRARIES) |
| public void setPollForce(boolean pollForce) { |
| if (pollForce) { |
| mFlags |= FLAG_POLL_FORCE; |
| } else { |
| mFlags &= ~FLAG_POLL_FORCE; |
| } |
| } |
| |
| /** @hide */ |
| public void setAugmentWithSubscriptionPlan(boolean augmentWithSubscriptionPlan) { |
| if (augmentWithSubscriptionPlan) { |
| mFlags |= FLAG_AUGMENT_WITH_SUBSCRIPTION_PLAN; |
| } else { |
| mFlags &= ~FLAG_AUGMENT_WITH_SUBSCRIPTION_PLAN; |
| } |
| } |
| |
| /** |
| * Query network usage statistics summaries. |
| * |
| * Result is summarised data usage for the whole |
| * device. Result is a single Bucket aggregated over time, state, uid, tag, metered, and |
| * roaming. This means the bucket's start and end timestamp will be the same as the |
| * 'startTime' and 'endTime' arguments. State is going to be |
| * {@link NetworkStats.Bucket#STATE_ALL}, uid {@link NetworkStats.Bucket#UID_ALL}, |
| * tag {@link NetworkStats.Bucket#TAG_NONE}, |
| * default network {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * metered {@link NetworkStats.Bucket#METERED_ALL}, |
| * and roaming {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param template Template used to match networks. See {@link NetworkTemplate}. |
| * @param startTime Start of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Bucket Summarised data usage. |
| * |
| * @hide |
| */ |
| @NonNull |
| @WorkerThread |
| @SystemApi(client = MODULE_LIBRARIES) |
| public Bucket querySummaryForDevice(@NonNull NetworkTemplate template, |
| long startTime, long endTime) { |
| Objects.requireNonNull(template); |
| try { |
| NetworkStats stats = |
| new NetworkStats(mContext, template, mFlags, startTime, endTime, mService); |
| Bucket bucket = stats.getDeviceSummaryForNetwork(); |
| stats.close(); |
| return bucket; |
| } catch (RemoteException e) { |
| e.rethrowFromSystemServer(); |
| } |
| return null; // To make the compiler happy. |
| } |
| |
| /** |
| * Query network usage statistics summaries. Result is summarised data usage for the whole |
| * device. Result is a single Bucket aggregated over time, state, uid, tag, metered, and |
| * roaming. This means the bucket's start and end timestamp are going to be the same as the |
| * 'startTime' and 'endTime' parameters. State is going to be |
| * {@link NetworkStats.Bucket#STATE_ALL}, uid {@link NetworkStats.Bucket#UID_ALL}, |
| * tag {@link NetworkStats.Bucket#TAG_NONE}, |
| * default network {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * metered {@link NetworkStats.Bucket#METERED_ALL}, |
| * and roaming {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param networkType As defined in {@link ConnectivityManager}, e.g. |
| * {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} |
| * etc. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when querying for the mobile network type to receive usage |
| * for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param startTime Start of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Bucket object or null if permissions are insufficient or error happened during |
| * statistics collection. |
| */ |
| @WorkerThread |
| public Bucket querySummaryForDevice(int networkType, @Nullable String subscriberId, |
| long startTime, long endTime) throws SecurityException, RemoteException { |
| NetworkTemplate template; |
| try { |
| template = createTemplate(networkType, subscriberId); |
| } catch (IllegalArgumentException e) { |
| if (DBG) Log.e(TAG, "Cannot create template", e); |
| return null; |
| } |
| |
| return querySummaryForDevice(template, startTime, endTime); |
| } |
| |
| /** |
| * Query network usage statistics summaries. Result is summarised data usage for all uids |
| * belonging to calling user. Result is a single Bucket aggregated over time, state and uid. |
| * This means the bucket's start and end timestamp are going to be the same as the 'startTime' |
| * and 'endTime' parameters. State is going to be {@link NetworkStats.Bucket#STATE_ALL}, |
| * uid {@link NetworkStats.Bucket#UID_ALL}, tag {@link NetworkStats.Bucket#TAG_NONE}, |
| * metered {@link NetworkStats.Bucket#METERED_ALL}, and roaming |
| * {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param networkType As defined in {@link ConnectivityManager}, e.g. |
| * {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} |
| * etc. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when querying for the mobile network type to receive usage |
| * for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param startTime Start of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Bucket object or null if permissions are insufficient or error happened during |
| * statistics collection. |
| */ |
| @WorkerThread |
| public Bucket querySummaryForUser(int networkType, @Nullable String subscriberId, |
| long startTime, long endTime) throws SecurityException, RemoteException { |
| NetworkTemplate template; |
| try { |
| template = createTemplate(networkType, subscriberId); |
| } catch (IllegalArgumentException e) { |
| if (DBG) Log.e(TAG, "Cannot create template", e); |
| return null; |
| } |
| |
| NetworkStats stats; |
| stats = new NetworkStats(mContext, template, mFlags, startTime, endTime, mService); |
| stats.startSummaryEnumeration(); |
| |
| stats.close(); |
| return stats.getSummaryAggregate(); |
| } |
| |
| /** |
| * Query network usage statistics summaries. Result filtered to include only uids belonging to |
| * calling user. Result is aggregated over time, hence all buckets will have the same start and |
| * end timestamps. Not aggregated over state, uid, default network, metered, or roaming. This |
| * means buckets' start and end timestamps are going to be the same as the 'startTime' and |
| * 'endTime' parameters. State, uid, metered, and roaming are going to vary, and tag is going to |
| * be the same. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param networkType As defined in {@link ConnectivityManager}, e.g. |
| * {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} |
| * etc. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when querying for the mobile network type to receive usage |
| * for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param startTime Start of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Statistics object or null if permissions are insufficient or error happened during |
| * statistics collection. |
| */ |
| @WorkerThread |
| public NetworkStats querySummary(int networkType, @Nullable String subscriberId, long startTime, |
| long endTime) throws SecurityException, RemoteException { |
| NetworkTemplate template; |
| try { |
| template = createTemplate(networkType, subscriberId); |
| } catch (IllegalArgumentException e) { |
| if (DBG) Log.e(TAG, "Cannot create template", e); |
| return null; |
| } |
| |
| return querySummary(template, startTime, endTime); |
| } |
| |
| /** |
| * Query network usage statistics summaries. |
| * |
| * The results will only include traffic made by UIDs belonging to the calling user profile. |
| * The results are aggregated over time, so that all buckets will have the same start and |
| * end timestamps as the passed arguments. Not aggregated over state, uid, default network, |
| * metered, or roaming. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param template Template used to match networks. See {@link NetworkTemplate}. |
| * @param startTime Start of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Statistics which is described above. |
| * @hide |
| */ |
| @NonNull |
| @SystemApi(client = MODULE_LIBRARIES) |
| @WorkerThread |
| public NetworkStats querySummary(@NonNull NetworkTemplate template, long startTime, |
| long endTime) throws SecurityException { |
| Objects.requireNonNull(template); |
| try { |
| NetworkStats result = |
| new NetworkStats(mContext, template, mFlags, startTime, endTime, mService); |
| result.startSummaryEnumeration(); |
| return result; |
| } catch (RemoteException e) { |
| e.rethrowFromSystemServer(); |
| } |
| return null; // To make the compiler happy. |
| } |
| |
| /** |
| * Query tagged network usage statistics summaries. |
| * |
| * The results will only include tagged traffic made by UIDs belonging to the calling user |
| * profile. The results are aggregated over time, so that all buckets will have the same |
| * start and end timestamps as the passed arguments. Not aggregated over state, uid, |
| * default network, metered, or roaming. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param template Template used to match networks. See {@link NetworkTemplate}. |
| * @param startTime Start of period, in milliseconds since the Unix epoch, see |
| * {@link System#currentTimeMillis}. |
| * @param endTime End of period, in milliseconds since the Unix epoch, see |
| * {@link System#currentTimeMillis}. |
| * @return Statistics which is described above. |
| * @hide |
| */ |
| @NonNull |
| @SystemApi(client = MODULE_LIBRARIES) |
| @WorkerThread |
| public NetworkStats queryTaggedSummary(@NonNull NetworkTemplate template, long startTime, |
| long endTime) throws SecurityException { |
| Objects.requireNonNull(template); |
| try { |
| NetworkStats result = |
| new NetworkStats(mContext, template, mFlags, startTime, endTime, mService); |
| result.startTaggedSummaryEnumeration(); |
| return result; |
| } catch (RemoteException e) { |
| e.rethrowFromSystemServer(); |
| } |
| return null; // To make the compiler happy. |
| } |
| |
| /** |
| * Query usage statistics details for networks matching a given {@link NetworkTemplate}. |
| * |
| * Result is not aggregated over time. This means buckets' start and |
| * end timestamps will be between 'startTime' and 'endTime' parameters. |
| * <p>Only includes buckets whose entire time period is included between |
| * startTime and endTime. Doesn't interpolate or return partial buckets. |
| * Since bucket length is in the order of hours, this |
| * method cannot be used to measure data usage on a fine grained time scale. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param template Template used to match networks. See {@link NetworkTemplate}. |
| * @param startTime Start of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Statistics which is described above. |
| * @hide |
| */ |
| @NonNull |
| @SystemApi(client = MODULE_LIBRARIES) |
| @WorkerThread |
| public NetworkStats queryDetailsForDevice(@NonNull NetworkTemplate template, |
| long startTime, long endTime) { |
| Objects.requireNonNull(template); |
| try { |
| final NetworkStats result = |
| new NetworkStats(mContext, template, mFlags, startTime, endTime, mService); |
| result.startHistoryDeviceEnumeration(); |
| return result; |
| } catch (RemoteException e) { |
| e.rethrowFromSystemServer(); |
| } |
| |
| return null; // To make the compiler happy. |
| } |
| |
| /** |
| * Query network usage statistics details for a given uid. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @see #queryDetailsForUidTagState(int, String, long, long, int, int, int) |
| */ |
| @NonNull |
| @WorkerThread |
| public NetworkStats queryDetailsForUid(int networkType, @Nullable String subscriberId, |
| long startTime, long endTime, int uid) throws SecurityException { |
| return queryDetailsForUidTagState(networkType, subscriberId, startTime, endTime, uid, |
| NetworkStats.Bucket.TAG_NONE, NetworkStats.Bucket.STATE_ALL); |
| } |
| |
| /** @hide */ |
| @NonNull |
| public NetworkStats queryDetailsForUid(@NonNull NetworkTemplate template, |
| long startTime, long endTime, int uid) throws SecurityException { |
| return queryDetailsForUidTagState(template, startTime, endTime, uid, |
| NetworkStats.Bucket.TAG_NONE, NetworkStats.Bucket.STATE_ALL); |
| } |
| |
| /** |
| * Query network usage statistics details for a given uid and tag. |
| * |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * Only usable for uids belonging to calling user. Result is not aggregated over time. |
| * This means buckets' start and end timestamps are going to be between 'startTime' and |
| * 'endTime' parameters. The uid is going to be the same as the 'uid' parameter, the tag |
| * the same as the 'tag' parameter, and the state the same as the 'state' parameter. |
| * defaultNetwork is going to be {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * metered is going to be {@link NetworkStats.Bucket#METERED_ALL}, and |
| * roaming is going to be {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * <p>Only includes buckets that atomically occur in the inclusive time range. Doesn't |
| * interpolate across partial buckets. Since bucket length is in the order of hours, this |
| * method cannot be used to measure data usage on a fine grained time scale. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param networkType As defined in {@link ConnectivityManager}, e.g. |
| * {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} |
| * etc. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when querying for the mobile network type to receive usage |
| * for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param startTime Start of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param uid UID of app |
| * @param tag TAG of interest. Use {@link NetworkStats.Bucket#TAG_NONE} for aggregated data |
| * across all the tags. |
| * @return Statistics which is described above. |
| * @throws SecurityException if permissions are insufficient to read network statistics. |
| */ |
| @NonNull |
| @WorkerThread |
| public NetworkStats queryDetailsForUidTag(int networkType, @Nullable String subscriberId, |
| long startTime, long endTime, int uid, int tag) throws SecurityException { |
| return queryDetailsForUidTagState(networkType, subscriberId, startTime, endTime, uid, |
| tag, NetworkStats.Bucket.STATE_ALL); |
| } |
| |
| /** |
| * Query network usage statistics details for a given uid, tag, and state. |
| * |
| * Only usable for uids belonging to calling user. Result is not aggregated over time. |
| * This means buckets' start and end timestamps are going to be between 'startTime' and |
| * 'endTime' parameters. The uid is going to be the same as the 'uid' parameter, the tag |
| * the same as the 'tag' parameter, and the state the same as the 'state' parameter. |
| * defaultNetwork is going to be {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * metered is going to be {@link NetworkStats.Bucket#METERED_ALL}, and |
| * roaming is going to be {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * <p>Only includes buckets that atomically occur in the inclusive time range. Doesn't |
| * interpolate across partial buckets. Since bucket length is in the order of hours, this |
| * method cannot be used to measure data usage on a fine grained time scale. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param networkType As defined in {@link ConnectivityManager}, e.g. |
| * {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} |
| * etc. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when querying for the mobile network type to receive usage |
| * for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param startTime Start of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param uid UID of app |
| * @param tag TAG of interest. Use {@link NetworkStats.Bucket#TAG_NONE} for aggregated data |
| * across all the tags. |
| * @param state state of interest. Use {@link NetworkStats.Bucket#STATE_ALL} to aggregate |
| * traffic from all states. |
| * @return Statistics which is described above. |
| * @throws SecurityException if permissions are insufficient to read network statistics. |
| */ |
| @NonNull |
| @WorkerThread |
| public NetworkStats queryDetailsForUidTagState(int networkType, @Nullable String subscriberId, |
| long startTime, long endTime, int uid, int tag, int state) throws SecurityException { |
| NetworkTemplate template; |
| template = createTemplate(networkType, subscriberId); |
| |
| return queryDetailsForUidTagState(template, startTime, endTime, uid, tag, state); |
| } |
| |
| /** |
| * Query network usage statistics details for a given template, uid, tag, and state. |
| * |
| * Only usable for uids belonging to calling user. Result is not aggregated over time. |
| * This means buckets' start and end timestamps are going to be between 'startTime' and |
| * 'endTime' parameters. The uid is going to be the same as the 'uid' parameter, the tag |
| * the same as the 'tag' parameter, and the state the same as the 'state' parameter. |
| * defaultNetwork is going to be {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * metered is going to be {@link NetworkStats.Bucket#METERED_ALL}, and |
| * roaming is going to be {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * <p>Only includes buckets that atomically occur in the inclusive time range. Doesn't |
| * interpolate across partial buckets. Since bucket length is in the order of hours, this |
| * method cannot be used to measure data usage on a fine grained time scale. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param template Template used to match networks. See {@link NetworkTemplate}. |
| * @param startTime Start of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period, in milliseconds since the Unix epoch, see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param uid UID of app |
| * @param tag TAG of interest. Use {@link NetworkStats.Bucket#TAG_NONE} for aggregated data |
| * across all the tags. |
| * @param state state of interest. Use {@link NetworkStats.Bucket#STATE_ALL} to aggregate |
| * traffic from all states. |
| * @return Statistics which is described above. |
| * @hide |
| */ |
| @NonNull |
| @SystemApi(client = MODULE_LIBRARIES) |
| @WorkerThread |
| public NetworkStats queryDetailsForUidTagState(@NonNull NetworkTemplate template, |
| long startTime, long endTime, int uid, int tag, int state) throws SecurityException { |
| Objects.requireNonNull(template); |
| try { |
| final NetworkStats result = new NetworkStats( |
| mContext, template, mFlags, startTime, endTime, mService); |
| result.startHistoryUidEnumeration(uid, tag, state); |
| return result; |
| } catch (RemoteException e) { |
| Log.e(TAG, "Error while querying stats for uid=" + uid + " tag=" + tag |
| + " state=" + state, e); |
| e.rethrowFromSystemServer(); |
| } |
| |
| return null; // To make the compiler happy. |
| } |
| |
| /** |
| * Query network usage statistics details. Result filtered to include only uids belonging to |
| * calling user. Result is aggregated over state but not aggregated over time, uid, tag, |
| * metered, nor roaming. This means buckets' start and end timestamps are going to be between |
| * 'startTime' and 'endTime' parameters. State is going to be |
| * {@link NetworkStats.Bucket#STATE_ALL}, uid will vary, |
| * tag {@link NetworkStats.Bucket#TAG_NONE}, |
| * default network is going to be {@link NetworkStats.Bucket#DEFAULT_NETWORK_ALL}, |
| * metered is going to be {@link NetworkStats.Bucket#METERED_ALL}, |
| * and roaming is going to be {@link NetworkStats.Bucket#ROAMING_ALL}. |
| * <p>Only includes buckets that atomically occur in the inclusive time range. Doesn't |
| * interpolate across partial buckets. Since bucket length is in the order of hours, this |
| * method cannot be used to measure data usage on a fine grained time scale. |
| * This may take a long time, and apps should avoid calling this on their main thread. |
| * |
| * @param networkType As defined in {@link ConnectivityManager}, e.g. |
| * {@link ConnectivityManager#TYPE_MOBILE}, {@link ConnectivityManager#TYPE_WIFI} |
| * etc. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when querying for the mobile network type to receive usage |
| * for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param startTime Start of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @param endTime End of period. Defined in terms of "Unix time", see |
| * {@link java.lang.System#currentTimeMillis}. |
| * @return Statistics object or null if permissions are insufficient or error happened during |
| * statistics collection. |
| */ |
| @WorkerThread |
| public NetworkStats queryDetails(int networkType, @Nullable String subscriberId, long startTime, |
| long endTime) throws SecurityException, RemoteException { |
| NetworkTemplate template; |
| try { |
| template = createTemplate(networkType, subscriberId); |
| } catch (IllegalArgumentException e) { |
| if (DBG) Log.e(TAG, "Cannot create template", e); |
| return null; |
| } |
| |
| NetworkStats result; |
| result = new NetworkStats(mContext, template, mFlags, startTime, endTime, mService); |
| result.startUserUidEnumeration(); |
| return result; |
| } |
| |
| /** |
| * Query realtime mobile network usage statistics. |
| * |
| * Return a snapshot of current UID network statistics, as it applies |
| * to the mobile radios of the device. The snapshot will include any |
| * tethering traffic, video calling data usage and count of |
| * network operations set by {@link TrafficStats#incrementOperationCount} |
| * made over a mobile radio. |
| * The snapshot will not include any statistics that cannot be seen by |
| * the kernel, e.g. statistics reported by {@link NetworkStatsProvider}s. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| @NonNull public android.net.NetworkStats getMobileUidStats() { |
| try { |
| return mService.getUidStatsForTransport(TRANSPORT_CELLULAR); |
| } catch (RemoteException e) { |
| if (DBG) Log.d(TAG, "Remote exception when get Mobile uid stats"); |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Query realtime Wi-Fi network usage statistics. |
| * |
| * Return a snapshot of current UID network statistics, as it applies |
| * to the Wi-Fi radios of the device. The snapshot will include any |
| * tethering traffic, video calling data usage and count of |
| * network operations set by {@link TrafficStats#incrementOperationCount} |
| * made over a Wi-Fi radio. |
| * The snapshot will not include any statistics that cannot be seen by |
| * the kernel, e.g. statistics reported by {@link NetworkStatsProvider}s. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| @NonNull public android.net.NetworkStats getWifiUidStats() { |
| try { |
| return mService.getUidStatsForTransport(TRANSPORT_WIFI); |
| } catch (RemoteException e) { |
| if (DBG) Log.d(TAG, "Remote exception when get WiFi uid stats"); |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Registers to receive notifications about data usage on specified networks. |
| * |
| * <p>The callbacks will continue to be called as long as the process is alive or |
| * {@link #unregisterUsageCallback} is called. |
| * |
| * @param template Template used to match networks. See {@link NetworkTemplate}. |
| * @param thresholdBytes Threshold in bytes to be notified on. Provided values lower than 2MiB |
| * will be clamped for callers except callers with the NETWORK_STACK |
| * permission. |
| * @param executor The executor on which callback will be invoked. The provided {@link Executor} |
| * must run callback sequentially, otherwise the order of callbacks cannot be |
| * guaranteed. |
| * @param callback The {@link UsageCallback} that the system will call when data usage |
| * has exceeded the specified threshold. |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}, conditional = true) |
| public void registerUsageCallback(@NonNull NetworkTemplate template, long thresholdBytes, |
| @NonNull @CallbackExecutor Executor executor, @NonNull UsageCallback callback) { |
| Objects.requireNonNull(template, "NetworkTemplate cannot be null"); |
| Objects.requireNonNull(callback, "UsageCallback cannot be null"); |
| Objects.requireNonNull(executor, "Executor cannot be null"); |
| |
| final DataUsageRequest request = new DataUsageRequest(DataUsageRequest.REQUEST_ID_UNSET, |
| template, thresholdBytes); |
| try { |
| final UsageCallbackWrapper callbackWrapper = |
| new UsageCallbackWrapper(executor, callback); |
| callback.request = mService.registerUsageCallback( |
| mContext.getOpPackageName(), request, callbackWrapper); |
| if (DBG) Log.d(TAG, "registerUsageCallback returned " + callback.request); |
| |
| if (callback.request == null) { |
| Log.e(TAG, "Request from callback is null; should not happen"); |
| } |
| } catch (RemoteException e) { |
| if (DBG) Log.d(TAG, "Remote exception when registering callback"); |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Registers to receive notifications about data usage on specified networks. |
| * |
| * <p>The callbacks will continue to be called as long as the process is live or |
| * {@link #unregisterUsageCallback} is called. |
| * |
| * @param networkType Type of network to monitor. Either |
| {@link ConnectivityManager#TYPE_MOBILE} or {@link ConnectivityManager#TYPE_WIFI}. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when registering for the mobile network type to receive |
| * notifications for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param thresholdBytes Threshold in bytes to be notified on. |
| * @param callback The {@link UsageCallback} that the system will call when data usage |
| * has exceeded the specified threshold. |
| */ |
| public void registerUsageCallback(int networkType, @Nullable String subscriberId, |
| long thresholdBytes, @NonNull UsageCallback callback) { |
| registerUsageCallback(networkType, subscriberId, thresholdBytes, callback, |
| null /* handler */); |
| } |
| |
| /** |
| * Registers to receive notifications about data usage on specified networks. |
| * |
| * <p>The callbacks will continue to be called as long as the process is live or |
| * {@link #unregisterUsageCallback} is called. |
| * |
| * @param networkType Type of network to monitor. Either |
| {@link ConnectivityManager#TYPE_MOBILE} or {@link ConnectivityManager#TYPE_WIFI}. |
| * @param subscriberId If applicable, the subscriber id of the network interface. |
| * <p>Starting with API level 29, the {@code subscriberId} is guarded by |
| * additional restrictions. Calling apps that do not meet the new |
| * requirements to access the {@code subscriberId} can provide a {@code |
| * null} value when registering for the mobile network type to receive |
| * notifications for all mobile networks. For additional details see {@link |
| * TelephonyManager#getSubscriberId()}. |
| * <p>Starting with API level 31, calling apps can provide a |
| * {@code subscriberId} with wifi network type to receive usage for |
| * wifi networks which is under the given subscription if applicable. |
| * Otherwise, pass {@code null} when querying all wifi networks. |
| * @param thresholdBytes Threshold in bytes to be notified on. |
| * @param callback The {@link UsageCallback} that the system will call when data usage |
| * has exceeded the specified threshold. |
| * @param handler to dispatch callback events through, otherwise if {@code null} it uses |
| * the calling thread. |
| */ |
| public void registerUsageCallback(int networkType, @Nullable String subscriberId, |
| long thresholdBytes, @NonNull UsageCallback callback, @Nullable Handler handler) { |
| NetworkTemplate template = createTemplate(networkType, subscriberId); |
| if (DBG) { |
| Log.d(TAG, "registerUsageCallback called with: {" |
| + " networkType=" + networkType |
| + " subscriberId=" + subscriberId |
| + " thresholdBytes=" + thresholdBytes |
| + " }"); |
| } |
| |
| final Executor executor = handler == null ? r -> r.run() : r -> handler.post(r); |
| |
| registerUsageCallback(template, thresholdBytes, executor, callback); |
| } |
| |
| /** |
| * Unregisters callbacks on data usage. |
| * |
| * @param callback The {@link UsageCallback} used when registering. |
| */ |
| public void unregisterUsageCallback(@NonNull UsageCallback callback) { |
| if (callback == null || callback.request == null |
| || callback.request.requestId == DataUsageRequest.REQUEST_ID_UNSET) { |
| throw new IllegalArgumentException("Invalid UsageCallback"); |
| } |
| try { |
| mService.unregisterUsageRequest(callback.request); |
| } catch (RemoteException e) { |
| if (DBG) Log.d(TAG, "Remote exception when unregistering callback"); |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Base class for usage callbacks. Should be extended by applications wanting notifications. |
| */ |
| public static abstract class UsageCallback { |
| /** |
| * Called when data usage has reached the given threshold. |
| * |
| * Called by {@code NetworkStatsService} when the registered threshold is reached. |
| * If a caller implements {@link #onThresholdReached(NetworkTemplate)}, the system |
| * will not call {@link #onThresholdReached(int, String)}. |
| * |
| * @param template The {@link NetworkTemplate} that associated with this callback. |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| public void onThresholdReached(@NonNull NetworkTemplate template) { |
| // Backward compatibility for those who didn't override this function. |
| final int networkType = networkTypeForTemplate(template); |
| if (networkType != ConnectivityManager.TYPE_NONE) { |
| final String subscriberId = template.getSubscriberIds().isEmpty() ? null |
| : template.getSubscriberIds().iterator().next(); |
| onThresholdReached(networkType, subscriberId); |
| } |
| } |
| |
| /** |
| * Called when data usage has reached the given threshold. |
| */ |
| public abstract void onThresholdReached(int networkType, @Nullable String subscriberId); |
| |
| /** |
| * @hide used for internal bookkeeping |
| */ |
| private DataUsageRequest request; |
| |
| /** |
| * Get network type from a template if feasible. |
| * |
| * @param template the target {@link NetworkTemplate}. |
| * @return legacy network type, only supports for the types which is already supported in |
| * {@link #registerUsageCallback(int, String, long, UsageCallback, Handler)}. |
| * {@link ConnectivityManager#TYPE_NONE} for other types. |
| */ |
| private static int networkTypeForTemplate(@NonNull NetworkTemplate template) { |
| switch (template.getMatchRule()) { |
| case NetworkTemplate.MATCH_MOBILE: |
| return ConnectivityManager.TYPE_MOBILE; |
| case NetworkTemplate.MATCH_WIFI: |
| return ConnectivityManager.TYPE_WIFI; |
| default: |
| return ConnectivityManager.TYPE_NONE; |
| } |
| } |
| } |
| |
| /** |
| * Registers a custom provider of {@link android.net.NetworkStats} to provide network statistics |
| * to the system. To unregister, invoke {@link #unregisterNetworkStatsProvider}. |
| * Note that no de-duplication of statistics between providers is performed, so each provider |
| * must only report network traffic that is not being reported by any other provider. Also note |
| * that the provider cannot be re-registered after unregistering. |
| * |
| * @param tag a human readable identifier of the custom network stats provider. This is only |
| * used for debugging. |
| * @param provider the subclass of {@link NetworkStatsProvider} that needs to be |
| * registered to the system. |
| * @hide |
| */ |
| @SystemApi |
| @RequiresPermission(anyOf = { |
| android.Manifest.permission.NETWORK_STATS_PROVIDER, |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK}) |
| public void registerNetworkStatsProvider( |
| @NonNull String tag, |
| @NonNull NetworkStatsProvider provider) { |
| try { |
| if (provider.getProviderCallbackBinder() != null) { |
| throw new IllegalArgumentException("provider is already registered"); |
| } |
| final INetworkStatsProviderCallback cbBinder = |
| mService.registerNetworkStatsProvider(tag, provider.getProviderBinder()); |
| provider.setProviderCallbackBinder(cbBinder); |
| } catch (RemoteException e) { |
| e.rethrowAsRuntimeException(); |
| } |
| } |
| |
| /** |
| * Unregisters an instance of {@link NetworkStatsProvider}. |
| * |
| * @param provider the subclass of {@link NetworkStatsProvider} that needs to be |
| * unregistered to the system. |
| * @hide |
| */ |
| @SystemApi |
| @RequiresPermission(anyOf = { |
| android.Manifest.permission.NETWORK_STATS_PROVIDER, |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK}) |
| public void unregisterNetworkStatsProvider(@NonNull NetworkStatsProvider provider) { |
| try { |
| provider.getProviderCallbackBinderOrThrow().unregister(); |
| } catch (RemoteException e) { |
| e.rethrowAsRuntimeException(); |
| } |
| } |
| |
| private static NetworkTemplate createTemplate(int networkType, @Nullable String subscriberId) { |
| final NetworkTemplate template; |
| switch (networkType) { |
| case ConnectivityManager.TYPE_MOBILE: |
| template = subscriberId == null |
| ? new NetworkTemplate.Builder(MATCH_MOBILE) |
| .setMeteredness(METERED_YES).build() |
| : new NetworkTemplate.Builder(MATCH_MOBILE) |
| .setMeteredness(METERED_YES) |
| .setSubscriberIds(Set.of(subscriberId)).build(); |
| break; |
| case ConnectivityManager.TYPE_WIFI: |
| template = TextUtils.isEmpty(subscriberId) |
| ? new NetworkTemplate.Builder(MATCH_WIFI).build() |
| : new NetworkTemplate.Builder(MATCH_WIFI) |
| .setSubscriberIds(Set.of(subscriberId)).build(); |
| break; |
| default: |
| throw new IllegalArgumentException("Cannot create template for network type " |
| + networkType + ", subscriberId '" |
| + NetworkIdentityUtils.scrubSubscriberId(subscriberId) + "'."); |
| } |
| return template; |
| } |
| |
| /** |
| * Notify {@code NetworkStatsService} about network status changed. |
| * |
| * Notifies NetworkStatsService of network state changes for data usage accounting purposes. |
| * |
| * To avoid races that attribute data usage to wrong network, such as new network with |
| * the same interface after SIM hot-swap, this function will not return until |
| * {@code NetworkStatsService} finishes its work of retrieving traffic statistics from |
| * all data sources. |
| * |
| * @param defaultNetworks the list of all networks that could be used by network traffic that |
| * does not explicitly select a network. |
| * @param networkStateSnapshots a list of {@link NetworkStateSnapshot}s, one for |
| * each network that is currently connected. |
| * @param activeIface the active (i.e., connected) default network interface for the calling |
| * uid. Used to determine on which network future calls to |
| * {@link android.net.TrafficStats#incrementOperationCount} applies to. |
| * @param underlyingNetworkInfos the list of underlying network information for all |
| * currently-connected VPNs. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| public void notifyNetworkStatus( |
| @NonNull List<Network> defaultNetworks, |
| @NonNull List<NetworkStateSnapshot> networkStateSnapshots, |
| @Nullable String activeIface, |
| @NonNull List<UnderlyingNetworkInfo> underlyingNetworkInfos) { |
| try { |
| Objects.requireNonNull(defaultNetworks); |
| Objects.requireNonNull(networkStateSnapshots); |
| Objects.requireNonNull(underlyingNetworkInfos); |
| mService.notifyNetworkStatus(defaultNetworks.toArray(new Network[0]), |
| networkStateSnapshots.toArray(new NetworkStateSnapshot[0]), activeIface, |
| underlyingNetworkInfos.toArray(new UnderlyingNetworkInfo[0])); |
| } catch (RemoteException e) { |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| private static class UsageCallbackWrapper extends IUsageCallback.Stub { |
| // Null if unregistered. |
| private volatile UsageCallback mCallback; |
| |
| private final Executor mExecutor; |
| |
| UsageCallbackWrapper(@NonNull Executor executor, @NonNull UsageCallback callback) { |
| mCallback = callback; |
| mExecutor = executor; |
| } |
| |
| @Override |
| public void onThresholdReached(DataUsageRequest request) { |
| // Copy it to a local variable in case mCallback changed inside the if condition. |
| final UsageCallback callback = mCallback; |
| if (callback != null) { |
| mExecutor.execute(() -> callback.onThresholdReached(request.template)); |
| } else { |
| Log.e(TAG, "onThresholdReached with released callback for " + request); |
| } |
| } |
| |
| @Override |
| public void onCallbackReleased(DataUsageRequest request) { |
| if (DBG) Log.d(TAG, "callback released for " + request); |
| mCallback = null; |
| } |
| } |
| |
| /** |
| * Mark given UID as being in foreground for stats purposes. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| public void noteUidForeground(int uid, boolean uidForeground) { |
| try { |
| mService.noteUidForeground(uid, uidForeground); |
| } catch (RemoteException e) { |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Set default value of global alert bytes, the value will be clamped to [128kB, 2MB]. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| Manifest.permission.NETWORK_STACK}) |
| public void setDefaultGlobalAlert(long alertBytes) { |
| try { |
| // TODO: Sync internal naming with the API surface. |
| mService.advisePersistThreshold(alertBytes); |
| } catch (RemoteException e) { |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Force update of statistics. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| public void forceUpdate() { |
| try { |
| mService.forceUpdate(); |
| } catch (RemoteException e) { |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Set the warning and limit to all registered custom network stats providers. |
| * Note that invocation of any interface will be sent to all providers. |
| * |
| * Asynchronicity notes : because traffic may be happening on the device at the same time, it |
| * doesn't make sense to wait for the warning and limit to be set – a caller still wouldn't |
| * know when exactly it was effective. All that can matter is that it's done quickly. Also, |
| * this method can't fail, so there is no status to return. All providers will see the new |
| * values soon. |
| * As such, this method returns immediately and sends the warning and limit to all providers |
| * as soon as possible through a one-way binder call. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| @RequiresPermission(anyOf = { |
| NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, |
| android.Manifest.permission.NETWORK_STACK}) |
| public void setStatsProviderWarningAndLimitAsync(@NonNull String iface, long warning, |
| long limit) { |
| try { |
| mService.setStatsProviderWarningAndLimitAsync(iface, warning, limit); |
| } catch (RemoteException e) { |
| throw e.rethrowFromSystemServer(); |
| } |
| } |
| |
| /** |
| * Get a RAT type representative of a group of RAT types for network statistics. |
| * |
| * Collapse the given Radio Access Technology (RAT) type into a bucket that |
| * is representative of the original RAT type for network statistics. The |
| * mapping mostly corresponds to {@code TelephonyManager#NETWORK_CLASS_BIT_MASK_*} |
| * but with adaptations specific to the virtual types introduced by |
| * networks stats. |
| * |
| * @param ratType An integer defined in {@code TelephonyManager#NETWORK_TYPE_*}. |
| * |
| * @hide |
| */ |
| @SystemApi(client = MODULE_LIBRARIES) |
| public static int getCollapsedRatType(int ratType) { |
| switch (ratType) { |
| case TelephonyManager.NETWORK_TYPE_GPRS: |
| case TelephonyManager.NETWORK_TYPE_GSM: |
| case TelephonyManager.NETWORK_TYPE_EDGE: |
| case TelephonyManager.NETWORK_TYPE_IDEN: |
| case TelephonyManager.NETWORK_TYPE_CDMA: |
| case TelephonyManager.NETWORK_TYPE_1xRTT: |
| return TelephonyManager.NETWORK_TYPE_GSM; |
| case TelephonyManager.NETWORK_TYPE_EVDO_0: |
| case TelephonyManager.NETWORK_TYPE_EVDO_A: |
| case TelephonyManager.NETWORK_TYPE_EVDO_B: |
| case TelephonyManager.NETWORK_TYPE_EHRPD: |
| case TelephonyManager.NETWORK_TYPE_UMTS: |
| case TelephonyManager.NETWORK_TYPE_HSDPA: |
| case TelephonyManager.NETWORK_TYPE_HSUPA: |
| case TelephonyManager.NETWORK_TYPE_HSPA: |
| case TelephonyManager.NETWORK_TYPE_HSPAP: |
| case TelephonyManager.NETWORK_TYPE_TD_SCDMA: |
| return TelephonyManager.NETWORK_TYPE_UMTS; |
| case TelephonyManager.NETWORK_TYPE_LTE: |
| case TelephonyManager.NETWORK_TYPE_IWLAN: |
| return TelephonyManager.NETWORK_TYPE_LTE; |
| case TelephonyManager.NETWORK_TYPE_NR: |
| return TelephonyManager.NETWORK_TYPE_NR; |
| // Virtual RAT type for 5G NSA mode, see |
| // {@link NetworkStatsManager#NETWORK_TYPE_5G_NSA}. |
| case NetworkStatsManager.NETWORK_TYPE_5G_NSA: |
| return NetworkStatsManager.NETWORK_TYPE_5G_NSA; |
| default: |
| return TelephonyManager.NETWORK_TYPE_UNKNOWN; |
| } |
| } |
| } |