Fix workaround logic for system UI gaps

tonihei · tonihei · commit f584849622a7 · 2026-02-05T10:43:18.000Z
The workaround introduced in a645066 should only be applied in cases where the stock system UI is used and the workaround is needed. In all other cases, like other manfacturers or when connected to Android Auto, the original usage is preferred as it more correctly represents the intention and helps to display the buttons more consistently. Issue: #3041 PiperOrigin-RevId: 865364728 (cherry picked from commit eeb5a2a)
diff --git a/RELEASENOTES.md b/RELEASENOTES.md
@@ -11,6 +11,10 @@ This release includes the following changes since
     *   Fix bug where `ProgressiveMediaSource` propagates out-of-date timeline
         info to player and the queued periods unexpectedly get removed
         ([#3016](https://github.com/androidx/media/issues/3016)).
+*   Session:
+    *   Fix issue where system UI button placement workaround negatively affects
+        other UI surface like Android Auto or manufacturers not needing the
+        workaround ([#3041](https://github.com/androidx/media/issues/3041)).
 *   Cast extension:
     *   Fix bug where transferring from Cast to local playback was broken.
 
diff --git a/libraries/session/src/main/java/androidx/media3/session/AndroidAutoConnectionStateObserver.java b/libraries/session/src/main/java/androidx/media3/session/AndroidAutoConnectionStateObserver.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2026 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 androidx.media3.session;
+
+import static android.os.Build.VERSION.SDK_INT;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.Cursor;
+import android.net.Uri;
+import androidx.media3.common.util.BackgroundExecutor;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/** Util class to observe the connection state to Android Auto. */
+/* package */ final class AndroidAutoConnectionStateObserver {
+
+  private static final Uri QUERY_URI = Uri.parse("content://androidx.car.app.connection");
+  private static final String QUERY_COLUMN = "CarConnectionState";
+  private static final String BROADCAST_INTENT =
+      "androidx.car.app.connection.action.CAR_CONNECTION_UPDATED";
+
+  private final Context context;
+  private final Runnable listener;
+  private final Executor backgroundExecutor;
+  private final AndroidAutoChangeReceiver changeReceiver;
+  private final AtomicBoolean isConnected;
+  private final AtomicBoolean isReleased;
+
+  /**
+   * Creates the observer.
+   *
+   * @param context A {@link Context}.
+   * @param onConnectionStateChanged Called when the return value of {@link #isConnected()} changed.
+   *     Will be called on a background thread.
+   */
+  public AndroidAutoConnectionStateObserver(Context context, Runnable onConnectionStateChanged) {
+    this.context = context.getApplicationContext();
+    this.listener = onConnectionStateChanged;
+    this.backgroundExecutor = BackgroundExecutor.get();
+    this.changeReceiver = new AndroidAutoChangeReceiver();
+    this.isConnected = new AtomicBoolean();
+    this.isReleased = new AtomicBoolean();
+    backgroundExecutor.execute(
+        () -> {
+          IntentFilter intentFilter = new IntentFilter(BROADCAST_INTENT);
+          if (SDK_INT >= 33) {
+            this.context.registerReceiver(changeReceiver, intentFilter, Context.RECEIVER_EXPORTED);
+          } else {
+            this.context.registerReceiver(changeReceiver, intentFilter);
+          }
+          updateConnectionState();
+        });
+  }
+
+  /** Release the observer. */
+  public void release() {
+    if (isReleased.getAndSet(true)) {
+      return;
+    }
+    backgroundExecutor.execute(() -> context.unregisterReceiver(changeReceiver));
+  }
+
+  /** Returns whether the device is currently connected to Android Auto. */
+  public boolean isConnected() {
+    return isConnected.get();
+  }
+
+  private void updateConnectionState() {
+    boolean oldValue = isConnected.get();
+    boolean newValue = queryConnectionState();
+    isConnected.set(newValue);
+    if (oldValue != newValue && !isReleased.get()) {
+      listener.run();
+    }
+  }
+
+  private boolean queryConnectionState() {
+    // Query the Android Auto content provider and check if it returns at least one non-zero entry
+    // for the requested query column.
+    try (Cursor cursor =
+        context
+            .getContentResolver()
+            .query(
+                QUERY_URI,
+                new String[] {QUERY_COLUMN},
+                /* selection= */ null,
+                /* selectionArgs= */ null,
+                /* orderBy= */ null)) {
+      if (cursor == null) {
+        return false;
+      }
+      int columnIndex = cursor.getColumnIndex(QUERY_COLUMN);
+      if (columnIndex == -1) {
+        return false;
+      }
+      if (!cursor.moveToNext()) {
+        return false;
+      }
+      return cursor.getInt(columnIndex) != 0;
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  private final class AndroidAutoChangeReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      backgroundExecutor.execute(AndroidAutoConnectionStateObserver.this::updateConnectionState);
+    }
+  }
+}
diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaSessionLegacyStub.java b/libraries/session/src/main/java/androidx/media3/session/MediaSessionLegacyStub.java
@@ -134,6 +134,8 @@
   private final MediaSessionManager sessionManager;
   private final ControllerLegacyCbForBroadcast controllerLegacyCbForBroadcast;
   private final ConnectionTimeoutHandler connectionTimeoutHandler;
+  private final boolean mayNeedButtonReservationWorkaroundForSeekbar;
+  @Nullable private final AndroidAutoConnectionStateObserver androidAutoObserver;
   private final MediaSessionCompat sessionCompat;
   @Nullable private final MediaButtonReceiver runtimeBroadcastReceiver;
   @Nullable private final ComponentName broadcastReceiverComponentName;
@@ -182,6 +184,8 @@ public MediaSessionLegacyStub(
     connectionTimeoutHandler =
         new ConnectionTimeoutHandler(
             session.getApplicationHandler().getLooper(), connectedControllersManager);
+    mayNeedButtonReservationWorkaroundForSeekbar =
+        mayNeedButtonReservationWorkaroundForSeekbar(context);
 
     if (!mediaButtonPreferences.isEmpty()) {
       updateCustomLayoutAndLegacyExtrasForMediaButtonPreferences();
@@ -260,6 +264,12 @@ public MediaSessionLegacyStub(
     @Initialized
     MediaSessionLegacyStub thisRef = this;
     sessionCompat.setCallback(thisRef, handler);
+
+    androidAutoObserver =
+        mayNeedButtonReservationWorkaroundForSeekbar
+            ? new AndroidAutoConnectionStateObserver(
+                context, thisRef::onAndroidAutoConnectionStateChanged)
+            : null;
   }
 
   /**
@@ -281,25 +291,7 @@ public void setAvailableCommands(
     this.availablePlayerCommands = playerCommands;
 
     if (!mediaButtonPreferences.isEmpty()) {
-      boolean hadPrevReservation =
-          legacyExtras.getBoolean(
-              MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV, /* defaultValue= */ false);
-      boolean hadNextReservation =
-          legacyExtras.getBoolean(
-              MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT, /* defaultValue= */ false);
-      updateCustomLayoutAndLegacyExtrasForMediaButtonPreferences();
-      boolean extrasChanged =
-          (legacyExtras.getBoolean(
-                      MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV,
-                      /* defaultValue= */ false)
-                  != hadPrevReservation)
-              || (legacyExtras.getBoolean(
-                      MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT,
-                      /* defaultValue= */ false)
-                  != hadNextReservation);
-      if (extrasChanged) {
-        getSessionCompat().setExtras(legacyExtras);
-      }
+      updateCustomLayoutAndLegacyExtrasForMediaButtonPreferencesAndInformExtrasChanged();
     }
 
     if (commandGetTimelineChanged) {
@@ -344,25 +336,7 @@ public void setPlatformCustomLayout(ImmutableList<CommandButton> customLayout) {
   public void setPlatformMediaButtonPreferences(
       ImmutableList<CommandButton> mediaButtonPreferences) {
     this.mediaButtonPreferences = mediaButtonPreferences;
-    boolean hadPrevReservation =
-        legacyExtras.getBoolean(
-            MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV, /* defaultValue= */ false);
-    boolean hadNextReservation =
-        legacyExtras.getBoolean(
-            MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT, /* defaultValue= */ false);
-    updateCustomLayoutAndLegacyExtrasForMediaButtonPreferences();
-    boolean extrasChanged =
-        (legacyExtras.getBoolean(
-                    MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV,
-                    /* defaultValue= */ false)
-                != hadPrevReservation)
-            || (legacyExtras.getBoolean(
-                    MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT,
-                    /* defaultValue= */ false)
-                != hadNextReservation);
-    if (extrasChanged) {
-      getSessionCompat().setExtras(legacyExtras);
-    }
+    updateCustomLayoutAndLegacyExtrasForMediaButtonPreferencesAndInformExtrasChanged();
   }
 
   /**
@@ -485,6 +459,9 @@ public void release() {
     if (runtimeBroadcastReceiver != null) {
       sessionImpl.getContext().unregisterReceiver(runtimeBroadcastReceiver);
     }
+    if (androidAutoObserver != null) {
+      androidAutoObserver.release();
+    }
     // No check for COMMAND_RELEASE needed as MediaControllers can always be released.
     sessionCompat.release();
   }
@@ -1253,6 +1230,34 @@ private boolean isQueueEnabled() {
         && playerWrapper.getAvailableCommands().contains(Player.COMMAND_GET_TIMELINE);
   }
 
+  private void onAndroidAutoConnectionStateChanged() {
+    postOrRun(
+        sessionImpl.getApplicationHandler(),
+        this::updateCustomLayoutAndLegacyExtrasForMediaButtonPreferencesAndInformExtrasChanged);
+  }
+
+  private void updateCustomLayoutAndLegacyExtrasForMediaButtonPreferencesAndInformExtrasChanged() {
+    boolean hadPrevReservation =
+        legacyExtras.getBoolean(
+            MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV, /* defaultValue= */ false);
+    boolean hadNextReservation =
+        legacyExtras.getBoolean(
+            MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT, /* defaultValue= */ false);
+    updateCustomLayoutAndLegacyExtrasForMediaButtonPreferences();
+    boolean extrasChanged =
+        (legacyExtras.getBoolean(
+                    MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV,
+                    /* defaultValue= */ false)
+                != hadPrevReservation)
+            || (legacyExtras.getBoolean(
+                    MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT,
+                    /* defaultValue= */ false)
+                != hadNextReservation);
+    if (extrasChanged) {
+      getSessionCompat().setExtras(legacyExtras);
+    }
+  }
+
   private void updateCustomLayoutAndLegacyExtrasForMediaButtonPreferences() {
     ImmutableList<CommandButton> mediaButtonPreferencesWithUnavailableButtonsDisabled =
         CommandButton.copyWithUnavailableButtonsDisabled(
@@ -1266,16 +1271,27 @@ private void updateCustomLayoutAndLegacyExtrasForMediaButtonPreferences() {
             mediaButtonPreferencesWithUnavailableButtonsDisabled,
             /* backSlotAllowed= */ true,
             /* forwardSlotAllowed= */ true);
-    // If no custom back slot button is defined and other custom forward or overflow buttons exist,
-    // we need to reserve the back slot to prevent the other buttons from moving into this slot. The
-    // forward slot should never be reserved to avoid gaps in the output. We explicitly clear the
-    // value to avoid any manually defined extras to interfere with our logic.
-    boolean reserveBackSpaceSlot =
-        !customLayout.isEmpty()
-            && !CommandButton.containsButtonForSlot(customLayout, CommandButton.SLOT_BACK);
-    legacyExtras.putBoolean(
-        MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV, reserveBackSpaceSlot);
-    legacyExtras.putBoolean(MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT, false);
+    if (needsButtonReservationWorkaroundForSeekbar(androidAutoObserver)) {
+      // When applying the workaround, if no custom back slot button is defined and other custom
+      // forward or overflow buttons exist, we need to reserve the back slot to prevent the other
+      // buttons from moving into this slot. The forward slot should never be reserved to avoid gaps
+      // in the output. We explicitly clear the value to avoid any manually defined extras to
+      // interfere with our logic.
+      boolean reserveBackSpaceSlot =
+          !customLayout.isEmpty()
+              && !CommandButton.containsButtonForSlot(customLayout, CommandButton.SLOT_BACK);
+      legacyExtras.putBoolean(
+          MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV, reserveBackSpaceSlot);
+      legacyExtras.putBoolean(MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT, false);
+    } else {
+      // Without the workaround, set the reservations to match our actual slot definition.
+      legacyExtras.putBoolean(
+          MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV,
+          !CommandButton.containsButtonForSlot(customLayout, CommandButton.SLOT_BACK));
+      legacyExtras.putBoolean(
+          MediaConstants.EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT,
+          !CommandButton.containsButtonForSlot(customLayout, CommandButton.SLOT_FORWARD));
+    }
   }
 
   private static MediaItem createMediaItemForMediaRequest(
@@ -2112,6 +2128,35 @@ public void onAdjustVolume(int direction) {
     };
   }
 
+  private boolean needsButtonReservationWorkaroundForSeekbar(
+      @Nullable AndroidAutoConnectionStateObserver androidAutoObserver) {
+    // Check if the device is generally known to require the workaround. Also disable the workaround
+    // when connected to Android Auto under the assumption that it is the main user interface while
+    // connected. See https://github.com/androidx/media/issues/3041.
+    if (!mayNeedButtonReservationWorkaroundForSeekbar) {
+      return false;
+    }
+    return androidAutoObserver == null || !androidAutoObserver.isConnected();
+  }
+
+  private static boolean mayNeedButtonReservationWorkaroundForSeekbar(Context context) {
+    // The stock system UMO has an issue that when a navigation button is reserved, it doesn't
+    // automatically fill its empty space with an extended seek bar, leaving an unexpected gap.
+    // This affects all manufacturers known to rely on the stock UMO from API 33. See
+    // https://github.com/androidx/media/issues/2976.
+    if (SDK_INT < 33) {
+      return false;
+    }
+    if (Util.isAutomotive(context)) {
+      return false;
+    }
+    return Build.MANUFACTURER.equals("Google")
+        || Build.MANUFACTURER.equals("motorola")
+        || Build.MANUFACTURER.equals("vivo")
+        || Build.MANUFACTURER.equals("Sony")
+        || Build.MANUFACTURER.equals("Nothing");
+  }
+
   /** Describes a legacy error. */
   private static final class LegacyError {
     public final boolean isFatal;
diff --git a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaControllerCompatPlaybackStateCompatActionsWithMediaSessionTest.java b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaControllerCompatPlaybackStateCompatActionsWithMediaSessionTest.java
@@ -16,6 +16,7 @@
 
 package androidx.media3.session;
 
+import static android.os.Build.VERSION.SDK_INT;
 import static androidx.media3.test.session.common.TestUtils.TIMEOUT_MS;
 import static androidx.media3.test.utils.TestUtil.getEventsAsList;
 import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
@@ -2027,11 +2028,20 @@ public void onPlaybackStateChanged(PlaybackStateCompat state) {
                 androidx.media.utils.MediaConstants
                     .SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_PREV))
         .isTrue();
-    assertThat(
-            extras2.getBoolean(
-                androidx.media.utils.MediaConstants
-                    .SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT))
-        .isFalse();
+    if (SDK_INT >= 33) {
+      // Applies if the workaround to disable to next reservation for SysUI is enabled.
+      assertThat(
+              extras2.getBoolean(
+                  androidx.media.utils.MediaConstants
+                      .SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT))
+          .isFalse();
+    } else {
+      assertThat(
+              extras2.getBoolean(
+                  androidx.media.utils.MediaConstants
+                      .SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT))
+          .isTrue();
+    }
     assertThat(actions2 & PlaybackStateCompat.ACTION_SKIP_TO_NEXT).isNotEqualTo(0);
     assertThat(actions2 & PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS).isNotEqualTo(0);
   }
