Add emergency wifi lock release

This copies the same changes applied to WakeLockManager to
WifiManager. See 80a3cde and fb2b678.

PiperOrigin-RevId: 817641489

Author: tonihei

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/WifiLockManager.java

@@ -15,14 +15,16 @@
  */
 package androidx.media3.exoplayer;
 
+import android.Manifest;
 import android.content.Context;
+import android.content.pm.PackageManager;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiManager.WifiLock;
 import android.os.Looper;
-import androidx.annotation.Nullable;
 import androidx.media3.common.util.Clock;
 import androidx.media3.common.util.HandlerWrapper;
 import androidx.media3.common.util.Log;
+import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 
 /**
  * Handles a {@link WifiLock}
@@ -34,9 +36,11 @@
 
   private static final String TAG = "WifiLockManager";
   private static final String WIFI_LOCK_TAG = "ExoPlayer:WifiLockManager";
+  private static final int UNREACTIVE_WIFILOCK_HANDLER_RELEASE_DELAY_MS = 1000;
 
   private final WifiLockManagerInternal wifiLockManagerInternal;
   private final HandlerWrapper wifiLockHandler;
+  private final HandlerWrapper mainHandler;
 
   private boolean enabled;
   private boolean stayAwake;
@@ -51,6 +55,7 @@
   public WifiLockManager(Context context, Looper wifiLockLooper, Clock clock) {
     wifiLockManagerInternal = new WifiLockManagerInternal(context.getApplicationContext());
     wifiLockHandler = clock.createHandler(wifiLockLooper, /* callback= */ null);
+    mainHandler = clock.createHandler(Looper.getMainLooper(), /* callback= */ null);
   }
 
   /**
@@ -68,8 +73,7 @@ public void setEnabled(boolean enabled) {
       return;
     }
     this.enabled = enabled;
-    boolean stayAwakeCurrent = stayAwake;
-    wifiLockHandler.post(() -> wifiLockManagerInternal.updateWifiLock(enabled, stayAwakeCurrent));
+    postUpdateWifiLock(enabled, stayAwake);
   }
 
   /**
@@ -87,24 +91,48 @@ public void setStayAwake(boolean stayAwake) {
     }
     this.stayAwake = stayAwake;
     if (enabled) {
+      postUpdateWifiLock(/* enabled= */ true, stayAwake);
+    }
+  }
+
+  private void postUpdateWifiLock(boolean enabled, boolean stayAwake) {
+    if (shouldAcquireWifilock(enabled, stayAwake)) {
+      wifiLockHandler.post(() -> wifiLockManagerInternal.updateWifiLock(enabled, stayAwake));
+    } else {
+      // When we are about to release a Wifi lock, add emergency safeguard on main thread in case
+      // the lock handler thread is unresponsive.
+      Runnable emergencyRelease = wifiLockManagerInternal::forceReleaseWifiLock;
+      mainHandler.postDelayed(emergencyRelease, UNREACTIVE_WIFILOCK_HANDLER_RELEASE_DELAY_MS);
       wifiLockHandler.post(
-          () -> wifiLockManagerInternal.updateWifiLock(/* enabled= */ true, stayAwake));
+          () -> {
+            mainHandler.removeCallbacks(emergencyRelease);
+            wifiLockManagerInternal.updateWifiLock(enabled, stayAwake);
+          });
     }
   }
 
