PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix DataUsagePreferenceController ANR

Browse Source 
Offload calculation work from main thread to fix.

Fix: 286082055
Test: manual - on Mobile Settings page
Test: unit test
Change-Id: I7865823d6af2c812afa35d047bd79b60ae4b0fb7
This commit is contained in:
Chaohui Wang
2023-07-04 00:12:42 +08:00
parent 04b1932b25
commit d42cc8e5e2
5 changed files with 307 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
src/com/android/settings/network/telephony/DataUsagePreferenceController.java
View File

@@ -1,151 +0,0 @@
/*
* Copyright (C) 2018 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.network.telephony;
import android.content.Context;
import android.content.Intent;
import android.net.NetworkTemplate;
import android.provider.Settings;
import android.telephony.SubscriptionManager;
import android.text.TextUtils;
import android.util.Log;
import androidx.preference.Preference;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.datausage.DataUsageUtils;
import com.android.settings.datausage.lib.DataUsageLib;
import com.android.settingslib.net.DataUsageController;
import com.android.settingslib.utils.ThreadUtils;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicReference;
/**
* Preference controller for "Data usage"
*/
public class DataUsagePreferenceController extends TelephonyBasePreferenceController {
private static final String LOG_TAG = "DataUsagePreferCtrl";
private Future<NetworkTemplate> mTemplateFuture;
private AtomicReference<NetworkTemplate> mTemplate;
private Future<Long> mHistoricalUsageLevel;
public DataUsagePreferenceController(Context context, String key) {
super(context, key);
mTemplate = new AtomicReference<NetworkTemplate>();
}
@Override
public int getAvailabilityStatus(int subId) {
return (SubscriptionManager.isValidSubscriptionId(subId))
&& DataUsageUtils.hasMobileData(mContext)
? AVAILABLE
: AVAILABLE_UNSEARCHABLE;
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (!TextUtils.equals(preference.getKey(), getPreferenceKey())) {
return false;
}
final Intent intent = new Intent(Settings.ACTION_MOBILE_DATA_USAGE);
intent.putExtra(Settings.EXTRA_NETWORK_TEMPLATE, getNetworkTemplate());
intent.putExtra(Settings.EXTRA_SUB_ID, mSubId);
mContext.startActivity(intent);
return true;
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
if (!SubscriptionManager.isValidSubscriptionId(mSubId)) {
preference.setEnabled(false);
return;
}
final CharSequence summary = getDataUsageSummary(mContext, mSubId);
if (summary == null) {
preference.setEnabled(false);
} else {
preference.setEnabled(true);
preference.setSummary(summary);
}
}
public void init(int subId) {
mSubId = subId;
mTemplate.set(null);
mTemplateFuture = ThreadUtils.postOnBackgroundThread(()
-> fetchMobileTemplate(mContext, mSubId));
}
private NetworkTemplate fetchMobileTemplate(Context context, int subId) {
if (!SubscriptionManager.isValidSubscriptionId(subId)) {
return null;
}
return DataUsageLib.getMobileTemplate(context, subId);
}
private NetworkTemplate getNetworkTemplate() {
if (!SubscriptionManager.isValidSubscriptionId(mSubId)) {
return null;
}
NetworkTemplate template = mTemplate.get();
if (template != null) {
return template;
}
try {
template = mTemplateFuture.get();
mTemplate.set(template);
} catch (ExecutionException | InterruptedException | NullPointerException exception) {
Log.e(LOG_TAG, "Fail to get data usage template", exception);
}
return template;
}
@VisibleForTesting
DataUsageController.DataUsageInfo getDataUsageInfo(DataUsageController controller) {
return controller.getDataUsageInfo(getNetworkTemplate());
}
private CharSequence getDataUsageSummary(Context context, int subId) {
final DataUsageController controller = new DataUsageController(context);
controller.setSubscriptionId(subId);
mHistoricalUsageLevel = ThreadUtils.postOnBackgroundThread(() ->
controller.getHistoricalUsageLevel(getNetworkTemplate()));
final DataUsageController.DataUsageInfo usageInfo = getDataUsageInfo(controller);
long usageLevel = usageInfo.usageLevel;
if (usageLevel <= 0L) {
try {
usageLevel = mHistoricalUsageLevel.get();
} catch (Exception exception) {
}
}
if (usageLevel <= 0L) {
return null;
}
return context.getString(R.string.data_usage_template,
DataUsageUtils.formatDataUsage(context, usageLevel), usageInfo.period);
}
}

