@capgo/native-audio 8.2.12 → 8.2.14

package/android/src/main/java/ee/forgr/audio/StreamAudioAsset.java

@@ -24,8 +24,6 @@ public class StreamAudioAsset extends AudioAsset {
     private float volume;
     private boolean isPrepared = false;
     private final float initialVolume;
-    private static final float FADE_STEP = 0.05f;
-    private static final int FADE_DELAY_MS = 80; // 80ms between steps
     private static final long LIVE_OFFSET_MS = 5000; // 5 seconds behind live
     private final java.util.Map<String, String> headers;
 
@@ -68,7 +66,7 @@ public class StreamAudioAsset extends AudioAsset {
     }
 
     private void initializePlayer() {
-        Log.d(TAG, "Initializing stream player with volume: " + volume);
+        logger.debug("Initializing stream player with volume: " + volume);
 
         // Configure HLS source with better settings for live streaming
         DefaultHttpDataSource.Factory httpDataSourceFactory = new DefaultHttpDataSource.Factory()
@@ -95,7 +93,7 @@ public class StreamAudioAsset extends AudioAsset {
             new Player.Listener() {
                 @Override
                 public void onPlaybackStateChanged(int state) {
-                    Log.d(TAG, "Stream state changed to: " + getStateString(state));
+                    logger.debug("Stream state changed to: " + getStateString(state));
                     if (state == Player.STATE_READY && !isPrepared) {
                         isPrepared = true;
                         if (player.isCurrentMediaItemLive()) {
@@ -106,17 +104,17 @@ public class StreamAudioAsset extends AudioAsset {
 
                 @Override
                 public void onIsLoadingChanged(boolean isLoading) {
-                    Log.d(TAG, "Loading state changed: " + isLoading);
+                    logger.debug("Loading state changed: " + isLoading);
                 }
 
                 @Override
                 public void onIsPlayingChanged(boolean isPlaying) {
-                    Log.d(TAG, "Playing state changed: " + isPlaying);
+                    logger.debug("Playing state changed: " + isPlaying);
                 }
 
                 @Override
                 public void onPlayerError(PlaybackException error) {
-                    Log.e(TAG, "Player error: " + error.getMessage());
+                    logger.error("Player error: " + error.getMessage());
                     isPrepared = false;
                     // Try to recover by recreating the player
                     owner
@@ -146,8 +144,8 @@ public class StreamAudioAsset extends AudioAsset {
     }
 
     @Override
-    public void play(Double time) throws Exception {
-        Log.d(TAG, "Play called with time: " + time + ", isPrepared: " + isPrepared);
+    public void play(double time, float volume) throws Exception {
+        logger.debug("Play called with time: " + time + ", isPrepared: " + isPrepared);
         owner
             .getActivity()
             .runOnUiThread(() -> {
@@ -157,23 +155,24 @@ public class StreamAudioAsset extends AudioAsset {
                         new Player.Listener() {
                             @Override
                             public void onPlaybackStateChanged(int state) {
-                                Log.d(TAG, "Play-wait state changed to: " + getStateString(state));
+                                logger.debug("Play-wait state changed to: " + getStateString(state));
                                 if (state == Player.STATE_READY) {
-                                    startPlayback(time);
+                                    startPlayback(time, volume);
+                                    startCurrentTimeUpdates();
                                     player.removeListener(this);
                                 }
                             }
                         }
                     );
                 } else {
-                    startPlayback(time);
+                    startPlayback(time, volume);
                 }
             });
     }
 
-    private void startPlayback(Double time) {
-        Log.d(TAG, "Starting playback with time: " + time);
-        if (time != null) {
+    private void startPlayback(double time, float volume) {
+        logger.debug("Starting playback with time: " + time);
+        if (time != 0) {
             player.seekTo(Math.round(time * 1000));
         } else if (player.isCurrentMediaItemLive()) {
             player.seekToDefaultPosition();
@@ -181,6 +180,7 @@ public class StreamAudioAsset extends AudioAsset {
         player.setPlaybackParameters(new PlaybackParameters(1.0f));
         player.setVolume(volume);
         player.setPlayWhenReady(true);
+        startCurrentTimeUpdates();
     }
 
     @Override
@@ -189,8 +189,10 @@ public class StreamAudioAsset extends AudioAsset {
         owner
             .getActivity()
             .runOnUiThread(() -> {
-                if (player.isPlaying()) {
+                cancelFade();
+                if (player != null && player.isPlaying()) {
                     player.setPlayWhenReady(false);
+                    stopCurrentTimeUpdates();
                     wasPlaying[0] = true;
                 }
             });
@@ -203,6 +205,7 @@ public class StreamAudioAsset extends AudioAsset {
             .getActivity()
             .runOnUiThread(() -> {
                 player.setPlayWhenReady(true);
+                startCurrentTimeUpdates();
             });
     }
 
@@ -211,6 +214,7 @@ public class StreamAudioAsset extends AudioAsset {
         owner
             .getActivity()
             .runOnUiThread(() -> {
+                cancelFade();
                 // First stop playback
                 player.stop();
                 // Reset player state
@@ -243,7 +247,7 @@ public class StreamAudioAsset extends AudioAsset {
                     new Player.Listener() {
                         @Override
                         public void onPlaybackStateChanged(int state) {
-                            Log.d(TAG, "Stop-reinit state changed to: " + getStateString(state));
+                            logger.debug("Stop-reinit state changed to: " + getStateString(state));
                             if (state == Player.STATE_READY) {
                                 isPrepared = true;
                                 player.removeListener(this);
@@ -264,6 +268,7 @@ public class StreamAudioAsset extends AudioAsset {
             .runOnUiThread(() -> {
                 player.setRepeatMode(Player.REPEAT_MODE_ONE);
                 player.setPlayWhenReady(true);
+                startCurrentTimeUpdates();
             });
     }
 
@@ -272,24 +277,58 @@ public class StreamAudioAsset extends AudioAsset {
         owner
             .getActivity()
             .runOnUiThread(() -> {
+                cancelFade();
                 player.stop();
                 player.clearMediaItems();
                 player.release();
                 isPrepared = false;
+                close(); // Ensure fadeExecutor is shutdown
             });
     }
 
     @Override
-    public void setVolume(float volume) throws Exception {
+    public void close() {
+        if (fadeExecutor != null && !fadeExecutor.isShutdown()) {
+            fadeExecutor.shutdown();
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            close();
+        } finally {
+            super.finalize();
+        }
+    }
+
+    @Override
+    public void setVolume(float volume, double duration) throws Exception {
         this.volume = volume;
         owner
             .getActivity()
             .runOnUiThread(() -> {
-                Log.d(TAG, "Setting volume to: " + volume);
-                player.setVolume(volume);
+                cancelFade();
+                try {
+                    if (this.isPlaying() && duration > 0) {
+                        fadeTo(duration, volume);
+                    } else {
+                        player.setVolume(volume);
+                    }
+                } catch (Exception e) {
+                    logger.error("Error setting volume", e);
+                }
             });
     }
 
+    @Override
+    public float getVolume() throws Exception {
+        if (player != null) {
+            return player.getVolume();
+        }
+        return 0;
+    }
+
     @Override
     public boolean isPlaying() throws Exception {
         return player != null && player.isPlaying();
@@ -340,8 +379,8 @@ public class StreamAudioAsset extends AudioAsset {
     }
 
     @Override
-    public void playWithFade(Double time) throws Exception {
-        Log.d(TAG, "PlayWithFade called with time: " + time);
+    public void playWithFadeIn(double time, float volume, double fadeInDurationMs) throws Exception {
+        logger.debug("playWithFadeIn called with time: " + time);
         owner
             .getActivity()
             .runOnUiThread(() -> {
@@ -352,19 +391,19 @@ public class StreamAudioAsset extends AudioAsset {
                             @Override
                             public void onPlaybackStateChanged(int state) {
                                 if (state == Player.STATE_READY) {
-                                    startPlaybackWithFade(time);
+                                    startPlaybackWithFade(time, volume, fadeInDurationMs);
                                     player.removeListener(this);
                                 }
                             }
                         }
                     );
                 } else {
-                    startPlaybackWithFade(time);
+                    startPlaybackWithFade(time, volume, fadeInDurationMs);
                 }
             });
     }
 
-    private void startPlaybackWithFade(Double time) {
+    private void startPlaybackWithFade(Double time, float targetVolume, double fadeInDurationMs) {
         if (!player.isPlayingAd()) {
             // Make sure we're not in an ad
             if (time != null) {
@@ -388,8 +427,9 @@ public class StreamAudioAsset extends AudioAsset {
                             // Start with volume 0
                             player.setVolume(0);
                             player.setPlayWhenReady(true);
+                            startCurrentTimeUpdates();
                             // Start fade after ensuring we're actually playing
-                            checkAndStartFade();
+                            checkAndStartFade(fadeInDurationMs, targetVolume);
                         }
                     }
                 }
@@ -397,7 +437,7 @@ public class StreamAudioAsset extends AudioAsset {
         }
     }
 
-    private void checkAndStartFade() {
+    private void checkAndStartFade(double fadeInDurationMs, float volume) {
         final Handler handler = new Handler(Looper.getMainLooper());
         handler.postDelayed(
             new Runnable() {
@@ -406,7 +446,7 @@ public class StreamAudioAsset extends AudioAsset {
                 @Override
                 public void run() {
                     if (player.isPlaying()) {
-                        fadeIn();
+                        fadeIn(fadeInDurationMs, volume);
                     } else if (attempts < 10) {
                         // Try for 5 seconds (10 * 500ms)
                         attempts++;
@@ -418,93 +458,166 @@ public class StreamAudioAsset extends AudioAsset {
         );
     }
 
-    private void fadeIn() {
-        final Handler handler = new Handler(Looper.getMainLooper());
-        final Runnable fadeRunnable = new Runnable() {
-            float currentVolume = 0;
+    private void fadeIn(double fadeInDurationMs, float targetVolume) {
+        cancelFade();
+        fadeState = FadeState.FADE_IN;
 
-            @Override
-            public void run() {
-                if (player != null && player.isPlaying() && currentVolume < volume) {
-                    currentVolume += FADE_STEP;
-                    if (currentVolume > volume) currentVolume = volume;
-                    player.setVolume(currentVolume);
-                    Log.d(TAG, "Fading in: volume = " + currentVolume);
-                    handler.postDelayed(this, FADE_DELAY_MS);
+        final int steps = Math.max(1, (int) (fadeInDurationMs / FADE_DELAY_MS));
+        final float fadeStep = targetVolume / steps;
+
+        fadeTask = fadeExecutor.scheduleWithFixedDelay(
+            new Runnable() {
+                float currentVolume = 0;
+
+                @Override
+                public void run() {
+                    if (fadeState != FadeState.FADE_IN || player == null || !player.isPlaying() || currentVolume >= targetVolume) {
+                        fadeState = FadeState.NONE;
+                        cancelFade();
+                        return;
+                    }
+
+                    final float nextVolume = Math.min(currentVolume + fadeStep, targetVolume);
+                    owner
+                        .getActivity()
+                        .runOnUiThread(() -> {
+                            if (player != null && player.isPlaying()) {
+                                player.setVolume(nextVolume);
+                            }
+                        });
+                    currentVolume = nextVolume;
                 }
-            }
-        };
-        handler.post(fadeRunnable);
+            },
+            0,
+            FADE_DELAY_MS,
+            java.util.concurrent.TimeUnit.MILLISECONDS
+        );
+    }
+
+    private void fadeTo(double fadeDurationMs, float targetVolume) {
+        cancelFade();
+        fadeState = FadeState.FADE_TO;
+
+        if (player == null) return;
+
+        final int steps = Math.max(1, (int) (fadeDurationMs / FADE_DELAY_MS));
+        final float minVolume = zeroVolume;
+        final float initialVolume = Math.max(player.getVolume(), minVolume);
+        final float finalTargetVolume = Math.max(targetVolume, minVolume);
+        final double ratio = Math.pow(finalTargetVolume / initialVolume, 1.0 / steps);
+        if (Double.isNaN(ratio) || Double.isInfinite(ratio)) {
+            player.setVolume(finalTargetVolume);
+            fadeState = FadeState.NONE;
+            return;
+        }
+
+        fadeTask = fadeExecutor.scheduleWithFixedDelay(
+            new Runnable() {
+                int currentStep = 0;
+                float currentVolume = initialVolume;
+
+                @Override
+                public void run() {
+                    if (fadeState != FadeState.FADE_TO || player == null || !player.isPlaying() || currentStep >= steps) {
+                        fadeState = FadeState.NONE;
+                        cancelFade();
+                        return;
+                    }
+
+                    currentVolume *= (float) ratio;
+                    final float nextVolume = Math.min(Math.max(currentVolume, minVolume), maxVolume);
+                    owner
+                        .getActivity()
+                        .runOnUiThread(() -> {
+                            if (player != null && player.isPlaying()) {
+                                player.setVolume(nextVolume);
+                            }
+                        });
+                    currentStep++;
+                }
+            },
+            0,
+            FADE_DELAY_MS,
+            java.util.concurrent.TimeUnit.MILLISECONDS
+        );
     }
 
     @Override
-    public void stopWithFade() throws Exception {
+    public void stopWithFade(double fadeOutDurationMs, boolean toPause) throws Exception {
         owner
             .getActivity()
             .runOnUiThread(() -> {
-                if (player.isPlaying()) {
-                    fadeOut();
+                if (player != null && player.isPlaying()) {
+                    fadeOut(fadeOutDurationMs, toPause);
+                } else if (!toPause) {
+                    try {
+                        stop();
+                    } catch (Exception e) {
+                        logger.error("Error stopping stream asset", e);
+                    }
                 }
             });
     }
 
-    private void fadeOut() {
-        final Handler handler = new Handler(Looper.getMainLooper());
-        final Runnable fadeRunnable = new Runnable() {
-            float currentVolume = player.getVolume();
-
-            @Override
-            public void run() {
-                if (currentVolume > FADE_STEP) {
-                    currentVolume -= FADE_STEP;
-                    player.setVolume(currentVolume);
-                    Log.d(TAG, "Fading out: volume = " + currentVolume);
-                    handler.postDelayed(this, FADE_DELAY_MS);
-                } else {
-                    player.setVolume(0);
-                    // Stop and reset player
-                    player.stop();
-                    player.clearMediaItems();
-                    isPrepared = false;
+    @Override
+    public void stopWithFade() throws Exception {
+        stopWithFade(DEFAULT_FADE_DURATION_MS, false);
+    }
 
-                    // Create new media source
-                    DefaultHttpDataSource.Factory httpDataSourceFactory = new DefaultHttpDataSource.Factory()
-                        .setAllowCrossProtocolRedirects(true)
-                        .setConnectTimeoutMs(15000)
-                        .setReadTimeoutMs(15000)
-                        .setUserAgent("ExoPlayer");
+    private void fadeOut(double fadeOutDurationMs, boolean toPause) {
+        cancelFade();
+        fadeState = FadeState.FADE_OUT;
 
-                    // Add custom headers if provided
-                    if (headers != null && !headers.isEmpty()) {
-                        httpDataSourceFactory.setDefaultRequestProperties(headers);
-                    }
+        if (player == null) return;
 
-                    HlsMediaSource mediaSource = new HlsMediaSource.Factory(httpDataSourceFactory)
-                        .setAllowChunklessPreparation(true)
-                        .setTimestampAdjusterInitializationTimeoutMs(LIVE_OFFSET_MS)
-                        .createMediaSource(MediaItem.fromUri(uri));
+        final int steps = Math.max(1, (int) (fadeOutDurationMs / FADE_DELAY_MS));
+        final float initialVolume = player.getVolume();
+        final float fadeStep = initialVolume / steps;
 
-                    // Set new media source and prepare
-                    player.setMediaSource(mediaSource);
-                    player.prepare();
+        fadeTask = fadeExecutor.scheduleWithFixedDelay(
+            new Runnable() {
+                float currentVolume = initialVolume;
 
-                    // Add listener for preparation completion
-                    player.addListener(
-                        new Player.Listener() {
-                            @Override
-                            public void onPlaybackStateChanged(int state) {
-                                Log.d(TAG, "Fade-stop state changed to: " + getStateString(state));
-                                if (state == Player.STATE_READY) {
-                                    isPrepared = true;
-                                    player.removeListener(this);
+                @Override
+                public void run() {
+                    if (fadeState != FadeState.FADE_OUT || player == null || currentVolume <= 0) {
+                        fadeState = FadeState.NONE;
+                        cancelFade();
+                        owner
+                            .getActivity()
+                            .runOnUiThread(() -> {
+                                if (player == null) {
+                                    return;
+                                }
+                                if (toPause) {
+                                    player.setPlayWhenReady(false);
+                                    stopCurrentTimeUpdates();
+                                } else {
+                                    try {
+                                        stop();
+                                    } catch (Exception e) {
+                                        logger.error("Error stopping stream asset after fade out", e);
+                                    }
                                 }
+                            });
+                        return;
+                    }
+
+                    final float nextVolume = Math.max(currentVolume - fadeStep, 0f);
+                    owner
+                        .getActivity()
+                        .runOnUiThread(() -> {
+                            if (player != null) {
+                                player.setVolume(nextVolume);
                             }
-                        }
-                    );
+                        });
+                    currentVolume = nextVolume;
                 }
-            }
-        };
-        handler.post(fadeRunnable);
+            },
+            0,
+            FADE_DELAY_MS,
+            java.util.concurrent.TimeUnit.MILLISECONDS
+        );
     }
 
     @Override
@@ -512,8 +625,84 @@ public class StreamAudioAsset extends AudioAsset {
         owner
             .getActivity()
             .runOnUiThread(() -> {
-                Log.d(TAG, "Setting playback rate to: " + rate);
+                logger.debug("Setting playback rate to: " + rate);
                 player.setPlaybackParameters(new PlaybackParameters(rate));
             });
     }
+
+    @Override
+    protected void startCurrentTimeUpdates() {
+        logger.debug("Starting timer updates");
+        if (currentTimeHandler == null) {
+            currentTimeHandler = new Handler(Looper.getMainLooper());
+        }
+        // Reset completion status for this assetId
+        dispatchedCompleteMap.put(assetId, false);
+
+        // Wait for player to be truly ready
+        currentTimeHandler.postDelayed(
+            new Runnable() {
+                @Override
+                public void run() {
+                    if (player != null && player.getPlaybackState() == Player.STATE_READY) {
+                        startTimeUpdateLoop();
+                    } else {
+                        // Check again in 100ms
+                        currentTimeHandler.postDelayed(this, 100);
+                    }
+                }
+            },
+            100
+        );
+    }
+
+    private void startTimeUpdateLoop() {
+        currentTimeRunnable = new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    boolean isPaused = false;
+                    if (player != null && player.getPlaybackState() == Player.STATE_READY) {
+                        if (player.isPlaying()) {
+                            double currentTime = player.getCurrentPosition() / 1000.0; // Get time directly
+                            logger.debug("Play timer update: currentTime = " + currentTime);
+                            if (owner != null) owner.notifyCurrentTime(assetId, currentTime);
+                            currentTimeHandler.postDelayed(this, 100);
+                            return;
+                        } else if (!player.getPlayWhenReady()) {
+                            isPaused = true;
+                        }
+                    }
+                    logger.debug("Stopping play timer - not playing or not ready");
+                    stopCurrentTimeUpdates();
+                    if (isPaused) {
+                        logger.verbose("Playback is paused, not dispatching complete");
+                    } else {
+                        logger.verbose("Playback is stopped, dispatching complete");
+                        dispatchComplete();
+                    }
+                } catch (Exception e) {
+                    logger.error("Error getting current time", e);
+                    stopCurrentTimeUpdates();
+                }
+            }
+        };
+        try {
+            if (currentTimeHandler == null) {
+                currentTimeHandler = new Handler(Looper.getMainLooper());
+            }
+            currentTimeHandler.post(currentTimeRunnable);
+        } catch (Exception e) {
+            logger.error("Error starting current time updates", e);
+        }
+    }
+
+    @Override
+    void stopCurrentTimeUpdates() {
+        logger.debug("Stopping play timer updates");
+        if (currentTimeHandler != null) {
+            currentTimeHandler.removeCallbacks(currentTimeRunnable);
+            currentTimeHandler = null;
+        }
+    }
 }