diff --git a/AndroidManifest.xml b/AndroidManifest.xml index c526d6fc245..58674222a59 100644 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -2404,7 +2404,21 @@ + android:enabled="false"> + + + + + + + + + @@ -2414,9 +2428,9 @@ + android:value="com.android.settings.category.ia.wireless" /> + android:value="com.android.settings.datausage.DataUsageSummaryLegacy" /> + + + + + + + + + + + + + + + diff --git a/src/com/android/settings/Settings.java b/src/com/android/settings/Settings.java index 741bfda4a5a..b9626727ea1 100644 --- a/src/com/android/settings/Settings.java +++ b/src/com/android/settings/Settings.java @@ -80,6 +80,7 @@ public class Settings extends SettingsActivity { public static class DeviceAdminSettingsActivity extends SettingsActivity { /* empty */ } public static class DataPlanUsageSummaryActivity extends SettingsActivity { /* empty */ } public static class DataUsageSummaryActivity extends SettingsActivity { /* empty */ } + public static class DataUsageSummaryLegacyActivity extends SettingsActivity { /* empty */ } public static class MobileDataUsageListActivity extends SettingsActivity { /* empty */ } public static class ConfigureWifiSettingsActivity extends SettingsActivity { /* empty */ } public static class SavedAccessPointsSettingsActivity extends SettingsActivity { /* empty */ } diff --git a/src/com/android/settings/SettingsActivity.java b/src/com/android/settings/SettingsActivity.java index 3c18efb5f6b..66e587ff839 100644 --- a/src/com/android/settings/SettingsActivity.java +++ b/src/com/android/settings/SettingsActivity.java @@ -44,6 +44,7 @@ import android.support.v7.preference.Preference; import android.support.v7.preference.PreferenceManager; import android.text.TextUtils; import android.transition.TransitionManager; +import android.util.FeatureFlagUtils; import android.util.Log; import android.view.View; import android.view.View.OnClickListener; @@ -55,6 +56,7 @@ import com.android.internal.util.ArrayUtils; import com.android.settings.Settings.WifiSettingsActivity; import com.android.settings.applications.manageapplications.ManageApplications; import com.android.settings.backup.BackupSettingsActivity; +import com.android.settings.core.FeatureFlags; import com.android.settings.core.gateway.SettingsGateway; import com.android.settings.dashboard.DashboardFeatureProvider; import com.android.settings.dashboard.DashboardSummary; @@ -819,6 +821,19 @@ public class SettingsActivity extends SettingsDrawerActivity Settings.PowerUsageSummaryLegacyActivity.class.getName()), mBatteryPresent && !isBatterySettingsV2Enabled, isAdmin) || somethingChanged; + final boolean isDataUsageSettingsV2Enabled = + FeatureFlagUtils.isEnabled(this, FeatureFlags.DATA_USAGE_SETTINGS_V2); + // Enable new data usage page if v2 enabled + somethingChanged = setTileEnabled(new ComponentName(packageName, + Settings.DataUsageSummaryActivity.class.getName()), + Utils.isBandwidthControlEnabled() && isDataUsageSettingsV2Enabled, isAdmin) + || somethingChanged; + // Enable legacy data usage page if v2 disabled + somethingChanged = setTileEnabled(new ComponentName(packageName, + Settings.DataUsageSummaryLegacyActivity.class.getName()), + Utils.isBandwidthControlEnabled() && !isDataUsageSettingsV2Enabled, isAdmin) + || somethingChanged; + somethingChanged = setTileEnabled(new ComponentName(packageName, Settings.UserSettingsActivity.class.getName()), UserHandle.MU_ENABLED && UserManager.supportsMultipleUsers() diff --git a/src/com/android/settings/core/FeatureFlags.java b/src/com/android/settings/core/FeatureFlags.java index 8fa1bb3ab28..fd756dfd40e 100644 --- a/src/com/android/settings/core/FeatureFlags.java +++ b/src/com/android/settings/core/FeatureFlags.java @@ -26,4 +26,5 @@ public class FeatureFlags { public static final String ZONE_PICKER_V2 = "settings_zone_picker_v2"; public static final String ABOUT_PHONE_V2 = "settings_about_phone_v2"; public static final String BLUETOOTH_WHILE_DRIVING = "settings_bluetooth_while_driving"; + public static final String DATA_USAGE_SETTINGS_V2 = "settings_data_usage_v2"; } diff --git a/src/com/android/settings/core/gateway/SettingsGateway.java b/src/com/android/settings/core/gateway/SettingsGateway.java index f43c3c8964f..105a286ecb4 100644 --- a/src/com/android/settings/core/gateway/SettingsGateway.java +++ b/src/com/android/settings/core/gateway/SettingsGateway.java @@ -62,6 +62,7 @@ import com.android.settings.connecteddevice.usb.UsbDetailsFragment; import com.android.settings.datausage.DataPlanUsageSummary; import com.android.settings.datausage.DataUsageList; import com.android.settings.datausage.DataUsageSummary; +import com.android.settings.datausage.DataUsageSummaryLegacy; import com.android.settings.deletionhelper.AutomaticStorageManagerSettings; import com.android.settings.development.DevelopmentSettingsDashboardFragment; import com.android.settings.deviceinfo.DeviceInfoSettings; @@ -189,6 +190,7 @@ public class SettingsGateway { CryptKeeperSettings.class.getName(), DataPlanUsageSummary.class.getName(), DataUsageSummary.class.getName(), + DataUsageSummaryLegacy.class.getName(), DreamSettings.class.getName(), UserSettings.class.getName(), NotificationAccessSettings.class.getName(), diff --git a/src/com/android/settings/datausage/DataUsageSummaryLegacy.java b/src/com/android/settings/datausage/DataUsageSummaryLegacy.java new file mode 100644 index 00000000000..6a241ebc506 --- /dev/null +++ b/src/com/android/settings/datausage/DataUsageSummaryLegacy.java @@ -0,0 +1,408 @@ +/* + * 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"; + + 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 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 getPreferenceControllers(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 getXmlResourcesToIndex(Context context, + boolean enabled) { + List resources = new ArrayList<>(); + SearchIndexableResource resource = new SearchIndexableResource(context); + resource.xmlResId = R.xml.data_usage; + 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 getNonIndexableKeys(Context context) { + List 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; + } + }; +} diff --git a/src/com/android/settings/search/SearchIndexableResourcesImpl.java b/src/com/android/settings/search/SearchIndexableResourcesImpl.java index bcf412c5554..4df421c77c4 100644 --- a/src/com/android/settings/search/SearchIndexableResourcesImpl.java +++ b/src/com/android/settings/search/SearchIndexableResourcesImpl.java @@ -22,6 +22,7 @@ import com.android.settings.DateTimeSettings; import com.android.settings.DisplaySettings; import com.android.settings.LegalSettings; import com.android.settings.connecteddevice.ConnectedDeviceDashboardFragmentOld; +import com.android.settings.datausage.DataUsageSummaryLegacy; import com.android.settings.deviceinfo.aboutphone.MyDeviceInfoFragment; import com.android.settings.accessibility.AccessibilitySettings; import com.android.settings.accessibility.AccessibilityShortcutPreferenceFragment; @@ -112,6 +113,7 @@ public class SearchIndexableResourcesImpl implements SearchIndexableResources { addIndex(BluetoothSettings.class); addIndex(SimSettings.class); addIndex(DataUsageSummary.class); + addIndex(DataUsageSummaryLegacy.class); addIndex(ScreenZoomSettings.class); addIndex(DisplaySettings.class); addIndex(AmbientDisplaySettings.class); diff --git a/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryLegacyTest.java b/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryLegacyTest.java new file mode 100644 index 00000000000..ad1defb003a --- /dev/null +++ b/tests/robotests/src/com/android/settings/datausage/DataUsageSummaryLegacyTest.java @@ -0,0 +1,85 @@ +/* + * 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 static com.google.common.truth.Truth.assertThat; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.net.ConnectivityManager; +import android.net.wifi.WifiConfiguration; +import android.net.wifi.WifiManager; +import android.text.format.Formatter; + +import com.android.settings.R; +import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settings.testutils.shadow.SettingsShadowResources; +import com.android.settingslib.NetworkPolicyEditor; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; +import org.robolectric.util.ReflectionHelpers; + +import java.util.ArrayList; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class DataUsageSummaryLegacyTest { + @Mock + private ConnectivityManager mManager; + private Context mContext; + + /** + * This set up is contrived to get a passing test so that the build doesn't block without tests. + * These tests should be updated as code gets refactored to improve testability. + */ + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + ShadowApplication shadowContext = ShadowApplication.getInstance(); + shadowContext.setSystemService(Context.CONNECTIVITY_SERVICE, mManager); + mContext = shadowContext.getApplicationContext(); + when(mManager.isNetworkSupported(anyInt())).thenReturn(true); + } + + @Test + @Config(shadows = { + SettingsShadowResources.class, + SettingsShadowResources.SettingsShadowTheme.class + }) + public void formatUsage_shouldLookLikeFormatFileSize() { + SettingsShadowResources.overrideResource(com.android.internal.R.string.fileSizeSuffix, + "%1$s %2$s"); + final long usage = 2147483648L; // 2GB + final String formattedUsage = + DataUsageSummaryLegacy.formatUsage(mContext, "^1", usage).toString(); + final String formattedAsFileSize = Formatter.formatFileSize(mContext, usage); + assertThat(formattedUsage).isEqualTo(formattedAsFileSize); + } +}