RK3588 双以太网

    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_ETHERNET) ||
                    mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
                t.traceBegin("StartEthernet");
                mSystemServiceManager.startService(ETHERNET_SERVICE_CLASS);
                t.traceEnd();
            }

    }

public final class EthernetService extends SystemService {

    private static final String TAG = "EthernetService";
    final EthernetServiceImpl mImpl;

    public EthernetService(Context context) {
        super(context);
        mImpl = new EthernetServiceImpl(context);
    }

    @Override
    public void onStart() {
        Log.i(TAG, "Registering service " + Context.ETHERNET_SERVICE);
        publishBinderService(Context.ETHERNET_SERVICE, mImpl);
    }

    @Override
    public void onBootPhase(int phase) {
        if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) {
            mImpl.start();
        }
    }
}

public class EthernetServiceImpl extends IEthernetManager.Stub {

    public void start() {
        Log.i(TAG, "Starting Ethernet service");

        HandlerThread handlerThread = new HandlerThread("EthernetServiceThread");
        handlerThread.start();
        mHandler = new Handler(handlerThread.getLooper());

        mTracker = new EthernetTracker(mContext, mHandler);
        mTracker.start();

        mStarted.set(true);
    }

}

final class EthernetTracker {


    /**
     * Interface names we track. This is a product-dependent regular expression, plus,
     * if setIncludeTestInterfaces is true, any test interfaces.
     */
    private String mIfaceMatch;

    private final Context mContext;
    private final INetworkManagementService mNMService;
    private final INetd mNetd;
    private final Handler mHandler;
    private final EthernetNetworkFactory mFactory;
    private final EthernetConfigStore mConfigStore;
    private final WifiSleepController mWifiSleepController;

    //lixiaogang add
    private EthernetNetworkFactoryExt mEthernetNetworkFactoryExt;

    EthernetTracker(Context context, Handler handler) {
        mContext = context;
        mHandler = handler;

        // The services we use.
        IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
        mNMService = INetworkManagementService.Stub.asInterface(b);
        mNetd = Objects.requireNonNull(NetdService.getInstance(), "could not get netd instance");

        // Interface match regex.
        updateIfaceMatchRegexp();


        mConfigStore = new EthernetConfigStore();

        NetworkCapabilities nc = createNetworkCapabilities(true /* clear default capabilities */);
        mFactory = new EthernetNetworkFactory(handler, context, nc);

        // 将这个网络工厂（NetworkFactory）注册到系统的 ConnectivityService，告知系统该工厂能够提供某类网络服务（如以太网），从而能够接收网络请求并管理网络连接。
        mFactory.register();
        mWifiSleepController = new WifiSleepController(mContext);

        //lixiaogang add
        mEthernetNetworkFactoryExt = new EthernetNetworkFactoryExt();
    }


    void start() {
        mConfigStore.read();

        // Default interface is just the first one we want to track.
        mIpConfigForDefaultInterface = mConfigStore.getIpConfigurationForDefaultInterface();
        final ArrayMap<String, IpConfiguration> configs = mConfigStore.getIpConfigurations();

        // 将所有接口配置复制到 mIpConfigurations（当前运行时缓存的配置集合），以便随时访问和管理
        for (int i = 0; i < configs.size(); i++) {
            mIpConfigurations.put(configs.keyAt(i), configs.valueAt(i));
        }

        // 向网络管理服务（NetworkManagementService）注册一个观察者，用于监听网卡接口的增删、状态变化（up/down/link）事件。
        try {
            mNMService.registerObserver(new InterfaceObserver());
        } catch (RemoteException e) {
            Log.e(TAG, "Could not register InterfaceObserver " + e);
        }

        // 通过 Handler 异步执行 trackAvailableInterfaces() 方法，开始扫描和追踪当前系统已有的以太网接口。
        mHandler.post(this::trackAvailableInterfaces);
    }

