Stop playback when #74 happens

Author: devgianlu

core/src/main/java/xyz/gianlu/librespot/cdn/CdnManager.java

@@ -224,11 +224,8 @@ private void requestChunk(int index, boolean retried) {
                 writeChunk(resp.buffer, index, false);
             } catch (IOException ex) {
                 LOGGER.fatal(String.format("Failed requesting chunk from network, index: %d, retried: %b", index, retried), ex);
-                if (retried) {
-                    // TODO: Fatal
-                } else {
-                    requestChunk(index, true);
-                }
+                if (retried) internalStream.notifyChunkError(index, new AbsChunckedInputStream.ChunkException(ex));
+                else requestChunk(index, true);
             }
         }
 

core/src/main/java/xyz/gianlu/librespot/player/AbsChunckedInputStream.java

@@ -14,6 +14,7 @@
 public abstract class AbsChunckedInputStream extends InputStream {
     private static final int PRELOAD_AHEAD = 3;
     private final AtomicInteger waitForChunk = new AtomicInteger(-1);
+    private ChunkException chunkException = null;
     private int pos = 0;
     private int mark = 0;
     private volatile boolean closed = false;
@@ -75,8 +76,13 @@ public void waitFor(int chunkIndex) throws IOException {
 
         synchronized (waitForChunk) {
             try {
+                chunkException = null;
+
                 waitForChunk.set(chunkIndex);
                 waitForChunk.wait();
+
+                if (chunkException != null)
+                    throw chunkException;
             } catch (InterruptedException ex) {
                 throw new IOException(ex);
             }
@@ -163,4 +169,32 @@ public final void notifyChunkAvailable(int index) {
             }
         }
     }
+
+    public final void notifyChunkError(int index, @NotNull ChunkException ex) {
+        availableChunks()[index] = false;
+        requestedChunks()[index] = false;
+
+        if (index == waitForChunk.get()) {
+            synchronized (waitForChunk) {
+                chunkException = ex;
+                waitForChunk.set(-1);
+                waitForChunk.notifyAll();
+            }
+        }
+    }
+
+    public static class ChunkException extends IOException {
+        public ChunkException(@NotNull Throwable cause) {
+            super(cause);
+        }
+
+        private ChunkException(@NotNull String message) {
+            super(message);
+        }
+
+        @NotNull
+        public static ChunkException from(short streamError) {
+            return new ChunkException("Failed due to stream error, code: " + streamError);
+        }
+    }
 }

core/src/main/java/xyz/gianlu/librespot/player/Player.java

@@ -373,6 +373,22 @@ public void preloadNextTrack(@NotNull TrackHandler handler) {
         }
     }
 
+    @Override
+    public void playbackError(@NotNull TrackHandler handler, @NotNull Exception ex) {
+        if (handler == trackHandler) {
+            if (ex instanceof AbsChunckedInputStream.ChunkException)
+                LOGGER.fatal("Failed retrieving chunk, playback failed!", ex);
+            else
+                LOGGER.fatal("Playback error!", ex);
+
+            state.setStatus(Spirc.PlayStatus.kPlayStatusStop);
+            stateUpdated();
+        } else if (handler == preloadTrackHandler) {
+            LOGGER.warn("Preloaded track loading failed!", ex);
+            preloadTrackHandler = null;
+        }
+    }
+
     private void handleLoad(@NotNull Remote3Frame frame) {
         if (!spirc.deviceState().getIsActive()) {
             spirc.deviceState()

core/src/main/java/xyz/gianlu/librespot/player/TrackHandler.java

@@ -135,7 +135,7 @@ public void endOfTrack() {
 
     @Override
     public void playbackError(@NotNull Exception ex) {
-        LOGGER.fatal("Playback failed!", ex);
+        listener.playbackError(this, ex);
     }
 
     @Override
@@ -190,6 +190,8 @@ public interface Listener {
         void endOfTrack(@NotNull TrackHandler handler);
 
         void preloadNextTrack(@NotNull TrackHandler handler);
+
+        void playbackError(@NotNull TrackHandler handler, @NotNull Exception ex);
     }
 
     private class Looper implements Runnable {

core/src/main/java/xyz/gianlu/librespot/player/feeders/storage/AudioFileFetch.java

@@ -4,6 +4,7 @@
 import org.jetbrains.annotations.Nullable;
 import xyz.gianlu.librespot.cache.CacheManager;
 import xyz.gianlu.librespot.common.Utils;
+import xyz.gianlu.librespot.player.AbsChunckedInputStream;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -21,6 +22,7 @@ public class AudioFileFetch implements AudioFile {
     private int size = -1;
     private int chunks = -1;
     private volatile boolean closed = false;
+    private Short streamError = null;
 
     AudioFileFetch(@Nullable CacheManager.Handler cache) {
         this.cache = cache;
@@ -49,20 +51,29 @@ public synchronized void writeHeader(byte id, byte[] bytes, boolean cached) thro
             size = ByteBuffer.wrap(bytes).getInt();
             size *= 4;
             chunks = (size + CHUNK_SIZE - 1) / CHUNK_SIZE;
+
+            streamError = null;
             notifyAll();
         }
     }
 
     @Override
-    public void streamError(int chunkIndex, short code) {
-        LOGGER.fatal(String.format("Stream error, index: %d, code: %d", chunkIndex, code)); // TODO: Fatal
+    public synchronized void streamError(int chunkIndex, short code) {
+        LOGGER.fatal(String.format("Stream error, index: %d, code: %d", chunkIndex, code));
+
+        streamError = code;
+        notifyAll();
     }
 
-    synchronized void waitChunk() {
+    synchronized void waitChunk() throws AbsChunckedInputStream.ChunkException {
         if (size != -1) return;
 
         try {
+            streamError = null;
             wait();
+
+            if (streamError != null)
+                throw AbsChunckedInputStream.ChunkException.from(streamError);
         } catch (InterruptedException ex) {
             throw new RuntimeException(ex);
         }

core/src/main/java/xyz/gianlu/librespot/player/feeders/storage/AudioFileStreaming.java

@@ -66,11 +66,10 @@ private void requestChunk(@NotNull ByteString fileId, int index, @NotNull AudioF
                 session.channel().requestChunk(fileId, index, file);
             } catch (IOException ex) {
                 LOGGER.fatal(String.format("Failed requesting chunk from network, index: %d, retried: %b", index, retried), ex);
-                if (retried) {
-                    // TODO: Fatal
-                } else {
+                if (retried)
+                    chunksBuffer.internalStream.notifyChunkError(index, new AbsChunckedInputStream.ChunkException(ex));
+                else
                     requestChunk(fileId, index, file, true);
-                }
             }
         }
     }
@@ -150,7 +149,8 @@ public void writeHeader(byte id, byte[] bytes, boolean cached) {
 
     @Override
     public void streamError(int chunkIndex, short code) {
-        LOGGER.fatal(String.format("Stream error, index: %d, code: %d", chunkIndex, code)); // TODO: Fatal
+        LOGGER.fatal(String.format("Stream error, index: %d, code: %d", chunkIndex, code));
+        chunksBuffer.internalStream.notifyChunkError(chunkIndex, AbsChunckedInputStream.ChunkException.from(code));
     }
 
     @Override