/* * Copyright (C) 2016 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 com.android.settings.datausage; import android.app.Activity; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.net.NetworkPolicyManager; import android.net.NetworkTemplate; import android.os.Bundle; import android.os.UserManager; import android.provider.SearchIndexableResource; import android.support.annotation.VisibleForTesting; import android.support.v7.preference.Preference; import android.support.v7.preference.PreferenceScreen; import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; import android.text.BidiFormatter; import android.text.Spannable; import android.text.SpannableString; import android.text.TextUtils; import android.text.format.Formatter; import android.text.style.RelativeSizeSpan; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.SummaryPreference; import com.android.settings.Utils; import com.android.settings.dashboard.SummaryLoader; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settings.search.Indexable; import com.android.settingslib.NetworkPolicyEditor; import com.android.settingslib.core.AbstractPreferenceController; import com.android.settingslib.net.DataUsageController; import java.util.ArrayList; import java.util.List; /** * Legacy {@link DataUsageSummary} fragment. */ public class DataUsageSummaryLegacy extends DataUsageBaseFragment implements Indexable, DataUsageEditController { private static final String TAG = "DataUsageSummaryLegacy"; static final boolean LOGD = false; public static final String KEY_RESTRICT_BACKGROUND = "restrict_background_legacy"; private static final String KEY_STATUS_HEADER = "status_header"; private static final String KEY_LIMIT_SUMMARY = "limit_summary"; // Mobile data keys public static final String KEY_MOBILE_USAGE_TITLE = "mobile_category"; public static final String KEY_MOBILE_DATA_USAGE_TOGGLE = "data_usage_enable"; public static final String KEY_MOBILE_DATA_USAGE = "cellular_data_usage"; public static final String KEY_MOBILE_BILLING_CYCLE = "billing_preference"; // Wifi keys public static final String KEY_WIFI_USAGE_TITLE = "wifi_category"; public static final String KEY_WIFI_DATA_USAGE = "wifi_data_usage"; private DataUsageController mDataUsageController; private DataUsageInfoController mDataInfoController; private SummaryPreference mSummaryPreference; private Preference mLimitPreference; private NetworkTemplate mDefaultTemplate; private int mDataUsageTemplate; private NetworkPolicyEditor mPolicyEditor; @Override public int getHelpResource() { return R.string.help_url_data_usage; } @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); final Context context = getContext(); NetworkPolicyManager policyManager = NetworkPolicyManager.from(context); mPolicyEditor = new NetworkPolicyEditor(policyManager); boolean hasMobileData = DataUsageUtils.hasMobileData(context); mDataUsageController = new DataUsageController(context); mDataInfoController = new DataUsageInfoController(); int defaultSubId = DataUsageUtils.getDefaultSubscriptionId(context); if (defaultSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { hasMobileData = false; } mDefaultTemplate = DataUsageUtils.getDefaultTemplate(context, defaultSubId); mSummaryPreference = (SummaryPreference) findPreference(KEY_STATUS_HEADER); if (!hasMobileData || !isAdmin()) { removePreference(KEY_RESTRICT_BACKGROUND); } if (hasMobileData) { mLimitPreference = findPreference(KEY_LIMIT_SUMMARY); List<SubscriptionInfo> subscriptions = services.mSubscriptionManager.getActiveSubscriptionInfoList(); if (subscriptions == null || subscriptions.size() == 0) { addMobileSection(defaultSubId); } for (int i = 0; subscriptions != null && i < subscriptions.size(); i++) { SubscriptionInfo subInfo = subscriptions.get(i); if (subscriptions.size() > 1) { addMobileSection(subInfo.getSubscriptionId(), subInfo); } else { addMobileSection(subInfo.getSubscriptionId()); } } mSummaryPreference.setSelectable(true); } else { removePreference(KEY_LIMIT_SUMMARY); mSummaryPreference.setSelectable(false); } boolean hasWifiRadio = DataUsageUtils.hasWifiRadio(context); if (hasWifiRadio) { addWifiSection(); } if (hasEthernet(context)) { addEthernetSection(); } mDataUsageTemplate = hasMobileData ? R.string.cell_data_template : hasWifiRadio ? R.string.wifi_data_template : R.string.ethernet_data_template; setHasOptionsMenu(true); } @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { if (UserManager.get(getContext()).isAdminUser()) { inflater.inflate(R.menu.data_usage, menu); } super.onCreateOptionsMenu(menu, inflater); } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.data_usage_menu_cellular_networks: { final Intent intent = new Intent(Intent.ACTION_MAIN); intent.setComponent(new ComponentName("com.android.phone", "com.android.phone.MobileNetworkSettings")); startActivity(intent); return true; } } return false; } @Override public boolean onPreferenceTreeClick(Preference preference) { if (preference == findPreference(KEY_STATUS_HEADER)) { BillingCycleSettings.BytesEditorFragment.show(this, false); return false; } return super.onPreferenceTreeClick(preference); } @Override protected int getPreferenceScreenResId() { return R.xml.data_usage_legacy; } @Override protected String getLogTag() { return TAG; } @Override protected List<AbstractPreferenceController> createPreferenceControllers(Context context) { return null; } private void addMobileSection(int subId) { addMobileSection(subId, null); } private void addMobileSection(int subId, SubscriptionInfo subInfo) { TemplatePreferenceCategory category = (TemplatePreferenceCategory) inflatePreferences(R.xml.data_usage_cellular); category.setTemplate(getNetworkTemplate(subId), subId, services); category.pushTemplates(services); if (subInfo != null && !TextUtils.isEmpty(subInfo.getDisplayName())) { Preference title = category.findPreference(KEY_MOBILE_USAGE_TITLE); title.setTitle(subInfo.getDisplayName()); } } private void addWifiSection() { TemplatePreferenceCategory category = (TemplatePreferenceCategory) inflatePreferences(R.xml.data_usage_wifi); category.setTemplate(NetworkTemplate.buildTemplateWifiWildcard(), 0, services); } private void addEthernetSection() { TemplatePreferenceCategory category = (TemplatePreferenceCategory) inflatePreferences(R.xml.data_usage_ethernet); category.setTemplate(NetworkTemplate.buildTemplateEthernet(), 0, services); } private Preference inflatePreferences(int resId) { PreferenceScreen rootPreferences = getPreferenceManager().inflateFromResource( getPrefContext(), resId, null); Preference pref = rootPreferences.getPreference(0); rootPreferences.removeAll(); PreferenceScreen screen = getPreferenceScreen(); pref.setOrder(screen.getPreferenceCount()); screen.addPreference(pref); return pref; } private NetworkTemplate getNetworkTemplate(int subscriptionId) { NetworkTemplate mobileAll = NetworkTemplate.buildTemplateMobileAll( services.mTelephonyManager.getSubscriberId(subscriptionId)); return NetworkTemplate.normalize(mobileAll, services.mTelephonyManager.getMergedSubscriberIds()); } @Override public void onResume() { super.onResume(); updateState(); } @VisibleForTesting static CharSequence formatUsage(Context context, String template, long usageLevel) { final float LARGER_SIZE = 1.25f * 1.25f; // (1/0.8)^2 final float SMALLER_SIZE = 1.0f / LARGER_SIZE; // 0.8^2 final int FLAGS = Spannable.SPAN_INCLUSIVE_INCLUSIVE; final Formatter.BytesResult usedResult = Formatter.formatBytes(context.getResources(), usageLevel, Formatter.FLAG_CALCULATE_ROUNDED); final SpannableString enlargedValue = new SpannableString(usedResult.value); enlargedValue.setSpan(new RelativeSizeSpan(LARGER_SIZE), 0, enlargedValue.length(), FLAGS); final SpannableString amountTemplate = new SpannableString( context.getString(com.android.internal.R.string.fileSizeSuffix) .replace("%1$s", "^1").replace("%2$s", "^2")); final CharSequence formattedUsage = TextUtils.expandTemplate(amountTemplate, enlargedValue, usedResult.units); final SpannableString fullTemplate = new SpannableString(template); fullTemplate.setSpan(new RelativeSizeSpan(SMALLER_SIZE), 0, fullTemplate.length(), FLAGS); return TextUtils.expandTemplate(fullTemplate, BidiFormatter.getInstance().unicodeWrap(formattedUsage.toString())); } private void updateState() { DataUsageController.DataUsageInfo info = mDataUsageController.getDataUsageInfo( mDefaultTemplate); Context context = getContext(); mDataInfoController.updateDataLimit(info, services.mPolicyEditor.getPolicy(mDefaultTemplate)); if (mSummaryPreference != null) { mSummaryPreference.setTitle( formatUsage(context, getString(mDataUsageTemplate), info.usageLevel)); final long limit = mDataInfoController.getSummaryLimit(info); mSummaryPreference.setSummary(info.period); if (limit <= 0) { mSummaryPreference.setChartEnabled(false); } else { mSummaryPreference.setChartEnabled(true); mSummaryPreference.setLabels(Formatter.formatFileSize(context, 0), Formatter.formatFileSize(context, limit)); mSummaryPreference.setRatios(info.usageLevel / (float) limit, 0, (limit - info.usageLevel) / (float) limit); } } if (mLimitPreference != null && (info.warningLevel > 0 || info.limitLevel > 0)) { String warning = Formatter.formatFileSize(context, info.warningLevel); String limit = Formatter.formatFileSize(context, info.limitLevel); mLimitPreference.setSummary(getString(info.limitLevel <= 0 ? R.string.cell_warning_only : R.string.cell_warning_and_limit, warning, limit)); } else if (mLimitPreference != null) { mLimitPreference.setSummary(null); } PreferenceScreen screen = getPreferenceScreen(); for (int i = 1; i < screen.getPreferenceCount(); i++) { ((TemplatePreferenceCategory) screen.getPreference(i)).pushTemplates(services); } } @Override public int getMetricsCategory() { return MetricsEvent.DATA_USAGE_SUMMARY; } @Override public NetworkPolicyEditor getNetworkPolicyEditor() { return services.mPolicyEditor; } @Override public NetworkTemplate getNetworkTemplate() { return mDefaultTemplate; } @Override public void updateDataUsage() { updateState(); } private static class SummaryProvider implements SummaryLoader.SummaryProvider { private final Activity mActivity; private final SummaryLoader mSummaryLoader; private final DataUsageController mDataController; public SummaryProvider(Activity activity, SummaryLoader summaryLoader) { mActivity = activity; mSummaryLoader = summaryLoader; mDataController = new DataUsageController(activity); } @Override public void setListening(boolean listening) { if (listening) { DataUsageController.DataUsageInfo info = mDataController.getDataUsageInfo(); String used; if (info == null) { used = Formatter.formatFileSize(mActivity, 0); } else if (info.limitLevel <= 0) { used = Formatter.formatFileSize(mActivity, info.usageLevel); } else { used = Utils.formatPercentage(info.usageLevel, info.limitLevel); } mSummaryLoader.setSummary(this, mActivity.getString(R.string.data_usage_summary_format, used)); } } } public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY = SummaryProvider::new; /** * For search */ public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = new BaseSearchIndexProvider() { @Override public List<SearchIndexableResource> getXmlResourcesToIndex(Context context, boolean enabled) { List<SearchIndexableResource> resources = new ArrayList<>(); SearchIndexableResource resource = new SearchIndexableResource(context); resource.xmlResId = R.xml.data_usage_legacy; resources.add(resource); resource = new SearchIndexableResource(context); resource.xmlResId = R.xml.data_usage_cellular; resources.add(resource); resource = new SearchIndexableResource(context); resource.xmlResId = R.xml.data_usage_wifi; resources.add(resource); return resources; } @Override public List<String> getNonIndexableKeys(Context context) { List<String> keys = super.getNonIndexableKeys(context); if (!DataUsageUtils.hasMobileData(context)) { keys.add(KEY_MOBILE_USAGE_TITLE); keys.add(KEY_MOBILE_DATA_USAGE_TOGGLE); keys.add(KEY_MOBILE_DATA_USAGE); keys.add(KEY_MOBILE_BILLING_CYCLE); } if (!DataUsageUtils.hasWifiRadio(context)) { keys.add(KEY_WIFI_DATA_USAGE); } // This title is named Wifi, and will confuse users. keys.add(KEY_WIFI_USAGE_TITLE); return keys; } }; }