126
src/com/android/settings/network/telephony/DataUsagePreferenceController.kt Normal file
View File

@@ -0,0 +1,126 @@
/*
* Copyright (C) 2023 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.network.telephony
import android.content.Context
import android.content.Intent
import android.net.NetworkTemplate
import android.provider.Settings
import android.telephony.SubscriptionManager
import androidx.annotation.VisibleForTesting
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.preference.Preference
import androidx.preference.PreferenceScreen
import com.android.settings.R
import com.android.settings.datausage.DataUsageUtils
import com.android.settingslib.net.DataUsageController
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
/**
* Preference controller for "Data usage"
*/
class DataUsagePreferenceController(context: Context, key: String) :
TelephonyBasePreferenceController(context, key) {
private lateinit var preference: Preference
private var networkTemplate: NetworkTemplate? = null
@VisibleForTesting
var dataUsageControllerFactory: (Context) -> DataUsageController = { DataUsageController(it) }
fun init(subId: Int) {
mSubId = subId
}
override fun getAvailabilityStatus(subId: Int): Int = when {
SubscriptionManager.isValidSubscriptionId(subId) &&
DataUsageUtils.hasMobileData(mContext) -> AVAILABLE
else -> AVAILABLE_UNSEARCHABLE
}
override fun displayPreference(screen: PreferenceScreen) {
super.displayPreference(screen)
preference = screen.findPreference(preferenceKey)!!
}
fun whenViewCreated(viewLifecycleOwner: LifecycleOwner) {
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
update()
}
}
}
override fun handlePreferenceTreeClick(preference: Preference): Boolean {
if (preference.key != preferenceKey || networkTemplate == null) return false
val intent = Intent(Settings.ACTION_MOBILE_DATA_USAGE).apply {
putExtra(Settings.EXTRA_NETWORK_TEMPLATE, networkTemplate)
putExtra(Settings.EXTRA_SUB_ID, mSubId)
}
mContext.startActivity(intent)
return true
}
private suspend fun update() {
val summary = withContext(Dispatchers.Default) {
networkTemplate = getNetworkTemplate()
getDataUsageSummary()
}
if (summary == null) {
preference.isEnabled = false
} else {
preference.isEnabled = true
preference.summary = summary
}
}
private fun getNetworkTemplate(): NetworkTemplate? = when {
SubscriptionManager.isValidSubscriptionId(mSubId) -> {
DataUsageUtils.getMobileTemplate(mContext, mSubId)
}
else -> null
}
private fun getDataUsageSummary(): String? {
val networkTemplate = networkTemplate ?: return null
val controller = dataUsageControllerFactory(mContext).apply {
setSubscriptionId(mSubId)
}
val usageInfo = controller.getDataUsageInfo(networkTemplate)
if (usageInfo != null && usageInfo.usageLevel > 0) {
return mContext.getString(
R.string.data_usage_template,
DataUsageUtils.formatDataUsage(mContext, usageInfo.usageLevel),
usageInfo.period,
)
}
return controller.getHistoricalUsageLevel(networkTemplate).takeIf { it > 0 }?.let {
mContext.getString(
R.string.data_used_template,
DataUsageUtils.formatDataUsage(mContext, it),
)
}
}
}

9
src/com/android/settings/network/telephony/MobileNetworkSettings.java
View File

@@ -31,7 +31,10 @@ import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import androidx.preference.Preference;
@@ -327,6 +330,12 @@ public class MobileNetworkSettings extends AbstractMobileNetworkSettings impleme
onRestoreInstance(icicle);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
use(DataUsagePreferenceController.class).whenViewCreated(getViewLifecycleOwner());
}
@Override
public void onResume() {
super.onResume();