fix: persist customBaseURL across NetworkOptions JSON round-trip

NetworkOptions.toJson() and withNetworkOptions(String) did not include
customBaseURL, so any value was silently dropped when UploadSettings
serialized NetworkOptions to the upload database. Events and alias
uploads read back NetworkOptions without customBaseURL and routed to
the default mParticle endpoints instead of the partner CNAME.

Also:
- Extract the customBaseURL/DomainMapping host-resolution branch out of
  getUrl() into a private resolveHost() helper plus a small ResolvedHost
  value type, lowering getUrl()'s cyclomatic complexity.
- Switch java.net.URL / java.net.MalformedURLException to imports.
- Add two androidTest cases covering the round-trip.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jamesnrokt

android-core/src/androidTest/kotlin/com.mparticle/networking/MParticleBaseClientImplTest.kt

@@ -570,4 +570,29 @@ class MParticleBaseClientImplTest : BaseCleanInstallEachTest() {
                 .build()
         assertEquals(null, opts.customBaseURL)
     }
+
+    @Test
+    fun testCustomBaseURLSurvivesJsonRoundTrip() {
+        val original =
+            NetworkOptions
+                .builder()
+                .setCustomBaseURL("https://rkt.example.com:8443")
+                .build()
+        Assert.assertEquals("rkt.example.com:8443", original.customBaseURL)
+
+        val json = original.toJson().toString()
+        val restored = NetworkOptions.withNetworkOptions(json)
+        Assert.assertNotNull(restored)
+        Assert.assertEquals("rkt.example.com:8443", restored!!.customBaseURL)
+    }
+
+    @Test
+    fun testCustomBaseURLOmittedFromJsonWhenUnset() {
+        val opts = NetworkOptions.builder().build()
+        val json = opts.toJson()
+        Assert.assertFalse(json.has("customBaseURL"))
+
+        val restored = NetworkOptions.withNetworkOptions(json.toString())
+        Assert.assertNull(restored!!.customBaseURL)
+    }
 }

android-core/src/main/java/com/mparticle/networking/MParticleBaseClientImpl.java