+  private static boolean shouldAcquireWifilock(boolean enabled, boolean stayAwake) {
+    return enabled && stayAwake;
+  }
+
   /** Internal methods called on the wifi lock Looper. */
   private static final class WifiLockManagerInternal {
 
     private final Context applicationContext;
 
-    @Nullable private WifiLock wifiLock;
+    private @MonotonicNonNull WifiLock wifiLock;
 
     public WifiLockManagerInternal(Context applicationContext) {
       this.applicationContext = applicationContext;
     }
 
     public void updateWifiLock(boolean enabled, boolean stayAwake) {
       if (enabled && wifiLock == null) {
+        if (applicationContext.checkSelfPermission(Manifest.permission.WAKE_LOCK)
+            != PackageManager.PERMISSION_GRANTED) {
+          Log.w(TAG, "WAKE_LOCK permission not granted, can't acquire wake lock for playback");
+          return;
+        }
         WifiManager wifiManager =
             (WifiManager)
                 applicationContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
@@ -120,11 +148,17 @@ public void updateWifiLock(boolean enabled, boolean stayAwake) {
         return;
       }
 
-      if (enabled && stayAwake) {
+      if (shouldAcquireWifilock(enabled, stayAwake)) {
         wifiLock.acquire();
       } else {
         wifiLock.release();
       }
     }
+
+    private synchronized void forceReleaseWifiLock() {
+      if (wifiLock != null) {
+        wifiLock.release();
+      }
+    }
   }
 }

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/WakeLockManagerTest.java

@@ -24,6 +24,7 @@
 import android.os.HandlerThread;
 import android.os.PowerManager.WakeLock;
 import androidx.media3.common.util.Clock;
+import androidx.media3.common.util.ConditionVariable;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import java.time.Duration;
@@ -100,10 +101,11 @@ public void blockedWakeLockThread_wakeLockIsStillReleasedAfterTimeout() {
     WakeLock wakeLock = ShadowPowerManager.getLatestWakeLock();
 
     // Block the wake lock thread to prevent any progress.
+    ConditionVariable blockedWakeLockThread = new ConditionVariable();
     new Handler(handlerThread.getLooper())
         .post(
             () -> {
-              while (true) {}
+              while (!blockedWakeLockThread.isOpen()) {}
             });
     wakeLockManager.setEnabled(false);
     ShadowLooper.idleMainLooper();
@@ -112,5 +114,10 @@ public void blockedWakeLockThread_wakeLockIsStillReleasedAfterTimeout() {
     ShadowLooper.idleMainLooper();
 
     assertThat(wakeLock.isHeld()).isFalse();
+
+    // Verify that a slow background thread that unblocks itself can't cause any issues.
+    blockedWakeLockThread.open();
+    ShadowLooper.idleMainLooper();
+    assertThat(wakeLock.isHeld()).isFalse();
   }
 }

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/WifiLockManagerTest.java

@@ -18,28 +18,36 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.robolectric.Shadows.shadowOf;
 
+import android.Manifest;
+import android.app.Application;
 import android.content.Context;
 import android.net.wifi.WifiManager;
+import android.os.Handler;
 import android.os.HandlerThread;
 import androidx.media3.common.util.Clock;
+import androidx.media3.common.util.ConditionVariable;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
+import java.time.Duration;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.robolectric.shadows.ShadowLooper;
+import org.robolectric.shadows.ShadowSystemClock;
 
 /** Unit test for {@link WifiLockManager}. */
 @RunWith(AndroidJUnit4.class)
 public class WifiLockManagerTest {
 
-  private Context context;
+  private Application context;
   private HandlerThread handlerThread;
   private WifiManager wifiManager;
 
   @Before
   public void setUp() {
     context = ApplicationProvider.getApplicationContext();
+    shadowOf(context).grantPermissions(Manifest.permission.WAKE_LOCK);
     handlerThread = new HandlerThread("wifiLockManagerTest");
     handlerThread.start();
     wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
@@ -86,4 +94,35 @@ public void stayAwakeTrue_wifiLockIsOnlyHeldWhenEnabled() {
     assertThat(lockCountWhenStayAwake).isGreaterThan(initialLockCount);
     assertThat(lockCountAfterDisable).isLessThan(lockCountWhenStayAwake);
   }
+
+  @Test
+  public void blockedWakeLockThread_wifiLockIsStillReleasedAfterTimeout() {
+    WifiLockManager wifiLockManager =
+        new WifiLockManager(context, handlerThread.getLooper(), Clock.DEFAULT);
+    wifiLockManager.setEnabled(true);
+    wifiLockManager.setStayAwake(true);
+    shadowOf(handlerThread.getLooper()).idle();
+    int lockCountWhenEnabled = shadowOf(wifiManager).getActiveLockCount();
+
+    // Block the wake lock thread to prevent any progress.
+    ConditionVariable blockedWakeLockThread = new ConditionVariable();
+    new Handler(handlerThread.getLooper())
+        .post(
+            () -> {
+              while (!blockedWakeLockThread.isOpen()) {}
+            });
+    wifiLockManager.setEnabled(false);
+    ShadowLooper.idleMainLooper();
+    // Verify it didn't work yet.
+    assertThat(shadowOf(wifiManager).getActiveLockCount()).isEqualTo(lockCountWhenEnabled);
+    ShadowSystemClock.advanceBy(Duration.ofSeconds(5));
+    ShadowLooper.idleMainLooper();
+
+    assertThat(shadowOf(wifiManager).getActiveLockCount()).isLessThan(lockCountWhenEnabled);
+
+    // Verify that a slow background thread that unblocks itself can't cause any issues.
+    blockedWakeLockThread.open();
+    ShadowLooper.idleMainLooper();
+    assertThat(shadowOf(wifiManager).getActiveLockCount()).isLessThan(lockCountWhenEnabled);
+  }
 }