diff --git a/service-t/src/com/android/server/ethernet/EthernetTracker.java b/service-t/src/com/android/server/ethernet/EthernetTracker.java
index 382350f..def701b 100644
--- a/service-t/src/com/android/server/ethernet/EthernetTracker.java
+++ b/service-t/src/com/android/server/ethernet/EthernetTracker.java
@@ -69,6 +69,7 @@
 import java.net.NetworkInterface;
 import java.net.SocketException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Iterator;
 import java.util.List;
@@ -769,11 +770,11 @@
         // capabilities) to prevent certain Ethernet interfaces from becoming
         // the default network. To avoid breaking existing device configurations, this
         // change is gated by the SDK level.
-        if (SdkLevel.isAtLeastB() && TextUtils.isEmpty(config.mCapabilities)) {
+        if (SdkLevel.isAtLeastB() && config.mCaps.isEmpty()) {
             boolean isTestIface = config.mIface.matches(TEST_IFACE_REGEXP);
             nc = createDefaultNetworkCapabilities(isTestIface, config.mTransport);
         } else {
-            nc = createNetworkCapabilities(config.mCapabilities, config.mTransport).build();
+            nc = createNetworkCapabilities(config.mCaps, config.mTransport).build();
         }
         mNetworkCapabilities.put(config.mIface, nc);
 
@@ -786,7 +787,7 @@
     private static NetworkCapabilities createDefaultNetworkCapabilities(
             boolean isTestIface, int transportType) {
         NetworkCapabilities.Builder builder =
-                createNetworkCapabilities(/* commaSeparatedCapabilities */ null, transportType)
+                createNetworkCapabilities(Collections.emptyList(), transportType)
                         .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
                         .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
                         .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING)
@@ -806,19 +807,18 @@
     /**
      * Parses a static list of network capabilities
      *
-     * @param commaSeparatedCapabilities A comma separated string list of integer encoded
-     *                                   NetworkCapability.NET_CAPABILITY_* values
+     * @param capabilities      A List of NetworkCapabilities.
      * @param overrideTransport A string representing a single integer encoded override transport
      *                          type. Must be one of the NetworkCapability.TRANSPORT_*
      *                          values. TRANSPORT_VPN is not supported. Errors with input
      *                          will cause the override to be ignored.
      */
     @VisibleForTesting
-    static NetworkCapabilities.Builder createNetworkCapabilities(
-            @Nullable String commaSeparatedCapabilities, int transportType) {
+    static NetworkCapabilities.Builder createNetworkCapabilities(List<Integer> capabilities,
+            int transportType) {
 
         final NetworkCapabilities.Builder builder =
-                TextUtils.isEmpty(commaSeparatedCapabilities)
+                capabilities.isEmpty()
                         ? new NetworkCapabilities.Builder()
                         : NetworkCapabilities.Builder.withoutDefaultCapabilities();
 
@@ -831,19 +831,8 @@
         builder.setLinkUpstreamBandwidthKbps(100 * 1000);
         builder.setLinkDownstreamBandwidthKbps(100 * 1000);
 
-        if (!TextUtils.isEmpty(commaSeparatedCapabilities)) {
-            for (String strNetworkCapability : commaSeparatedCapabilities.split(",")) {
-                if (!TextUtils.isEmpty(strNetworkCapability)) {
-                    try {
-                        builder.addCapability(Integer.valueOf(strNetworkCapability));
-                    } catch (NumberFormatException nfe) {
-                        Log.e(TAG, "Capability '" + strNetworkCapability + "' could not be parsed");
-                    } catch (IllegalArgumentException iae) {
-                        Log.e(TAG, strNetworkCapability + " is not a valid "
-                                + "NetworkCapability.NET_CAPABILITY_* value");
-                    }
-                }
-            }
+        for (int capability : capabilities) {
+            builder.addCapability(capability);
         }
         // Ethernet networks have no way to update the following capabilities, so they always
         // have them.
@@ -1025,10 +1014,32 @@
     @VisibleForTesting
     static class EthernetTrackerConfig {
         final String mIface;
-        final String mCapabilities;
+        final List<Integer> mCaps;
         final String mIpConfig;
         final int mTransport;
 
+        private static List<Integer> parseCapabilities(String capabilitiesString) {
+            if (TextUtils.isEmpty(capabilitiesString)) {
+                return Collections.emptyList();
+            }
+
+            final ArrayList<Integer> capabilities = new ArrayList<>();
+            for (String strNetworkCapability : capabilitiesString.split(",")) {
+                if (TextUtils.isEmpty(strNetworkCapability)) {
+                    continue;
+                }
+                final Integer capability;
+                try {
+                    capability = Integer.valueOf(strNetworkCapability);
+                } catch (NumberFormatException e) {
+                    Log.e(TAG, "Failed to parse capability: " + strNetworkCapability, e);
+                    continue;
+                }
+                capabilities.add(capability);
+            }
+            return capabilities;
+        }
+
         private static int parseTransportType(String transportString) {
             if (TextUtils.isEmpty(transportString)) {
                 return TRANSPORT_ETHERNET;
@@ -1061,7 +1072,7 @@
             Objects.requireNonNull(configString, "EthernetTrackerConfig requires non-null config");
             final String[] tokens = configString.split(";", /* limit of tokens */ 4);
             mIface = tokens[0];
-            mCapabilities = tokens.length > 1 ? tokens[1] : null;
+            mCaps = tokens.length > 1 ? parseCapabilities(tokens[1]) : Collections.emptyList();
             mIpConfig = tokens.length > 2 && !TextUtils.isEmpty(tokens[2]) ? tokens[2] : null;
             mTransport = tokens.length > 3 ? parseTransportType(tokens[3]) : TRANSPORT_ETHERNET;
         }
diff --git a/tests/unit/java/com/android/server/ethernet/EthernetTrackerTest.java b/tests/unit/java/com/android/server/ethernet/EthernetTrackerTest.java
index ef60f2a..6ce7dbc 100644
--- a/tests/unit/java/com/android/server/ethernet/EthernetTrackerTest.java
+++ b/tests/unit/java/com/android/server/ethernet/EthernetTrackerTest.java
@@ -18,6 +18,8 @@
 
 import static android.net.TestNetworkManager.TEST_TAP_PREFIX;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThrows;
@@ -292,13 +294,12 @@
         final EthernetTrackerConfig config = new EthernetTrackerConfig(configString);
         assertEquals(
                 expectedNetworkCapabilities,
-                EthernetTracker.createNetworkCapabilities(config.mCapabilities, config.mTransport)
-                        .build());
+                EthernetTracker.createNetworkCapabilities(config.mCaps, config.mTransport).build());
     }
 
     @Test
     public void testCreateEthernetTrackerConfigReturnsCorrectValue() {
-        final String capabilities = "2";
+        final String capabilities = "2,4,6,8";
         final String ipConfig = "3";
         final String transport = "1";
         final String configString = String.join(";", TEST_IFACE, capabilities, ipConfig, transport);
@@ -306,7 +307,7 @@
         final EthernetTrackerConfig config = new EthernetTrackerConfig(configString);
 
         assertEquals(TEST_IFACE, config.mIface);
-        assertEquals(capabilities, config.mCapabilities);
+        assertThat(config.mCaps).containsExactly(2, 4, 6, 8);
         assertEquals(ipConfig, config.mIpConfig);
         assertEquals(NetworkCapabilities.TRANSPORT_WIFI, config.mTransport);
     }