fix: strip any extensions that might be passed in with the locale [ANDR-14] (#330)

* fix: strip any extensions that might be passed in with the locale [ANDR-14]

* Update src/main/java/com/contentful/java/cda/AbsQuery.java

Co-authored-by: Copilot <[email protected]>

---------

Co-authored-by: Ely Lucas <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 3 people

src/main/java/com/contentful/java/cda/AbsQuery.java

@@ -75,6 +75,7 @@ public Query withContentType(String contentType) {
 
   /**
    * Requesting content with specific locale.
+   * If the locale contains Unicode extension tags (e.g., "en-CA-u-fw-sun-mu-celsius") they will be stripped.
    *
    * @param locale the locale to be used.
    * @return the calling query for chaining.
@@ -85,12 +86,14 @@ public Query withContentType(String contentType) {
   public Query withLocale(String locale) {
     checkNotNull(locale, "Locale must not be null.");
 
+    String normalizedLocale = stripExtensionsFromLocale(locale);
+
     if (params.get(PARAMETER_LOCALE) != null) {
       throw new IllegalStateException(format("Locale \"%s\" is already present in query.",
           params.get(PARAMETER_LOCALE)));
     }
 
-    params.put(PARAMETER_LOCALE, locale);
+    params.put(PARAMETER_LOCALE, normalizedLocale);
 
     return (Query) this;
   }
@@ -487,4 +490,37 @@ private int countDots(String text) {
     }
     return count;
   }
+
+  /**
+   * Normalizes a locale string by removing Unicode extension tags.
+   * <p>
+   * Starting with Android 14 (API 34), the ICU library provides extended locale strings
+   * that include user preferences like "en-CA-u-fw-sun-mu-celsius". These extensions are
+   * not supported by Contentful's API, so we strip them to get the base locale code.
+   * <p>
+   * Examples:
+   * <ul>
+   *   <li>"en-CA-u-fw-sun-mu-celsius" → "en-CA"</li>
+   *   <li>"en-GB-u-hc-h24" → "en-GB"</li>
+   *   <li>"en-US" → "en-US" (unchanged)</li>
+   * </ul>
+   *
+   * @param locale the locale string to normalize
+   * @return the normalized locale string without Unicode extension tags
+   */
+  private String stripExtensionsFromLocale(String locale) {
+    if (locale == null || locale.isEmpty()) {
+      return locale;
+    }
+
+    // Find the Unicode extension separator "-u-"
+    int extensionIndex = locale.indexOf("-u-");
+    if (extensionIndex > 0) {
+      // Strip everything from "-u-" onwards
+      return locale.substring(0, extensionIndex);
+    }
+
+    // No Unicode extensions found, return as-is
+    return locale;
+  }
 }

src/test/java/com/contentful/java/cda/AbsQueryTest.java

@@ -72,6 +72,97 @@ public void settingLocaleTypeTwiceThrowsError() {
     query.withLocale("de");
   }
 
+  @Test
+  public void localeWithStandardFormat() {
+    query.withLocale("en-US");
+
+    assertThat(query.params).containsEntry("locale", "en-US");
+  }
+
+  @Test
+  public void localeWithAndroid14ExtensionIsNormalized() {
+    // Android 14+ may send locales with Unicode extension tags like "en-CA-u-fw-sun-mu-celsius"
+    query.withLocale("en-CA-u-fw-sun-mu-celsius");
+
+    // Should be normalized to just "en-CA"
+    assertThat(query.params).containsEntry("locale", "en-CA");
+  }
+
+  @Test
+  public void localeWithMultipleUnicodeExtensions() {
+    // Test locale with multiple Unicode extension tags
+    query.withLocale("en-GB-u-hc-h24-fw-mon");
+
+    // Should strip all extensions after "-u-"
+    assertThat(query.params).containsEntry("locale", "en-GB");
+  }
+
+  @Test
+  public void localeWithSimpleUnicodeExtension() {
+    // Test with a simple Unicode extension
+    query.withLocale("en-US-u-ca-gregory");
+
+    assertThat(query.params).containsEntry("locale", "en-US");
+  }
+
+  @Test
+  public void localeWithOnlyLanguageCode() {
+    // Test with just a language code (no region)
+    query.withLocale("en");
+
+    assertThat(query.params).containsEntry("locale", "en");
+  }
+
+  @Test
+  public void localeWithThreeLetterRegionCode() {
+    // Test with three-letter region code
+    query.withLocale("zh-CHN");
+
+    assertThat(query.params).containsEntry("locale", "zh-CHN");
+  }
+
+  @Test
+  public void localeWithScriptAndRegion() {
+    // Test with script and region (e.g., Chinese)
+    query.withLocale("zh-Hans-CN");
+
+    assertThat(query.params).containsEntry("locale", "zh-Hans-CN");
+  }
+
+  @Test
+  public void localeWithScriptRegionAndUnicodeExtension() {
+    // Test with script, region, and Unicode extension
+    query.withLocale("zh-Hans-CN-u-ca-chinese");
+
+    // Should preserve script and region, but strip Unicode extension
+    assertThat(query.params).containsEntry("locale", "zh-Hans-CN");
+  }
+
+  @Test
+  public void localeWithUAtStart() {
+    // Edge case: "u" at the start should not be treated as extension
+    query.withLocale("uz-UZ");
+
+    assertThat(query.params).containsEntry("locale", "uz-UZ");
+  }
+
+  @Test
+  public void localeWithUppercaseU() {
+    // Edge case: uppercase "U" should not be treated as extension separator
+    query.withLocale("en-US-U-test");
+
+    // "-U-" (uppercase) should not be treated as Unicode extension separator
+    assertThat(query.params).containsEntry("locale", "en-US-U-test");
+  }
+
+  @Test
+  public void localeEmpty() {
+    // Empty locale should be handled gracefully (will be caught by checkNotNull)
+    query.withLocale("");
+
+    assertThat(query.params).containsEntry("locale", "");
+  }
+
   @Test
   public void select() {
     query.withContentType("foo");