Android/packages_apps_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Avoid ANR of TetherPreferenceController

Browse Source 
Off load the following work from main thread,
- Calculate title
- Calculate summery

This also helps improve the latency.

Also migrate to registerTetheringEventCallback() since
TetheringManager.ACTION_TETHER_STATE_CHANGED is deprecated.

Fix: 311848767
Test: manual - on Network & internet page and turn on / off tethering
Test: unit tests
Change-Id: I6ee182b41ef51f691ea31938142be1a41faf5573
This commit is contained in:
Chaohui Wang
2023-11-28 18:57:04 +08:00
parent 6a3a3e2ac7
commit 880068d23a
8 changed files with 461 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/com/android/settings/network/NetworkDashboardFragment.java
View File

@@ -98,7 +98,6 @@ public class NetworkDashboardFragment extends DashboardFragment implements
final List<AbstractPreferenceController> controllers = new ArrayList<>();
controllers.add(new MobileNetworkSummaryController(context, lifecycle, lifecycleOwner));
controllers.add(new TetherPreferenceController(context, lifecycle));
controllers.add(vpnPreferenceController);
if (internetPreferenceController != null) {
controllers.add(internetPreferenceController);

311
src/com/android/settings/network/TetherPreferenceController.java
View File

@@ -1,311 +0,0 @@
/*
* 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.network;
import static android.os.UserManager.DISALLOW_CONFIG_TETHERING;
import static com.android.settingslib.RestrictedLockUtilsInternal.checkIfRestrictionEnforced;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothPan;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.database.ContentObserver;
import android.net.TetheringManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.UserHandle;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.FeatureFlagUtils;
import android.util.Log;
import androidx.annotation.VisibleForTesting;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.FeatureFlags;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.TetherUtil;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnCreate;
import com.android.settingslib.core.lifecycle.events.OnDestroy;
import com.android.settingslib.core.lifecycle.events.OnPause;
import com.android.settingslib.core.lifecycle.events.OnResume;
import java.util.concurrent.atomic.AtomicReference;
public class TetherPreferenceController extends AbstractPreferenceController implements
PreferenceControllerMixin, LifecycleObserver, OnCreate, OnResume, OnPause, OnDestroy {
private static final String TAG = "TetherPreferenceController";
private static final String KEY_TETHER_SETTINGS = "tether_settings";
private final boolean mAdminDisallowedTetherConfig;
private final AtomicReference<BluetoothPan> mBluetoothPan;
private final BluetoothAdapter mBluetoothAdapter;
private final TetheringManager mTetheringManager;
@VisibleForTesting
final BluetoothProfile.ServiceListener mBtProfileServiceListener =
new android.bluetooth.BluetoothProfile.ServiceListener() {
public void onServiceConnected(int profile, BluetoothProfile proxy) {
if (mBluetoothPan.get() == null) {
mBluetoothPan.set((BluetoothPan) proxy);
}
updateSummary();
}
public void onServiceDisconnected(int profile) {
updateSummary();
}
};
private SettingObserver mAirplaneModeObserver;
private Preference mPreference;
private TetherBroadcastReceiver mTetherReceiver;
private BroadcastReceiver mBluetoothStateReceiver;
@VisibleForTesting(otherwise = VisibleForTesting.NONE)
TetherPreferenceController() {
super(null);
mAdminDisallowedTetherConfig = false;
mBluetoothPan = new AtomicReference<>();
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
mTetheringManager = null;
}
public TetherPreferenceController(Context context, Lifecycle lifecycle) {
super(context);
mBluetoothPan = new AtomicReference<>();
mAdminDisallowedTetherConfig = isTetherConfigDisallowed(context);
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
mTetheringManager = context.getSystemService(TetheringManager.class);
if (lifecycle != null) {
lifecycle.addObserver(this);
}
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(KEY_TETHER_SETTINGS);
if (mPreference != null && !mAdminDisallowedTetherConfig) {
mPreference.setTitle(
com.android.settingslib.Utils.getTetheringLabel(mTetheringManager));
}
}
@Override
public boolean isAvailable() {
return TetherUtil.isTetherAvailable(mContext)
&& !FeatureFlagUtils.isEnabled(mContext, FeatureFlags.TETHER_ALL_IN_ONE);
}
@Override
public void updateState(Preference preference) {
updateSummary();
}
@Override
public String getPreferenceKey() {
return KEY_TETHER_SETTINGS;
}
@Override
public void onCreate(Bundle savedInstanceState) {
if (mBluetoothAdapter != null &&
mBluetoothAdapter.getState() == BluetoothAdapter.STATE_ON) {
mBluetoothAdapter.getProfileProxy(mContext, mBtProfileServiceListener,
BluetoothProfile.PAN);
}
if (mBluetoothStateReceiver == null) {
mBluetoothStateReceiver = new BluetoothStateReceiver();
mContext.registerReceiver(
mBluetoothStateReceiver,
new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED));
}
}
@Override
public void onResume() {
if (mAirplaneModeObserver == null) {
mAirplaneModeObserver = new SettingObserver();
}
if (mTetherReceiver == null) {
mTetherReceiver = new TetherBroadcastReceiver();
}
mContext.registerReceiver(
mTetherReceiver, new IntentFilter(TetheringManager.ACTION_TETHER_STATE_CHANGED));
mContext.getContentResolver()
.registerContentObserver(mAirplaneModeObserver.uri, false, mAirplaneModeObserver);
}
@Override
public void onPause() {
if (mAirplaneModeObserver != null) {
mContext.getContentResolver().unregisterContentObserver(mAirplaneModeObserver);
}
if (mTetherReceiver != null) {
mContext.unregisterReceiver(mTetherReceiver);
}
}
@Override
public void onDestroy() {
final BluetoothProfile profile = mBluetoothPan.getAndSet(null);
if (profile != null && mBluetoothAdapter != null) {
mBluetoothAdapter.closeProfileProxy(BluetoothProfile.PAN, profile);
}
if (mBluetoothStateReceiver != null) {
mContext.unregisterReceiver(mBluetoothStateReceiver);
mBluetoothStateReceiver = null;
}
}
public static boolean isTetherConfigDisallowed(Context context) {
return checkIfRestrictionEnforced(
context, DISALLOW_CONFIG_TETHERING, UserHandle.myUserId()) != null;
}
@VisibleForTesting
void updateSummary() {
if (mPreference == null) {
// Preference is not ready yet.
return;
}
String[] allTethered = mTetheringManager.getTetheredIfaces();
String[] wifiTetherRegex = mTetheringManager.getTetherableWifiRegexs();
String[] bluetoothRegex = mTetheringManager.getTetherableBluetoothRegexs();
boolean hotSpotOn = false;
boolean tetherOn = false;
if (allTethered != null) {
if (wifiTetherRegex != null) {
for (String tethered : allTethered) {
for (String regex : wifiTetherRegex) {
if (tethered.matches(regex)) {
hotSpotOn = true;
break;
}
}
}
}
if (allTethered.length > 1) {
// We have more than 1 tethered connection
tetherOn = true;
} else if (allTethered.length == 1) {
// We have more than 1 tethered, it's either wifiTether (hotspot), or other type of
// tether.
tetherOn = !hotSpotOn;
} else {
// No tethered connection.
tetherOn = false;
}
}
if (!tetherOn
&& bluetoothRegex != null && bluetoothRegex.length > 0
&& mBluetoothAdapter != null
&& mBluetoothAdapter.getState() == BluetoothAdapter.STATE_ON) {
// Check bluetooth state. It's not included in mTetheringManager.getTetheredIfaces.
final BluetoothPan pan = mBluetoothPan.get();
tetherOn = pan != null && pan.isTetheringOn();
}
if (!hotSpotOn && !tetherOn) {
// Both off
updateSummaryToOff();
} else if (hotSpotOn && tetherOn) {
// Both on
mPreference.setSummary(R.string.tether_settings_summary_hotspot_on_tether_on);
} else if (hotSpotOn) {
mPreference.setSummary(R.string.tether_settings_summary_hotspot_on_tether_off);
} else {
mPreference.setSummary(R.string.tether_settings_summary_hotspot_off_tether_on);
}
}
private void updateSummaryToOff() {
if (mPreference == null) {
// Preference is not ready yet.
return;
}
mPreference.setSummary(R.string.tether_preference_summary_off);
}
class SettingObserver extends ContentObserver {
public final Uri uri;
public SettingObserver() {
super(new Handler());
uri = Settings.Global.getUriFor(Settings.Global.AIRPLANE_MODE_ON);
}
@Override
public void onChange(boolean selfChange, Uri uri) {
super.onChange(selfChange, uri);
if (this.uri.equals(uri)) {
boolean isAirplaneMode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.AIRPLANE_MODE_ON, 0) != 0;
if (isAirplaneMode) {
// Airplane mode is on. Update summary to say tether is OFF directly. We cannot
// go through updateSummary() because turning off tether takes time, and we
// might still get "ON" status when rerun updateSummary(). So, just say it's off
updateSummaryToOff();
}
}
}
}
@VisibleForTesting
class TetherBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
updateSummary();
}
}
private class BluetoothStateReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
Log.i(TAG, "onReceive: action: " + action);
if (TextUtils.equals(action, BluetoothAdapter.ACTION_STATE_CHANGED)) {
final int state =
intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
Log.i(TAG, "onReceive: state: " + BluetoothAdapter.nameForState(state));
final BluetoothProfile profile = mBluetoothPan.get();
switch(state) {
case BluetoothAdapter.STATE_ON:
if (profile == null && mBluetoothAdapter != null) {
mBluetoothAdapter.getProfileProxy(mContext, mBtProfileServiceListener,
BluetoothProfile.PAN);
}
break;
}
}
}
}
}

102
src/com/android/settings/network/TetherPreferenceController.kt Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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
import android.content.Context
import android.net.TetheringManager
import android.os.UserHandle
import android.os.UserManager
import android.util.FeatureFlagUtils
import androidx.annotation.StringRes
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.core.BasePreferenceController
import com.android.settings.core.FeatureFlags
import com.android.settingslib.RestrictedLockUtilsInternal
import com.android.settingslib.TetherUtil
import com.android.settingslib.Utils
import com.android.settingslib.spa.framework.util.collectLatestWithLifecycle
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
class TetherPreferenceController(context: Context, key: String) :
BasePreferenceController(context, key) {
private val tetheredRepository = TetheredRepository(context)
private val tetheringManager = mContext.getSystemService(TetheringManager::class.java)!!
private var preference: Preference? = null
override fun getAvailabilityStatus() =
if (TetherUtil.isTetherAvailable(mContext)
&& !FeatureFlagUtils.isEnabled(mContext, FeatureFlags.TETHER_ALL_IN_ONE)
) {
AVAILABLE
} else {
CONDITIONALLY_UNAVAILABLE
}
override fun displayPreference(screen: PreferenceScreen) {
super.displayPreference(screen)
preference = screen.findPreference(preferenceKey)
}
override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
getTitleResId()?.let { preference?.setTitle(it) }
}
}
tetheredRepository.tetheredTypesFlow().collectLatestWithLifecycle(viewLifecycleOwner) {
preference?.setSummary(getSummaryResId(it))
}
}
private suspend fun getTitleResId(): Int? = withContext(Dispatchers.Default) {
if (isTetherConfigDisallowed(mContext)) null
else Utils.getTetheringLabel(tetheringManager)
}
@VisibleForTesting
@StringRes
fun getSummaryResId(tetheredTypes: Set<Int>): Int {
val hotSpotOn = TetheringManager.TETHERING_WIFI in tetheredTypes
val tetherOn = tetheredTypes.any { it != TetheringManager.TETHERING_WIFI }
return when {
hotSpotOn && tetherOn -> R.string.tether_settings_summary_hotspot_on_tether_on
hotSpotOn -> R.string.tether_settings_summary_hotspot_on_tether_off
tetherOn -> R.string.tether_settings_summary_hotspot_off_tether_on
else -> R.string.tether_preference_summary_off
}
}
companion object {
@JvmStatic
fun isTetherConfigDisallowed(context: Context?): Boolean =
RestrictedLockUtilsInternal.checkIfRestrictionEnforced(
context, UserManager.DISALLOW_CONFIG_TETHERING, UserHandle.myUserId()
) != null
}
}

102
src/com/android/settings/network/TetheredRepository.kt Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothManager
import android.bluetooth.BluetoothPan
import android.bluetooth.BluetoothProfile
import android.content.Context
import android.content.IntentFilter
import android.net.TetheringInterface
import android.net.TetheringManager
import com.android.settingslib.spaprivileged.framework.common.broadcastReceiverFlow
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.asExecutor
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.conflate
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.flow.merge
import kotlinx.coroutines.launch
class TetheredRepository(private val context: Context) {
private val tetheringManager = context.getSystemService(TetheringManager::class.java)!!
private val adapter = context.getSystemService(BluetoothManager::class.java)!!.adapter
fun tetheredTypesFlow(): Flow<Set<Int>> =
combine(
tetheredInterfacesFlow(),
isBluetoothTetheringOnFlow(),
) { tetheringInterfaces, isBluetoothTetheringOn ->
val mutableSet = tetheringInterfaces.map { it.type }.toMutableSet()
if (isBluetoothTetheringOn) mutableSet += TetheringManager.TETHERING_BLUETOOTH
mutableSet
}.conflate().flowOn(Dispatchers.Default)
private fun tetheredInterfacesFlow(): Flow<Set<TetheringInterface>> = callbackFlow {
val callback = object : TetheringManager.TetheringEventCallback {
override fun onTetheredInterfacesChanged(interfaces: Set<TetheringInterface>) {
trySend(interfaces)
}
}
tetheringManager.registerTetheringEventCallback(Dispatchers.Default.asExecutor(), callback)
awaitClose { tetheringManager.unregisterTetheringEventCallback(callback) }
}.conflate().flowOn(Dispatchers.Default)
@OptIn(ExperimentalCoroutinesApi::class)
private fun isBluetoothTetheringOnFlow(): Flow<Boolean> =
merge(
flowOf(null), // kick an initial value
context.broadcastReceiverFlow(IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)),
).flatMapLatest {
if (adapter.getState() == BluetoothAdapter.STATE_ON) {
isBluetoothPanTetheringOnFlow()
} else {
flowOf(false)
}
}.conflate().flowOn(Dispatchers.Default)
private fun isBluetoothPanTetheringOnFlow() = callbackFlow {
var connectedProxy: BluetoothProfile? = null
val listener = object : BluetoothProfile.ServiceListener {
override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
connectedProxy = proxy
launch(Dispatchers.Default) {
trySend((proxy as BluetoothPan).isTetheringOn)
}
}
override fun onServiceDisconnected(profile: Int) {}
}
adapter.getProfileProxy(context, listener, BluetoothProfile.PAN)
awaitClose {
connectedProxy?.let { adapter.closeProfileProxy(BluetoothProfile.PAN, it) }
}
}.conflate().flowOn(Dispatchers.Default)
}