android.app.usage.NetworkStatsManager#android.net.NetworkPolicyManager源码实例Demo

public void start() {
    mCM = mContext.getSystemService(ConnectivityManager.class);
    mNPM = mContext.getSystemService(NetworkPolicyManager.class);
    mStatsManager = mContext.getSystemService(NetworkStatsManager.class);

    registerTrackMobileCallback();
    registerNetworkPolicyListener();
    final Uri defaultSettingUri =
            Settings.Global.getUriFor(NETWORK_DEFAULT_DAILY_MULTIPATH_QUOTA_BYTES);
    mResolver.registerContentObserver(defaultSettingUri, false, mSettingsObserver);

    final IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
    mContext.registerReceiverAsUser(
            mConfigChangeReceiver, UserHandle.ALL, intentFilter, null, mHandler);
}
 

private boolean updateFirewallUidRuleLocked(int chain, int uid, int rule) {
    synchronized (mRulesLock) {
        SparseIntArray uidFirewallRules = getUidFirewallRulesLR(chain);

        final int oldUidFirewallRule = uidFirewallRules.get(uid, FIREWALL_RULE_DEFAULT);
        if (DBG) {
            Slog.d(TAG, "oldRule = " + oldUidFirewallRule
                    + ", newRule=" + rule + " for uid=" + uid + " on chain " + chain);
        }
        if (oldUidFirewallRule == rule) {
            if (DBG) Slog.d(TAG, "!!!!! Skipping change");
            // TODO: eventually consider throwing
            return false;
        }

        String ruleName = getFirewallRuleName(chain, rule);
        String oldRuleName = getFirewallRuleName(chain, oldUidFirewallRule);

        if (rule == NetworkPolicyManager.FIREWALL_RULE_DEFAULT) {
            uidFirewallRules.delete(uid);
        } else {
            uidFirewallRules.put(uid, rule);
        }
        return !ruleName.equals(oldRuleName);
    }
}
 

private @NonNull String getFirewallRuleName(int chain, int rule) {
    String ruleName;
    if (getFirewallType(chain) == FIREWALL_TYPE_WHITELIST) {
        if (rule == NetworkPolicyManager.FIREWALL_RULE_ALLOW) {
            ruleName = "allow";
        } else {
            ruleName = "deny";
        }
    } else { // Blacklist mode
        if (rule == NetworkPolicyManager.FIREWALL_RULE_DENY) {
            ruleName = "deny";
        } else {
            ruleName = "allow";
        }
    }
    return ruleName;
}
 

private int listWifiNetworks() {
    final PrintWriter pw = getOutPrintWriter();
    final String arg = getNextArg();
    final int match;
    if (arg == null) {
        match = WifiConfiguration.METERED_OVERRIDE_NONE;
    } else if (Boolean.parseBoolean(arg)) {
        match = WifiConfiguration.METERED_OVERRIDE_METERED;
    } else {
        match = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
    }

    final List<WifiConfiguration> configs = mWifiManager.getConfiguredNetworks();
    for (WifiConfiguration config : configs) {
        if (arg == null || config.meteredOverride == match) {
            pw.print(NetworkPolicyManager.resolveNetworkId(config));
            pw.print(';');
            pw.println(overrideToString(config.meteredOverride));
        }
    }
    return 0;
}
 

private int setMeteredWifiNetwork() throws RemoteException {
    final PrintWriter pw = getOutPrintWriter();
    final String networkId = getNextArg();
    if (networkId == null) {
        pw.println("Error: didn't specify networkId");
        return -1;
    }
    final String arg = getNextArg();
    if (arg == null) {
        pw.println("Error: didn't specify meteredOverride");
        return -1;
    }
    mInterface.setWifiMeteredOverride(NetworkPolicyManager.resolveNetworkId(networkId),
            stringToOverride(arg));
    return -1;
}
 

public ConnectivityController(JobSchedulerService service) {
    super(service);

    mConnManager = mContext.getSystemService(ConnectivityManager.class);
    mNetPolicyManager = mContext.getSystemService(NetworkPolicyManager.class);

    // We're interested in all network changes; internally we match these
    // network changes against the active network for each UID with jobs.
    final NetworkRequest request = new NetworkRequest.Builder().clearCapabilities().build();
    mConnManager.registerNetworkCallback(request, mNetworkCallback);

    mNetPolicyManager.registerListener(mNetPolicyListener);
}
 

private void registerNetworkPolicyListener() {
    mPolicyListener = new NetworkPolicyManager.Listener() {
        @Override
        public void onMeteredIfacesChanged(String[] meteredIfaces) {
            // Dispatched every time opportunistic quota is recalculated.
            mHandler.post(() -> updateAllMultipathBudgets());
        }
    };
    mNPM.registerListener(mPolicyListener);
}
 

private byte[] getNetworkPolicies() {
    NetworkPolicyManager networkPolicyManager =
            (NetworkPolicyManager) getSystemService(NETWORK_POLICY_SERVICE);
    NetworkPolicy[] policies = networkPolicyManager.getNetworkPolicies();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    if (policies != null && policies.length != 0) {
        DataOutputStream out = new DataOutputStream(baos);
        try {
            out.writeInt(NETWORK_POLICIES_BACKUP_VERSION);
            out.writeInt(policies.length);
            for (NetworkPolicy policy : policies) {
                if (policy != null) {
                    byte[] marshaledPolicy = policy.getBytesForBackup();
                    out.writeByte(BackupUtils.NOT_NULL);
                    out.writeInt(marshaledPolicy.length);
                    out.write(marshaledPolicy);
                } else {
                    out.writeByte(BackupUtils.NULL);
                }
            }
        } catch (IOException ioe) {
            Log.e(TAG, "Failed to convert NetworkPolicies to byte array " + ioe.getMessage());
            baos.reset();
        }
    }
    return baos.toByteArray();
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

@Override
public Object createService(ContextImpl ctx) {
    return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getService(NETWORK_POLICY_SERVICE)));
}
 

private static String getPolicyChangedLog(int uid, int oldPolicy, int newPolicy) {
    return "Policy for " + uid + " changed from "
            + NetworkPolicyManager.uidPoliciesToString(oldPolicy) + " to "
            + NetworkPolicyManager.uidPoliciesToString(newPolicy);
}
 

@Override
public NetworkPolicyManager createService(ContextImpl ctx) throws ServiceNotFoundException {
    return new NetworkPolicyManager(ctx, INetworkPolicyManager.Stub.asInterface(
            ServiceManager.getServiceOrThrow(Context.NETWORK_POLICY_SERVICE)));
}