ethernet: rename mDefaultInterface to mTetheringInterface
The name "default interface" is misleading as "default" is an overloaded
term that can imply many things. Renaming it to mTetheringInterface, so
it becomes clearer what this interface is used for. I briefly considered
naming it mInterfaceUsedForTethering, but then
mInterfaceUsedForTetheringMode becomes annoyingly long. Decided to go
with mTetheringInterface and mTetheringInterfaceMode instead. This
change also gets rid of all mentions of default in the context of
tethering.
Test: m
Bug: 236280707
Change-Id: Ia5ddbdc5a8b258d7fb050126288b82a1c8cf666d
diff --git a/service-t/src/com/android/server/ethernet/EthernetTracker.java b/service-t/src/com/android/server/ethernet/EthernetTracker.java
index f3e49f8..97d7cbf 100644
--- a/service-t/src/com/android/server/ethernet/EthernetTracker.java
+++ b/service-t/src/com/android/server/ethernet/EthernetTracker.java
@@ -127,9 +127,11 @@
private final TetheredInterfaceRequestList mTetheredInterfaceRequests =
new TetheredInterfaceRequestList();
- // Used only on the handler thread
- private String mDefaultInterface;
- private int mDefaultInterfaceMode = INTERFACE_MODE_CLIENT;
+ // The first interface discovered is set as the mTetheringInterface. It is the interface that is
+ // returned when a tethered interface is requested; until then, it remains in client mode. Its
+ // current mode is reflected in mTetheringInterfaceMode.
+ private String mTetheringInterface;
+ private int mTetheringInterfaceMode = INTERFACE_MODE_CLIENT;
// Tracks whether clients were notified that the tethered interface is available
private boolean mTetheredInterfaceWasAvailable = false;
private volatile IpConfiguration mIpConfigForDefaultInterface;
@@ -140,7 +142,7 @@
RemoteCallbackList<ITetheredInterfaceCallback> {
@Override
public void onCallbackDied(ITetheredInterfaceCallback cb, Object cookie) {
- mHandler.post(EthernetTracker.this::maybeUntetherDefaultInterface);
+ mHandler.post(EthernetTracker.this::maybeUntetherInterface);
}
}
@@ -165,7 +167,7 @@
}
private void onNewLink(String ifname, boolean linkUp) {
- if (!mFactory.hasInterface(ifname) && !ifname.equals(mDefaultInterface)) {
+ if (!mFactory.hasInterface(ifname) && !ifname.equals(mTetheringInterface)) {
Log.i(TAG, "onInterfaceAdded, iface: " + ifname);
maybeTrackInterface(ifname);
}
@@ -471,21 +473,21 @@
// Remote process has already died
return;
}
- if (mDefaultInterfaceMode == INTERFACE_MODE_SERVER) {
+ if (mTetheringInterfaceMode == INTERFACE_MODE_SERVER) {
if (mTetheredInterfaceWasAvailable) {
- notifyTetheredInterfaceAvailable(callback, mDefaultInterface);
+ notifyTetheredInterfaceAvailable(callback, mTetheringInterface);
}
return;
}
- setDefaultInterfaceMode(INTERFACE_MODE_SERVER);
+ setTetheringInterfaceMode(INTERFACE_MODE_SERVER);
});
}
public void releaseTetheredInterface(ITetheredInterfaceCallback callback) {
mHandler.post(() -> {
mTetheredInterfaceRequests.unregister(callback);
- maybeUntetherDefaultInterface();
+ maybeUntetherInterface();
});
}
@@ -505,21 +507,21 @@
}
}
- private void maybeUntetherDefaultInterface() {
+ private void maybeUntetherInterface() {
if (mTetheredInterfaceRequests.getRegisteredCallbackCount() > 0) return;
- if (mDefaultInterfaceMode == INTERFACE_MODE_CLIENT) return;
- setDefaultInterfaceMode(INTERFACE_MODE_CLIENT);
+ if (mTetheringInterfaceMode == INTERFACE_MODE_CLIENT) return;
+ setTetheringInterfaceMode(INTERFACE_MODE_CLIENT);
}
- private void setDefaultInterfaceMode(int mode) {
- Log.d(TAG, "Setting default interface mode to " + mode);
- mDefaultInterfaceMode = mode;
- if (mDefaultInterface != null) {
- removeInterface(mDefaultInterface);
- addInterface(mDefaultInterface);
+ private void setTetheringInterfaceMode(int mode) {
+ Log.d(TAG, "Setting tethering interface mode to " + mode);
+ mTetheringInterfaceMode = mode;
+ if (mTetheringInterface != null) {
+ removeInterface(mTetheringInterface);
+ addInterface(mTetheringInterface);
// when this broadcast is sent, any calls to notifyTetheredInterfaceAvailable or
// notifyTetheredInterfaceUnavailable have already happened
- broadcastInterfaceStateChange(mDefaultInterface);
+ broadcastInterfaceStateChange(mTetheringInterface);
}
}
@@ -548,8 +550,8 @@
}
private int getInterfaceMode(final String iface) {
- if (iface.equals(mDefaultInterface)) {
- return mDefaultInterfaceMode;
+ if (iface.equals(mTetheringInterface)) {
+ return mTetheringInterfaceMode;
}
return INTERFACE_MODE_CLIENT;
}
@@ -561,8 +563,8 @@
private void stopTrackingInterface(String iface) {
removeInterface(iface);
- if (iface.equals(mDefaultInterface)) {
- mDefaultInterface = null;
+ if (iface.equals(mTetheringInterface)) {
+ mTetheringInterface = null;
}
broadcastInterfaceStateChange(iface);
}
@@ -630,7 +632,9 @@
}
private void maybeUpdateServerModeInterfaceState(String iface, boolean available) {
- if (available == mTetheredInterfaceWasAvailable || !iface.equals(mDefaultInterface)) return;
+ if (available == mTetheredInterfaceWasAvailable || !iface.equals(mTetheringInterface)) {
+ return;
+ }
Log.d(TAG, (available ? "Tracking" : "No longer tracking")
+ " interface in server mode: " + iface);
@@ -655,15 +659,15 @@
// If we don't already track this interface, and if this interface matches
// our regex, start tracking it.
- if (mFactory.hasInterface(iface) || iface.equals(mDefaultInterface)) {
+ if (mFactory.hasInterface(iface) || iface.equals(mTetheringInterface)) {
if (DBG) Log.w(TAG, "Ignoring already-tracked interface " + iface);
return;
}
if (DBG) Log.i(TAG, "maybeTrackInterface: " + iface);
- // Do not make an interface default if it has configured NetworkCapabilities.
- if (mDefaultInterface == null && !mNetworkCapabilities.containsKey(iface)) {
- mDefaultInterface = iface;
+ // Do not use an interface for tethering if it has configured NetworkCapabilities.
+ if (mTetheringInterface == null && !mNetworkCapabilities.containsKey(iface)) {
+ mTetheringInterface = iface;
}
if (mIpConfigForDefaultInterface != null) {
@@ -961,8 +965,8 @@
pw.println("Ethernet State: "
+ (mEthernetState == ETHERNET_STATE_ENABLED ? "enabled" : "disabled"));
pw.println("Ethernet interface name filter: " + mIfaceMatch);
- pw.println("Default interface: " + mDefaultInterface);
- pw.println("Default interface mode: " + mDefaultInterfaceMode);
+ pw.println("Interface used for tethering: " + mTetheringInterface);
+ pw.println("Tethering interface mode: " + mTetheringInterfaceMode);
pw.println("Tethered interface requests: "
+ mTetheredInterfaceRequests.getRegisteredCallbackCount());
pw.println("Listeners: " + mListeners.getRegisteredCallbackCount());