import static android.net.NetworkPolicyManager.EXTRA_NETWORK_TEMPLATE;
import static android.net.NetworkPolicyManager.computeLastCycleBoundary;
import static android.net.NetworkPolicyManager.computeNextCycleBoundary;
-import static android.net.TrafficStats.TEMPLATE_MOBILE_3G_LOWER;
-import static android.net.TrafficStats.TEMPLATE_MOBILE_4G;
-import static android.net.TrafficStats.TEMPLATE_MOBILE_ALL;
-import static android.net.TrafficStats.TEMPLATE_WIFI;
+import static android.net.NetworkTemplate.MATCH_MOBILE_3G_LOWER;
+import static android.net.NetworkTemplate.MATCH_MOBILE_4G;
+import static android.net.NetworkTemplate.MATCH_MOBILE_ALL;
+import static android.net.NetworkTemplate.MATCH_WIFI;
import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
import android.app.AlertDialog;
import android.net.NetworkPolicyManager;
import android.net.NetworkStats;
import android.net.NetworkStatsHistory;
+import android.net.NetworkTemplate;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.RemoteException;
import android.widget.TabWidget;
import android.widget.TextView;
-import com.android.settings.net.NetworkPolicyModifier;
+import com.android.settings.net.NetworkPolicyEditor;
import com.android.settings.widget.DataUsageChartView;
import com.android.settings.widget.DataUsageChartView.DataUsageChartListener;
import com.google.android.collect.Lists;
// TODO: persist show wifi flag
private boolean mShowWifi = false;
- private int mTemplate = TEMPLATE_INVALID;
+ private NetworkTemplate mTemplate = null;
- private NetworkPolicyModifier mPolicyModifier;
+ private NetworkPolicyEditor mPolicyEditor;
private NetworkStatsHistory mHistory;
private String mIntentTab = null;
mPolicyService = INetworkPolicyManager.Stub.asInterface(
ServiceManager.getService(Context.NETWORK_POLICY_SERVICE));
- final Context context = getActivity();
- final String subscriberId = getActiveSubscriberId(context);
- mPolicyModifier = new NetworkPolicyModifier(mPolicyService, subscriberId);
- mPolicyModifier.read();
+ mPolicyEditor = new NetworkPolicyEditor(mPolicyService);
+ mPolicyEditor.read();
setHasOptionsMenu(true);
}
@Override
public void onPrepareOptionsMenu(Menu menu) {
final MenuItem split4g = menu.findItem(R.id.action_split_4g);
- split4g.setChecked(mPolicyModifier.isMobilePolicySplit());
+ split4g.setChecked(isMobilePolicySplit());
}
@Override
switch (item.getItemId()) {
case R.id.action_split_4g: {
final boolean mobileSplit = !item.isChecked();
- mPolicyModifier.setMobilePolicySplit(mobileSplit);
- item.setChecked(mPolicyModifier.isMobilePolicySplit());
+ setMobilePolicySplit(mobileSplit);
+ item.setChecked(isMobilePolicySplit());
updateTabs();
return true;
}
}
/**
- * Rebuild all tabs based on {@link NetworkPolicyModifier} and
+ * Rebuild all tabs based on {@link NetworkPolicyEditor} and
* {@link #mShowWifi}, hiding the tabs entirely when applicable. Selects
* first tab, and kicks off a full rebind of body contents.
*/
private void updateTabs() {
- final boolean mobileSplit = mPolicyModifier.isMobilePolicySplit();
+ final boolean mobileSplit = isMobilePolicySplit();
final boolean tabsVisible = mobileSplit || mShowWifi;
mTabWidget.setVisibility(tabsVisible ? View.VISIBLE : View.GONE);
mTabHost.clearAllTabs();
final String tabTag = mTabHost.getCurrentTabTag();
final String currentTab = tabTag != null ? tabTag : TAB_MOBILE;
+ final Context context = getActivity();
+ final String subscriberId = getActiveSubscriberId(context);
+
if (LOGD) Log.d(TAG, "updateBody() with currentTab=" + currentTab);
if (TAB_WIFI.equals(currentTab)) {
// wifi doesn't have any controls
mDataEnabledView.setVisibility(View.GONE);
mDisableAtLimitView.setVisibility(View.GONE);
- mTemplate = TEMPLATE_WIFI;
+ mTemplate = new NetworkTemplate(MATCH_WIFI, null);
} else {
// make sure we show for non-wifi
if (TAB_MOBILE.equals(currentTab)) {
mDataEnabled.setTitle(R.string.data_usage_enable_mobile);
mDisableAtLimit.setTitle(R.string.data_usage_disable_mobile_limit);
- mTemplate = TEMPLATE_MOBILE_ALL;
+ mTemplate = new NetworkTemplate(MATCH_MOBILE_ALL, subscriberId);
} else if (TAB_3G.equals(currentTab)) {
mDataEnabled.setTitle(R.string.data_usage_enable_3g);
mDisableAtLimit.setTitle(R.string.data_usage_disable_3g_limit);
- mTemplate = TEMPLATE_MOBILE_3G_LOWER;
+ mTemplate = new NetworkTemplate(MATCH_MOBILE_3G_LOWER, subscriberId);
} else if (TAB_4G.equals(currentTab)) {
mDataEnabled.setTitle(R.string.data_usage_enable_4g);
mDisableAtLimit.setTitle(R.string.data_usage_disable_4g_limit);
- mTemplate = TEMPLATE_MOBILE_4G;
+ mTemplate = new NetworkTemplate(MATCH_MOBILE_4G, subscriberId);
}
private void setPolicyCycleDay(int cycleDay) {
if (LOGD) Log.d(TAG, "setPolicyCycleDay()");
- mPolicyModifier.setPolicyCycleDay(mTemplate, cycleDay);
+ mPolicyEditor.setPolicyCycleDay(mTemplate, cycleDay);
updatePolicy(true);
}
private void setPolicyWarningBytes(long warningBytes) {
if (LOGD) Log.d(TAG, "setPolicyWarningBytes()");
- mPolicyModifier.setPolicyWarningBytes(mTemplate, warningBytes);
+ mPolicyEditor.setPolicyWarningBytes(mTemplate, warningBytes);
updatePolicy(false);
}
private void setPolicyLimitBytes(long limitBytes) {
if (LOGD) Log.d(TAG, "setPolicyLimitBytes()");
- mPolicyModifier.setPolicyLimitBytes(mTemplate, limitBytes);
+ mPolicyEditor.setPolicyLimitBytes(mTemplate, limitBytes);
updatePolicy(false);
}
* current {@link #mTemplate}.
*/
private void updatePolicy(boolean refreshCycle) {
- final NetworkPolicy policy = mPolicyModifier.getPolicy(mTemplate);
+ final NetworkPolicy policy = mPolicyEditor.getPolicy(mTemplate);
// reflect policy limit in checkbox
mDisableAtLimit.setChecked(policy != null && policy.limitBytes != LIMIT_DISABLED);
final AppUsageItem app = (AppUsageItem) parent.getItemAtPosition(position);
final Bundle args = new Bundle();
- args.putInt(Intent.EXTRA_UID, app.uid);
+ args.putParcelable(DataUsageAppDetail.EXTRA_NETWORK_TEMPLATE, mTemplate);
+ args.putInt(DataUsageAppDetail.EXTRA_UID, app.uid);
final PreferenceActivity activity = (PreferenceActivity) getActivity();
activity.startPreferencePanel(DataUsageAppDetail.class.getName(), args,
protected NetworkStats doInBackground(Void... params) {
try {
final long[] range = mChart.getInspectRange();
- return mStatsService.getSummaryForAllUid(range[0], range[1], mTemplate);
+ return mStatsService.getSummaryForAllUid(mTemplate, range[0], range[1]);
} catch (RemoteException e) {
Log.w(TAG, "problem reading stats");
}
}.execute();
}
+ private boolean isMobilePolicySplit() {
+ final String subscriberId = getActiveSubscriberId(getActivity());
+ return mPolicyEditor.isMobilePolicySplit(subscriberId);
+ }
+
+ private void setMobilePolicySplit(boolean split) {
+ final String subscriberId = getActiveSubscriberId(getActivity());
+ mPolicyEditor.setMobilePolicySplit(subscriberId, split);
+ }
+
private static String getActiveSubscriberId(Context context) {
final TelephonyManager telephony = (TelephonyManager) context.getSystemService(
Context.TELEPHONY_SERVICE);
final Bundle args = new Bundle();
// TODO: customize default limits based on network template
- switch (parent.mTemplate) {
- case TEMPLATE_MOBILE_3G_LOWER: {
+ switch (parent.mTemplate.getMatchRule()) {
+ case MATCH_MOBILE_3G_LOWER: {
args.putInt(EXTRA_MESSAGE_ID, R.string.data_usage_limit_dialog_3g);
args.putLong(EXTRA_LIMIT_BYTES, 5 * GB_IN_BYTES);
break;
}
- case TEMPLATE_MOBILE_4G: {
+ case MATCH_MOBILE_4G: {
args.putInt(EXTRA_MESSAGE_ID, R.string.data_usage_limit_dialog_4g);
args.putLong(EXTRA_LIMIT_BYTES, 5 * GB_IN_BYTES);
break;
}
- case TEMPLATE_MOBILE_ALL: {
+ case MATCH_MOBILE_ALL: {
args.putInt(EXTRA_MESSAGE_ID, R.string.data_usage_limit_dialog_mobile);
args.putLong(EXTRA_LIMIT_BYTES, 5 * GB_IN_BYTES);
break;
public static final String EXTRA_CYCLE_DAY = "cycleDay";
public static void show(DataUsageSummary parent) {
- final NetworkPolicy policy = parent.mPolicyModifier.getPolicy(parent.mTemplate);
+ final NetworkPolicy policy = parent.mPolicyEditor.getPolicy(parent.mTemplate);
final Bundle args = new Bundle();
args.putInt(CycleEditorFragment.EXTRA_CYCLE_DAY, policy.cycleDay);
public static void show(DataUsageSummary parent) {
final Bundle args = new Bundle();
- switch (parent.mTemplate) {
- case TEMPLATE_MOBILE_3G_LOWER: {
+ switch (parent.mTemplate.getMatchRule()) {
+ case MATCH_MOBILE_3G_LOWER: {
args.putInt(EXTRA_TITLE_ID, R.string.data_usage_disabled_dialog_3g_title);
break;
}
- case TEMPLATE_MOBILE_4G: {
+ case MATCH_MOBILE_4G: {
args.putInt(EXTRA_TITLE_ID, R.string.data_usage_disabled_dialog_4g_title);
break;
}
- case TEMPLATE_MOBILE_ALL: {
+ case MATCH_MOBILE_ALL: {
args.putInt(EXTRA_TITLE_ID, R.string.data_usage_disabled_dialog_mobile_title);
break;
}
private static String computeTabFromIntent(Intent intent) {
final int networkTemplate = intent.getIntExtra(EXTRA_NETWORK_TEMPLATE, TEMPLATE_INVALID);
switch (networkTemplate) {
- case TEMPLATE_MOBILE_3G_LOWER:
+ case MATCH_MOBILE_3G_LOWER:
return TAB_3G;
- case TEMPLATE_MOBILE_4G:
+ case MATCH_MOBILE_4G:
return TAB_4G;
- case TEMPLATE_MOBILE_ALL:
+ case MATCH_MOBILE_ALL:
return TAB_MOBILE;
- case TEMPLATE_WIFI:
+ case MATCH_WIFI:
return TAB_WIFI;
default:
return null;
package com.android.settings.net;
-import static android.net.TrafficStats.TEMPLATE_MOBILE_3G_LOWER;
-import static android.net.TrafficStats.TEMPLATE_MOBILE_4G;
-import static android.net.TrafficStats.TEMPLATE_MOBILE_ALL;
+import static android.net.NetworkTemplate.MATCH_MOBILE_3G_LOWER;
+import static android.net.NetworkTemplate.MATCH_MOBILE_4G;
+import static android.net.NetworkTemplate.MATCH_MOBILE_ALL;
import static com.android.internal.util.Preconditions.checkNotNull;
import android.net.INetworkPolicyManager;
import android.net.NetworkPolicy;
+import android.net.NetworkTemplate;
import android.os.AsyncTask;
import android.os.RemoteException;
* Utility class to modify list of {@link NetworkPolicy}. Specifically knows
* about which policies can coexist.
*/
-public class NetworkPolicyModifier {
- // TODO: refactor to "Editor"
+public class NetworkPolicyEditor {
// TODO: be more robust when missing policies from service
private INetworkPolicyManager mPolicyService;
- private String mSubscriberId;
-
private ArrayList<NetworkPolicy> mPolicies = Lists.newArrayList();
- public NetworkPolicyModifier(INetworkPolicyManager policyService, String subscriberId) {
+ public NetworkPolicyEditor(INetworkPolicyManager policyService) {
mPolicyService = checkNotNull(policyService);
- mSubscriberId = subscriberId;
}
public void read() {
}
}
- public NetworkPolicy getPolicy(int networkTemplate) {
+ public NetworkPolicy getPolicy(NetworkTemplate template) {
for (NetworkPolicy policy : mPolicies) {
- if (policy.networkTemplate == networkTemplate
- && Objects.equal(policy.subscriberId, mSubscriberId)) {
+ if (policy.template.equals(template)) {
return policy;
}
}
return null;
}
- public void setPolicyCycleDay(int networkTemplate, int cycleDay) {
- getPolicy(networkTemplate).cycleDay = cycleDay;
+ public void setPolicyCycleDay(NetworkTemplate template, int cycleDay) {
+ getPolicy(template).cycleDay = cycleDay;
writeAsync();
}
- public void setPolicyWarningBytes(int networkTemplate, long warningBytes) {
- getPolicy(networkTemplate).warningBytes = warningBytes;
+ public void setPolicyWarningBytes(NetworkTemplate template, long warningBytes) {
+ getPolicy(template).warningBytes = warningBytes;
writeAsync();
}
- public void setPolicyLimitBytes(int networkTemplate, long limitBytes) {
- getPolicy(networkTemplate).limitBytes = limitBytes;
+ public void setPolicyLimitBytes(NetworkTemplate template, long limitBytes) {
+ getPolicy(template).limitBytes = limitBytes;
writeAsync();
}
- public boolean isMobilePolicySplit() {
- return getPolicy(TEMPLATE_MOBILE_3G_LOWER) != null && getPolicy(TEMPLATE_MOBILE_4G) != null;
+ public boolean isMobilePolicySplit(String subscriberId) {
+ boolean has3g = false;
+ boolean has4g = false;
+ for (NetworkPolicy policy : mPolicies) {
+ final NetworkTemplate template = policy.template;
+ if (Objects.equal(subscriberId, template.getSubscriberId())) {
+ switch (template.getMatchRule()) {
+ case MATCH_MOBILE_3G_LOWER:
+ has3g = true;
+ break;
+ case MATCH_MOBILE_4G:
+ has4g = true;
+ break;
+ }
+ }
+ }
+ return has3g && has4g;
}
- public void setMobilePolicySplit(boolean split) {
- final boolean beforeSplit = isMobilePolicySplit();
+ public void setMobilePolicySplit(String subscriberId, boolean split) {
+ final boolean beforeSplit = isMobilePolicySplit(subscriberId);
+
+ final NetworkTemplate template3g = new NetworkTemplate(MATCH_MOBILE_3G_LOWER, subscriberId);
+ final NetworkTemplate template4g = new NetworkTemplate(MATCH_MOBILE_4G, subscriberId);
+ final NetworkTemplate templateAll = new NetworkTemplate(MATCH_MOBILE_ALL, subscriberId);
+
if (split == beforeSplit) {
// already in requested state; skip
return;
} else if (beforeSplit && !split) {
// combine, picking most restrictive policy
- final NetworkPolicy policy3g = getPolicy(TEMPLATE_MOBILE_3G_LOWER);
- final NetworkPolicy policy4g = getPolicy(TEMPLATE_MOBILE_4G);
+ final NetworkPolicy policy3g = getPolicy(template3g);
+ final NetworkPolicy policy4g = getPolicy(template4g);
final NetworkPolicy restrictive = policy3g.compareTo(policy4g) < 0 ? policy3g
: policy4g;
mPolicies.remove(policy3g);
mPolicies.remove(policy4g);
- mPolicies.add(new NetworkPolicy(TEMPLATE_MOBILE_ALL, restrictive.subscriberId,
- restrictive.cycleDay, restrictive.warningBytes, restrictive.limitBytes));
+ mPolicies.add(
+ new NetworkPolicy(templateAll, restrictive.cycleDay, restrictive.warningBytes,
+ restrictive.limitBytes));
writeAsync();
} else if (!beforeSplit && split) {
// duplicate existing policy into two rules
- final NetworkPolicy policyAll = getPolicy(TEMPLATE_MOBILE_ALL);
+ final NetworkPolicy policyAll = getPolicy(templateAll);
mPolicies.remove(policyAll);
- mPolicies.add(
- new NetworkPolicy(TEMPLATE_MOBILE_3G_LOWER, policyAll.subscriberId,
- policyAll.cycleDay, policyAll.warningBytes, policyAll.limitBytes));
- mPolicies.add(
- new NetworkPolicy(TEMPLATE_MOBILE_4G, policyAll.subscriberId,
- policyAll.cycleDay, policyAll.warningBytes, policyAll.limitBytes));
+ mPolicies.add(new NetworkPolicy(
+ template3g, policyAll.cycleDay, policyAll.warningBytes, policyAll.limitBytes));
+ mPolicies.add(new NetworkPolicy(
+ template4g, policyAll.cycleDay, policyAll.warningBytes, policyAll.limitBytes));
writeAsync();
}