@@ -114,50 +114,18 @@ protected MPUrl getUrl(Endpoint endpoint, @Nullable String identityPath, HashMap
     protected MPUrl getUrl(Endpoint endpoint, @Nullable String identityPath,HashMap<String, String> audienceQueryParams, @Nullable UploadSettings uploadSettings) throws MalformedURLException {
         NetworkOptions networkOptions = uploadSettings == null ? mConfigManager.getNetworkOptions() : uploadSettings.getNetworkOptions();
         DomainMapping domainMapping = networkOptions.getDomain(endpoint);
-        String url = NetworkOptionsManager.getDefaultUrl(endpoint);
         String apiKey = uploadSettings == null ? mApiKey : uploadSettings.getApiKey();
-        final String customBaseURL = networkOptions.getCustomBaseURL();
+        final boolean usingCustomBaseURL = !MPUtility.isEmpty(networkOptions.getCustomBaseURL());
 
-        // `defaultDomain` variable is for URL generation when domain mapping is specified.
-        String defaultDomain = url;
-        boolean isDefaultDomain = true;
-
-        if (!MPUtility.isEmpty(customBaseURL)) {
-            // customBaseURL takes priority over all individual domain mappings.
-            if (domainMapping != null && !MPUtility.isEmpty(domainMapping.getUrl())) {
-                Logger.warning("NetworkOptions: customBaseURL is set; domain mapping for " + endpoint.name() + " is ignored.");
-            }
-            url = customBaseURL;
-            isDefaultDomain = false;
-            if (endpoint != Endpoint.CONFIG) {
-                // When custom CNAME is used, the default-domain URL still needs the pod prefix
-                // so MPConnectionTest matching and pinning fallbacks continue to work.
-                defaultDomain = getPodUrl(defaultDomain, null, false);
-            }
-        } else {
-            // Check if domain mapping is specified and update the URL based on domain mapping
-            String domainMappingUrl = domainMapping != null ? domainMapping.getUrl() : null;
-            if (!MPUtility.isEmpty(domainMappingUrl)) {
-                isDefaultDomain = url.equals(domainMappingUrl);
-                url = domainMappingUrl;
-            }
-
-            if (endpoint != Endpoint.CONFIG) {
-                // Set URL with pod prefix if it’s the default domain and endpoint is not CONFIG
-                if (isDefaultDomain) {
-                    url = getPodUrl(url, mConfigManager.getPodPrefix(apiKey), mConfigManager.isDirectUrlRoutingEnabled());
-                } else {
-                    // When domain mapping is specified, generate the default domain. Whether podRedirection is enabled or not, always use the original URL.
-                    defaultDomain = getPodUrl(defaultDomain, null, false);
-                }
-            }
-        }
+        ResolvedHost host = resolveHost(endpoint, networkOptions, domainMapping, apiKey);
+        String url = host.url;
+        String defaultDomain = host.defaultDomain;
+        boolean isDefaultDomain = host.isDefaultDomain;
 
         Uri uri;
         String subdirectory;
         String pathPrefix;
         String pathPostfix;
-        final boolean usingCustomBaseURL = !MPUtility.isEmpty(customBaseURL);
         boolean overridesSubdirectory = domainMapping != null && domainMapping.isOverridesSubdirectory();
         if (usingCustomBaseURL && overridesSubdirectory) {
             Logger.warning("NetworkOptions: customBaseURL with overridesSubdirectory is unsupported for CDN routing; overridesSubdirectory will be ignored for " + endpoint.name() + ".");
@@ -268,6 +236,57 @@ String getPodUrl(String URLPrefix, String pod, boolean enablePodRedirection) {
         return null;
     }
 
+    /**
+     * Resolves the host(s) used to build the endpoint URL. Returns three values:
+     * {@code url} — host used for the request, {@code defaultDomain} — host used as the
+     * fallback for {@link #generateDefaultURL}, and {@code isDefaultDomain} — true when
+     * {@code url} is the unmodified mParticle default.
+     *
+     * <p>Priority: {@code customBaseURL} → per-endpoint {@code DomainMapping} → default.
+     */
+    private ResolvedHost resolveHost(Endpoint endpoint, NetworkOptions networkOptions, DomainMapping domainMapping, String apiKey) {
+        String defaultUrl = NetworkOptionsManager.getDefaultUrl(endpoint);
+        String customBaseURL = networkOptions.getCustomBaseURL();
+
+        if (!MPUtility.isEmpty(customBaseURL)) {
+            if (domainMapping != null && !MPUtility.isEmpty(domainMapping.getUrl())) {
+                Logger.warning("NetworkOptions: customBaseURL is set; domain mapping for " + endpoint.name() + " is ignored.");
+            }
+            // When custom CNAME is used, the default-domain URL still needs the pod prefix
+            // so MPConnectionTest matching and pinning fallbacks continue to work.
+            String defaultDomain = endpoint == Endpoint.CONFIG ? defaultUrl : getPodUrl(defaultUrl, null, false);
+            return new ResolvedHost(customBaseURL, defaultDomain, false);
+        }
+
+        String domainMappingUrl = domainMapping != null ? domainMapping.getUrl() : null;
+        boolean isDefaultDomain = MPUtility.isEmpty(domainMappingUrl) || defaultUrl.equals(domainMappingUrl);
+        String url = isDefaultDomain ? defaultUrl : domainMappingUrl;
+        String defaultDomain = defaultUrl;
+
+        if (endpoint != Endpoint.CONFIG) {
+            if (isDefaultDomain) {
+                // Default domain gets the pod prefix.
+                url = getPodUrl(url, mConfigManager.getPodPrefix(apiKey), mConfigManager.isDirectUrlRoutingEnabled());
+            } else {
+                // Domain-mapped: always generate the default with the original (un-pod-prefixed) host.
+                defaultDomain = getPodUrl(defaultDomain, null, false);
+            }
+        }
+        return new ResolvedHost(url, defaultDomain, isDefaultDomain);
+    }
+
+    private static final class ResolvedHost {
+        final String url;
+        final String defaultDomain;
+        final boolean isDefaultDomain;
+
+        ResolvedHost(String url, String defaultDomain, boolean isDefaultDomain) {
+            this.url = url;
+            this.defaultDomain = defaultDomain;
+            this.isDefaultDomain = isDefaultDomain;
+        }
+    }
+
     public enum Endpoint {
         CONFIG(1),
         IDENTITY(2),

android-core/src/main/java/com/mparticle/networking/NetworkOptions.java

@@ -16,11 +16,13 @@
 import org.json.JSONException;
 import org.json.JSONObject;
 
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.HashSet;
 import java.util.Set;
 
 public class NetworkOptions {
@@ -66,6 +68,13 @@ public static NetworkOptions withNetworkOptions(@Nullable String jsonString) {
             JSONObject jsonObject = new JSONObject(jsonString);
             builder.setPinningDisabledInDevelopment(jsonObject.optBoolean("disableDevPinning", false));
             builder.setPinningDisabled(jsonObject.optBoolean("disablePinning", false));
+            String storedCustomBaseURL = jsonObject.optString("customBaseURL", null);
+            if (!MPUtility.isEmpty(storedCustomBaseURL)) {
+                // Stored value is already host(:port). Skip the Builder setter (which expects a full
+                // HTTPS URL with scheme) and assign directly so a previously-validated value survives
+                // the JSON round-trip.
+                builder.customBaseURL = storedCustomBaseURL;
+            }
             JSONArray domainMappingsJson = jsonObject.getJSONArray("domainMappings");
             for (int i = 0; i < domainMappingsJson.length(); i++) {
                 builder.addDomainMapping(DomainMapping
@@ -138,6 +147,9 @@ public JSONObject toJson() {
             JSONArray domainMappingsJson = new JSONArray();
             networkOptions.put("disableDevPinning", pinningDisabledInDevelopment);
             networkOptions.put("disablePinning", pinningDisabled);
+            if (!MPUtility.isEmpty(customBaseURL)) {
+                networkOptions.put("customBaseURL", customBaseURL);
+            }
             networkOptions.put("domainMappings", domainMappingsJson);
             for (DomainMapping domainMapping : domainMappings.values()) {
                 domainMappingsJson.put(domainMapping.toString());
@@ -221,7 +233,7 @@ public Builder setPinningDisabled(boolean disabled) {
         @NonNull
         public Builder setCustomBaseURL(@NonNull String customBaseURL) {
             try {
-                java.net.URL parsed = new java.net.URL(customBaseURL);
+                URL parsed = new URL(customBaseURL);
                 if (!"https".equalsIgnoreCase(parsed.getProtocol()) || MPUtility.isEmpty(parsed.getHost())) {
                     Logger.warning("NetworkOptions: customBaseURL must use HTTPS and include a valid host — value ignored.");
                     return this;
@@ -231,7 +243,7 @@ public Builder setCustomBaseURL(@NonNull String customBaseURL) {
                     host.append(":").append(parsed.getPort());
                 }
                 this.customBaseURL = host.toString();
-            } catch (java.net.MalformedURLException e) {
+            } catch (MalformedURLException e) {
                 Logger.warning("NetworkOptions: customBaseURL is malformed — value ignored.");
             }
             return this;