FileDocCategorySizeDatePackage
NetworkPolicyManager.javaAPI DocAndroid 5.1 API10651Thu Mar 12 22:22:10 GMT 2015android.net

NetworkPolicyManager

public class NetworkPolicyManager extends Object
Manager for creating and modifying network policy rules. {@hide}

Fields Summary
public static final int
POLICY_NONE
No specific network policy, use system default.
public static final int
POLICY_REJECT_METERED_BACKGROUND
Reject network usage on metered networks when application in background.
public static final int
POLICY_ALLOW_BACKGROUND_BATTERY_SAVE
Allow network use (metered or not) in the background in battery save mode.
public static final int
RULE_ALLOW_ALL
All network traffic should be allowed.
public static final int
RULE_REJECT_METERED
Reject traffic on metered networks.
private static final boolean
ALLOW_PLATFORM_APP_POLICY
public static final String
EXTRA_NETWORK_TEMPLATE
{@link Intent} extra that indicates which {@link NetworkTemplate} rule it applies to.
private INetworkPolicyManager
mService
Constructors Summary
public NetworkPolicyManager(INetworkPolicyManager service)


       
        if (service == null) {
            throw new IllegalArgumentException("missing INetworkPolicyManager");
        }
        mService = service;
Methods Summary
public voidaddUidPolicy(int uid, int policy)
Add policy flags for specific UID. The given policy bits will be set for the uid. Policy flags may be either {@link #POLICY_REJECT_METERED_BACKGROUND} or {@link #POLICY_ALLOW_BACKGROUND_BATTERY_SAVE}.

        try {
            mService.addUidPolicy(uid, policy);
        } catch (RemoteException e) {
        }
public static longcomputeLastCycleBoundary(long currentTime, NetworkPolicy policy)
Compute the last cycle boundary for the given {@link NetworkPolicy}. For example, if cycle day is 20th, and today is June 15th, it will return May 20th. When cycle day doesn't exist in current month, it snaps to the 1st of following month.

hide

        if (policy.cycleDay == CYCLE_NONE) {
            throw new IllegalArgumentException("Unable to compute boundary without cycleDay");
        }

        final Time now = new Time(policy.cycleTimezone);
        now.set(currentTime);

        // first, find cycle boundary for current month
        final Time cycle = new Time(now);
        cycle.hour = cycle.minute = cycle.second = 0;
        snapToCycleDay(cycle, policy.cycleDay);

        if (Time.compare(cycle, now) >= 0) {
            // cycle boundary is beyond now, use last cycle boundary; start by
            // pushing ourselves squarely into last month.
            final Time lastMonth = new Time(now);
            lastMonth.hour = lastMonth.minute = lastMonth.second = 0;
            lastMonth.monthDay = 1;
            lastMonth.month -= 1;
            lastMonth.normalize(true);

            cycle.set(lastMonth);
            snapToCycleDay(cycle, policy.cycleDay);
        }

        return cycle.toMillis(true);
public static longcomputeNextCycleBoundary(long currentTime, NetworkPolicy policy)
{@hide}

        if (policy.cycleDay == CYCLE_NONE) {
            throw new IllegalArgumentException("Unable to compute boundary without cycleDay");
        }

        final Time now = new Time(policy.cycleTimezone);
        now.set(currentTime);

        // first, find cycle boundary for current month
        final Time cycle = new Time(now);
        cycle.hour = cycle.minute = cycle.second = 0;
        snapToCycleDay(cycle, policy.cycleDay);

        if (Time.compare(cycle, now) <= 0) {
            // cycle boundary is before now, use next cycle boundary; start by
            // pushing ourselves squarely into next month.
            final Time nextMonth = new Time(now);
            nextMonth.hour = nextMonth.minute = nextMonth.second = 0;
            nextMonth.monthDay = 1;
            nextMonth.month += 1;
            nextMonth.normalize(true);

            cycle.set(nextMonth);
            snapToCycleDay(cycle, policy.cycleDay);
        }

        return cycle.toMillis(true);
public static voiddumpPolicy(java.io.PrintWriter fout, int policy)
{@hide}

        fout.write("[");
        if ((policy & POLICY_REJECT_METERED_BACKGROUND) != 0) {
            fout.write("REJECT_METERED_BACKGROUND");
        }
        fout.write("]");
public static voiddumpRules(java.io.PrintWriter fout, int rules)
{@hide}

        fout.write("[");
        if ((rules & RULE_REJECT_METERED) != 0) {
            fout.write("REJECT_METERED");
        }
        fout.write("]");
public static android.net.NetworkPolicyManagerfrom(android.content.Context context)

        return (NetworkPolicyManager) context.getSystemService(Context.NETWORK_POLICY_SERVICE);
public NetworkPolicy[]getNetworkPolicies()

        try {
            return mService.getNetworkPolicies();
        } catch (RemoteException e) {
            return null;
        }
public int[]getPowerSaveAppIdWhitelist()

        try {
            return mService.getPowerSaveAppIdWhitelist();
        } catch (RemoteException e) {
            return new int[0];
        }
public booleangetRestrictBackground()

        try {
            return mService.getRestrictBackground();
        } catch (RemoteException e) {
            return false;
        }
public intgetUidPolicy(int uid)

        try {
            return mService.getUidPolicy(uid);
        } catch (RemoteException e) {
            return POLICY_NONE;
        }
public int[]getUidsWithPolicy(int policy)

        try {
            return mService.getUidsWithPolicy(policy);
        } catch (RemoteException e) {
            return new int[0];
        }
public static booleanisUidValidForPolicy(android.content.Context context, int uid)
Check if given UID can have a {@link #setUidPolicy(int, int)} defined, usually to protect critical system services.

        // first, quick-reject non-applications
        if (!UserHandle.isApp(uid)) {
            return false;
        }

        if (!ALLOW_PLATFORM_APP_POLICY) {
            final PackageManager pm = context.getPackageManager();
            final HashSet<Signature> systemSignature;
            try {
                systemSignature = Sets.newHashSet(
                        pm.getPackageInfo("android", GET_SIGNATURES).signatures);
            } catch (NameNotFoundException e) {
                throw new RuntimeException("problem finding system signature", e);
            }

            try {
                // reject apps signed with platform cert
                for (String packageName : pm.getPackagesForUid(uid)) {
                    final HashSet<Signature> packageSignature = Sets.newHashSet(
                            pm.getPackageInfo(packageName, GET_SIGNATURES).signatures);
                    if (packageSignature.containsAll(systemSignature)) {
                        return false;
                    }
                }
            } catch (NameNotFoundException e) {
            }
        }

        // nothing found above; we can apply policy to UID
        return true;
public voidregisterListener(INetworkPolicyListener listener)

        try {
            mService.registerListener(listener);
        } catch (RemoteException e) {
        }
public voidremoveUidPolicy(int uid, int policy)
Clear/remove policy flags for specific UID. The given policy bits will be set for the uid. Policy flags may be either {@link #POLICY_REJECT_METERED_BACKGROUND} or {@link #POLICY_ALLOW_BACKGROUND_BATTERY_SAVE}.

        try {
            mService.removeUidPolicy(uid, policy);
        } catch (RemoteException e) {
        }
public voidsetNetworkPolicies(NetworkPolicy[] policies)

        try {
            mService.setNetworkPolicies(policies);
        } catch (RemoteException e) {
        }
public voidsetRestrictBackground(boolean restrictBackground)

        try {
            mService.setRestrictBackground(restrictBackground);
        } catch (RemoteException e) {
        }
public voidsetUidPolicy(int uid, int policy)
Set policy flags for specific UID.

param
policy {@link #POLICY_NONE} or combination of flags like {@link #POLICY_REJECT_METERED_BACKGROUND}, {@link #POLICY_ALLOW_BACKGROUND_BATTERY_SAVE}.

        try {
            mService.setUidPolicy(uid, policy);
        } catch (RemoteException e) {
        }
public static voidsnapToCycleDay(android.text.format.Time time, int cycleDay)
Snap to the cycle day for the current month given; when cycle day doesn't exist, it snaps to last second of current month.

hide

        if (cycleDay > time.getActualMaximum(MONTH_DAY)) {
            // cycle day isn't valid this month; snap to last second of month
            time.month += 1;
            time.monthDay = 1;
            time.second = -1;
        } else {
            time.monthDay = cycleDay;
        }
        time.normalize(true);
public voidunregisterListener(INetworkPolicyListener listener)

        try {
            mService.unregisterListener(listener);
        } catch (RemoteException e) {
        }