Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bfd3722e authored by Nikhil Nayunigari's avatar Nikhil Nayunigari
Browse files

Changes to add Ethernet settings row item 

Adds EthernetSettings row item to NetworkProviderSettings and its
controller.

Flag: com.android.settings.connectivity.ethernet_settings

Test: atest
SettingsRoboTests:
com.android.settings.network.EthernetSwitchPreferenceControllerTest

Change-Id: I27965ad0c8563657b17e0aa6d3bd19b97fcf5615
parent 63242bc3

Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -114,8 +114,8 @@ android_library { 
        "setupdesign-lottie-loading-layout",

        "device_policy_aconfig_flags_lib",

        "keyboard_flags_lib",

        "settings_connectivity_flags",

        "com_android_systemui_flags_lib",

        "settings_connectivity_flags_lib",

    ],



    plugins: [

res/xml/network_provider_settings.xml

+6 −0
Original line number Diff line number Diff line
@@ -36,6 +36,12 @@ 
        android:layout="@layout/airplane_mode_message_preference"

        settings:allowDividerBelow="true"/>



    <com.android.settingslib.RestrictedSwitchPreference

        android:key="main_toggle_ethernet"

        android:title="@string/ethernet"

        settings:restrictedSwitchSummary="@string/not_allowed_by_ent"

        settings:allowDividerAbove="true"/>



    <Preference

        android:key="connected_ethernet_network"

        android:title="@string/ethernet"

src/com/android/settings/network/NetworkProviderSettings.java

+20 −0
Original line number Diff line number Diff line
@@ -69,6 +69,7 @@ import com.android.settings.dashboard.RestrictedDashboardFragment; 
import com.android.settings.datausage.DataUsagePreference;

import com.android.settings.datausage.DataUsageUtils;

import com.android.settings.location.WifiScanningFragment;

import com.android.settings.network.ethernet.EthernetSwitchPreferenceController;

import com.android.settings.search.BaseSearchIndexProvider;

import com.android.settings.wifi.AddNetworkFragment;

import com.android.settings.wifi.AddWifiNetworkPreference;
@@ -84,6 +85,7 @@ import com.android.settings.wifi.dpp.WifiDppUtils; 
import com.android.settingslib.HelpUtils;

import com.android.settingslib.RestrictedLockUtils;

import com.android.settingslib.RestrictedLockUtilsInternal;

import com.android.settingslib.RestrictedSwitchPreference;

import com.android.settingslib.search.Indexable;

import com.android.settingslib.search.SearchIndexable;

import com.android.settingslib.utils.StringUtil;
@@ -129,6 +131,8 @@ public class NetworkProviderSettings extends RestrictedDashboardFragment 
    private static final String PREF_KEY_EMPTY_WIFI_LIST = "wifi_empty_list";

    @VisibleForTesting

    static final String PREF_KEY_WIFI_TOGGLE = "main_toggle_wifi";

    @VisibleForTesting

    static final String PREF_KEY_ETHERNET_TOGGLE = "main_toggle_ethernet";

    // TODO(b/70983952): Rename these to use WifiEntry instead of AccessPoint.

    @VisibleForTesting

    static final String PREF_KEY_CONNECTED_ACCESS_POINTS = "connected_access_point";
@@ -242,10 +246,12 @@ public class NetworkProviderSettings extends RestrictedDashboardFragment 
    LayoutPreference mResetInternetPreference;

    @VisibleForTesting

    ConnectedEthernetNetworkController mConnectedEthernetNetworkController;

    private EthernetSwitchPreferenceController mEthernetSwitchPreferenceController;

    @VisibleForTesting

    FooterPreference mWifiStatusMessagePreference;

    @VisibleForTesting

    MenuProvider mMenuProvider;

    RestrictedSwitchPreference mEthernetSwitchPreference;



    /**

     * Mobile networks list for provider model
@@ -383,12 +389,18 @@ public class NetworkProviderSettings extends RestrictedDashboardFragment 
        mDataUsagePreference.setTemplate(new NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI)

                        .build(), SubscriptionManager.INVALID_SUBSCRIPTION_ID);

        mResetInternetPreference = findPreference(PREF_KEY_RESET_INTERNET);

        mEthernetSwitchPreference = findPreference(PREF_KEY_ETHERNET_TOGGLE);

        if (mResetInternetPreference != null) {

            mResetInternetPreference.setVisible(false);

        }

        addNetworkMobileProviderController();

        addConnectedEthernetNetworkController();

        addWifiSwitchPreferenceController();

        if (com.android.settings.connectivity.Flags.ethernetSettings()) {

            addEthernetSwitchPreferenceController();

        } else {

            mEthernetSwitchPreference.setVisible(false);

        }

        mWifiStatusMessagePreference = findPreference(PREF_KEY_WIFI_STATUS_MESSAGE);



        checkConnectivityRecovering();
@@ -441,6 +453,14 @@ public class NetworkProviderSettings extends RestrictedDashboardFragment 
        mWifiSwitchPreferenceController.displayPreference(getPreferenceScreen());

    }



    private void addEthernetSwitchPreferenceController() {

        if (mEthernetSwitchPreferenceController == null) {

            mEthernetSwitchPreferenceController =

                    new EthernetSwitchPreferenceController(getContext(), getSettingsLifecycle());

        }

        mEthernetSwitchPreferenceController.displayPreference(getPreferenceScreen());

    }



    private void checkConnectivityRecovering() {

        mInternetResetHelper = new InternetResetHelper(getContext(), getLifecycle(),

                mNetworkMobileProviderController,

src/com/android/settings/network/ethernet/EthernetInterfaceTracker.kt

+30 −18
Original line number Diff line number Diff line
@@ -20,41 +20,40 @@ import android.content.Context 
import android.net.EthernetManager

import android.net.IpConfiguration

import androidx.core.content.ContextCompat

import java.util.concurrent.Executor



class EthernetInterfaceTracker(private val context: Context) :

class EthernetInterfaceTracker private constructor(private val context: Context) :

    EthernetManager.InterfaceStateListener {

    interface EthernetInterfaceListListener {

        fun onInterfaceListChanged()

    interface EthernetInterfaceTrackerListener {

        fun onInterfaceListChanged(ethernetInterfaces: List<EthernetInterface>)

    }



    private val ethernetManager =

        context.getSystemService(Context.ETHERNET_SERVICE) as EthernetManager

    private val ethernetManager: EthernetManager? =

        context.applicationContext.getSystemService(EthernetManager::class.java)

    private val TAG = "EthernetInterfaceTracker"



    // Maps ethernet interface identifier to EthernetInterface object

    private val ethernetInterfaces = mutableMapOf<String, EthernetInterface>()

    private val interfaceListeners = mutableListOf<EthernetInterfaceListListener>()

    private val mExecutor = ContextCompat.getMainExecutor(context)



    init {

        ethernetManager.addInterfaceStateListener(mExecutor, this)

    }

    private val interfaceListeners = mutableListOf<EthernetInterfaceTrackerListener>()



    fun getInterface(id: String): EthernetInterface? {

        return ethernetInterfaces.get(id)

    }



    fun getAvailableInterfaces(): Collection<EthernetInterface> {

        return ethernetInterfaces.values

    }

    val availableInterfaces: Collection<EthernetInterface>

        get() = ethernetInterfaces.values



    fun registerInterfaceListener(listener: EthernetInterfaceListListener) {

    fun registerInterfaceListener(listener: EthernetInterfaceTrackerListener) {

        if (interfaceListeners.isEmpty()) {

            ethernetManager?.addInterfaceStateListener(ContextCompat.getMainExecutor(context), this)

        }

        interfaceListeners.add(listener)

    }



    fun unregisterInterfaceListener(listener: EthernetInterfaceListListener) {

    fun unregisterInterfaceListener(listener: EthernetInterfaceTrackerListener) {

        interfaceListeners.remove(listener)

        if (interfaceListeners.isEmpty()) {

            ethernetManager?.removeInterfaceStateListener(this)

        }

    }



    override fun onInterfaceStateChanged(id: String, state: Int, role: Int, cfg: IpConfiguration?) {
@@ -68,7 +67,20 @@ class EthernetInterfaceTracker(private val context: Context) : 
        }

        if (interfacesChanged) {

            for (listener in interfaceListeners) {

                listener.onInterfaceListChanged()

                listener.onInterfaceListChanged(ethernetInterfaces.values.toList())

            }

        }

    }



    companion object {

        @Volatile private var INSTANCE: EthernetInterfaceTracker? = null



        fun getInstance(context: Context): EthernetInterfaceTracker {

            return INSTANCE

                ?: synchronized(this) {

                    val instance = EthernetInterfaceTracker(context.applicationContext)

                    INSTANCE = instance

                    instance

                }

        }

    }

src/com/android/settings/network/ethernet/EthernetSwitchPreferenceController.kt

0 → 100644
+96 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2025 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.ethernet



import android.content.Context

import android.net.EthernetManager

import androidx.core.content.ContextCompat

import androidx.lifecycle.Lifecycle

import androidx.lifecycle.LifecycleEventObserver

import androidx.lifecycle.LifecycleOwner

import androidx.preference.Preference

import androidx.preference.PreferenceScreen

import com.android.settings.connectivity.Flags

import com.android.settingslib.RestrictedSwitchPreference

import com.android.settingslib.core.AbstractPreferenceController

import com.google.common.annotations.VisibleForTesting

import java.util.concurrent.Executor



class EthernetSwitchPreferenceController(context: Context, private val lifecycle: Lifecycle) :

    AbstractPreferenceController(context),

    LifecycleEventObserver,

    EthernetInterfaceTracker.EthernetInterfaceTrackerListener {



    private val ethernetManager: EthernetManager? =

        context.getSystemService(EthernetManager::class.java)

    private var preference: RestrictedSwitchPreference? = null

    private val executor = ContextCompat.getMainExecutor(context)

    private val ethernetInterfaceTracker = EthernetInterfaceTracker.getInstance(context)



    init {

        lifecycle.addObserver(this)

    }



    override fun getPreferenceKey(): String {

        return KEY

    }



    override fun isAvailable(): Boolean {

        return (Flags.ethernetSettings() && ethernetInterfaceTracker.availableInterfaces.size > 0)

    }



    override fun displayPreference(screen: PreferenceScreen) {

        super.displayPreference(screen)

        preference = screen.findPreference(KEY)

        preference?.setOnPreferenceChangeListener(this::onPreferenceChange)

    }



    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {

        when (event) {

            Lifecycle.Event.ON_START -> {

                ethernetManager?.addEthernetStateListener(executor, this::onEthernetStateChanged)

                ethernetInterfaceTracker.registerInterfaceListener(this)

            }



            Lifecycle.Event.ON_STOP -> {

                ethernetManager?.removeEthernetStateListener(this::onEthernetStateChanged)

                ethernetInterfaceTracker.unregisterInterfaceListener(this)

            }



            else -> {}

        }

    }



    fun onPreferenceChange(preference: Preference, newValue: Any): Boolean {

        val isChecked = newValue as Boolean

        ethernetManager?.setEthernetEnabled(isChecked)

        return true

    }



    @VisibleForTesting

    fun onEthernetStateChanged(state: Int) {

        preference?.setChecked(state == EthernetManager.ETHERNET_STATE_ENABLED)

    }



    override fun onInterfaceListChanged(ethernetInterfaces: List<EthernetInterface>) {

        preference?.setVisible(ethernetInterfaces.size > 0)

    }



    companion object {

        private val KEY = "main_toggle_ethernet"

    }

}