    // 获取外网接口
    private void updateIfaceMatchRegexp() {
        // modify lixiaogang start
        // final String match = mContext.getResources().getString(
        //         com.android.internal.R.string.config_ethernet_iface_regex);
        // mIfaceMatch = mIncludeTestInterfaces
        //         ? "(" + match + "|" + TEST_IFACE_REGEXP + ")"
        //         : match;
        mIfaceMatch = SystemProperties.get("ro.net.eth_primary", "eth0");//"eth1";
        Log.d(TAG, "Interface match regexp set to '" + mIfaceMatch + "'");
        // modify lixiaogang end
    }

    private class InterfaceObserver extends BaseNetworkObserver {

        @Override
        public void interfaceLinkStateChanged(String iface, boolean up) {
            if (DBG) {
                Log.i(TAG, "interfaceLinkStateChanged, iface: " + iface + ", up: " + up);
            }

            if(isEthernetInterfaceActive())
                mHandler.post(() -> updateInterfaceState(iface, up));
            else{
                if (iface.matches(mIfaceMatch)){
                       mHandler.post(() -> updateInterfaceState(iface, false));
                       Settings.System.putInt(mContext.getContentResolver(),Settings.System.ETHERNET_ON,0);
            }}

            mHandler.post(() -> mEthernetNetworkFactoryExt.interfaceLinkStateChanged(iface, up));
        }

        @Override
        public void interfaceAdded(String iface) {
            mHandler.post(() -> maybeTrackInterface(iface));
            mHandler.post(() -> mEthernetNetworkFactoryExt.interfaceAdded(iface));
        }

        @Override
        public void interfaceRemoved(String iface) {
            mHandler.post(() -> stopTrackingInterface(iface));
            mHandler.post(() -> mEthernetNetworkFactoryExt.interfaceRemoved(iface));
        }
    }

    private boolean maybeTrackInterface(String iface) {
        if (!iface.matches(mIfaceMatch)) {
            return false;
        }

        // 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 (DBG) Log.w(TAG, "Ignoring already-tracked interface " + iface);
            return false;
        }
        if (DBG) Log.i(TAG, "maybeTrackInterface: " + iface);

        // TODO: avoid making an interface default if it has configured NetworkCapabilities.
        if (mDefaultInterface == null) {
            mDefaultInterface = iface;
        }

        if (mIpConfigForDefaultInterface != null) {
            updateIpConfiguration(iface, mIpConfigForDefaultInterface);
            mIpConfigForDefaultInterface = null;
        }

        addInterface(iface);
        mEthernetNetworkFactoryExt.start(mContext, mNMService);
        return true;
    }

    private void trackAvailableInterfaces() {
        try {
            final String[] ifaces = mNMService.listInterfaces();
            for (String iface : ifaces) {
                if (maybeTrackInterface(iface)) {
                    String mIfaceTmp = iface;
                    new Thread(new Runnable() {
                        public void run() {
                            // carrier is always 1 when kernel boot up no matter RJ45 plugin or not,
                            // sleep a little time to wait kernel's correct carrier status
                            try {
                                Thread.sleep(3000);
                            } catch (InterruptedException ignore) {
                            }
                            Log.d(TAG, mIfaceTmp + " isEthernetInterfaceActive = " + isEthernetInterfaceActive());
                            if (!isEthernetInterfaceActive()) {
                                updateInterfaceState(mIfaceTmp, false);
                            }
                        }
                    }).start();
                    break;
                }

            }
        } catch (RemoteException | IllegalStateException e) {
            Log.e(TAG, "Could not get list of interfaces " + e);
        }
    }

}

/**
 * This class provides an API to store and manage Ethernet network configuration.
 */
public class EthernetConfigStore {
    private static final String ipConfigFile = Environment.getDataDirectory() +
            "/misc/ethernet/ipconfig.txt";

    private IpConfigStore mStore = new IpConfigStore();
    private ArrayMap<String, IpConfiguration> mIpConfigurations;
    private IpConfiguration mIpConfigurationForDefaultInterface;
    private final Object mSync = new Object();

    public EthernetConfigStore() {
        mIpConfigurations = new ArrayMap<>(0);
    }

    public void read() {
        synchronized (mSync) {
            ArrayMap<String, IpConfiguration> configs =
                    IpConfigStore.readIpConfigurations(ipConfigFile);

            // This configuration may exist in old file versions when there was only a single active
            // Ethernet interface.
            if (configs.containsKey("0")) {
                mIpConfigurationForDefaultInterface = configs.remove("0");
            }

            mIpConfigurations = configs;
        }
    }

    public void write(String iface, IpConfiguration config) {
        boolean modified;

        synchronized (mSync) {
            if (config == null) {
                modified = mIpConfigurations.remove(iface) != null;
            } else {
                IpConfiguration oldConfig = mIpConfigurations.put(iface, config);
                modified = !config.equals(oldConfig);
            }

            if (modified) {
                mStore.writeIpConfigurations(ipConfigFile, mIpConfigurations);
            }
        }
    }

    public ArrayMap<String, IpConfiguration> getIpConfigurations() {
        synchronized (mSync) {
            return new ArrayMap<>(mIpConfigurations);
        }
    }

    @Nullable
    public IpConfiguration getIpConfigurationForDefaultInterface() {
        synchronized (mSync) {
            return mIpConfigurationForDefaultInterface == null
                    ? null : new IpConfiguration(mIpConfigurationForDefaultInterface);
        }
    }
}

public class EthernetNetworkFactory extends NetworkFactory {

    private final static int NETWORK_SCORE = 70;
    private static final String NETWORK_TYPE = "Ethernet";
    
    public EthernetNetworkFactory(Handler handler, Context context, NetworkCapabilities filter) {
        super(handler.getLooper(), context, NETWORK_TYPE, filter);

        mHandler = handler;
        mContext = context;

        setScoreFilter(NETWORK_SCORE);
        mEthernetManager = (EthernetManager) context.getSystemService(Context.ETHERNET_SERVICE);
    }

}


public class NetworkFactory {

    public NetworkFactory(Looper looper, Context context, String logTag,
            @Nullable final NetworkCapabilities filter) {
        LOG_TAG = logTag;
        if (isAtLeastS()) {
            mImpl = new NetworkFactoryImpl(this, looper, context, filter);
        } else {
            mImpl = new NetworkFactoryLegacyImpl(this, looper, context, filter);
        }
    }

    // 将这个网络工厂（NetworkFactory）注册到系统的 ConnectivityService，告知系统该工厂能够提供某类网络服务（如以太网），从而能够接收网络请求并管理网络连接。
    public void register() {
        mImpl.register(LOG_TAG);
    }

}


class NetworkFactoryImpl extends NetworkFactoryLegacyImpl {

    private void register(final String logTag, final boolean listenToAllRequests) {
        if (mProvider != null) {
            throw new IllegalStateException("A NetworkFactory must only be registered once");
        }
        if (DBG) mParent.log("Registering NetworkFactory");

        mProvider = new NetworkProvider(mContext, NetworkFactoryImpl.this.getLooper(), logTag) {
            @Override
            public void onNetworkRequested(@NonNull NetworkRequest request, int score,
                    int servingProviderId) {
                handleAddRequest(request);
            }

            @Override
            public void onNetworkRequestWithdrawn(@NonNull NetworkRequest request) {
                handleRemoveRequest(request);
            }
        };

        ((ConnectivityManager) mContext.getSystemService(
                Context.CONNECTIVITY_SERVICE)).registerNetworkProvider(mProvider);

        // The mScore and mCapabilityFilter members can only be accessed on the handler thread.
        // TODO : offer a separate API to listen to all requests instead
        if (listenToAllRequests) {
            sendMessage(obtainMessage(CMD_LISTEN_TO_ALL_REQUESTS));
        } else {
            sendMessage(obtainMessage(CMD_OFFER_NETWORK));
        }
    }

}