NewPipe/app/src/main/java/org/schabi/newpipe/player/mediasource/DeferredMediaSource.java

package org.schabi.newpipe.player.mediasource;

import android.support.annotation.NonNull;
import android.util.Log;

import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.source.MediaPeriod;
import com.google.android.exoplayer2.source.MediaSource;
import com.google.android.exoplayer2.upstream.Allocator;

import org.schabi.newpipe.extractor.stream.StreamInfo;
import org.schabi.newpipe.playlist.PlayQueueItem;

import java.io.IOException;

import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

/**
 * DeferredMediaSource is specifically designed to allow external control over when
 * the source metadata are loaded while being compatible with ExoPlayer's playlists.
 *
 * This media source follows the structure of how NewPipeExtractor's
 * {@link org.schabi.newpipe.extractor.stream.StreamInfoItem} is converted into
 * {@link org.schabi.newpipe.extractor.stream.StreamInfo}. Once conversion is complete,
 * this media source behaves identically as any other native media sources.
 * */
public final class DeferredMediaSource implements MediaSource {
    private final String TAG = "DeferredMediaSource@" + Integer.toHexString(hashCode());

    private int state = -1;

    public final static int STATE_INIT = 0;
    public final static int STATE_PREPARED = 1;
    public final static int STATE_LOADED = 2;
    public final static int STATE_DISPOSED = 3;

    public interface Callback {
        /**
         * Player-specific MediaSource resolution from given StreamInfo.
         * */
        MediaSource sourceOf(final StreamInfo info);
    }

    private PlayQueueItem stream;
    private Callback callback;

    private MediaSource mediaSource;

    private Disposable loader;

    private ExoPlayer exoPlayer;
    private Listener listener;
    private Throwable error;

    public DeferredMediaSource(@NonNull final PlayQueueItem stream,
                               @NonNull final Callback callback) {
        this.stream = stream;
        this.callback = callback;
        this.state = STATE_INIT;
    }

    /**
     * Parameters are kept in the class for delayed preparation.
     * */
    @Override
    public void prepareSource(ExoPlayer exoPlayer, boolean isTopLevelSource, Listener listener) {
        this.exoPlayer = exoPlayer;
        this.listener = listener;
        this.state = STATE_PREPARED;
    }

    public int state() {
        return state;
    }

    /**
     * Externally controlled loading. This method fully prepares the source to be used
     * like any other native MediaSource.
     *
     * Ideally, this should be called after this source has entered PREPARED state and
     * called once only.
     *
     * If loading fails here, an error will be propagated out and result in a
     * {@link com.google.android.exoplayer2.ExoPlaybackException}, which is delegated
     * to the player.
     * */
    public synchronized void load() {
        if (state != STATE_PREPARED || stream == null || loader != null) return;
        Log.d(TAG, "Loading: [" + stream.getTitle() + "] with url: " + stream.getUrl());

        final Consumer<StreamInfo> onSuccess = new Consumer<StreamInfo>() {
            @Override
            public void accept(StreamInfo streamInfo) throws Exception {
                Log.d(TAG, " Loaded: [" + stream.getTitle() + "] with url: " + stream.getUrl());
                state = STATE_LOADED;

                if (exoPlayer == null || listener == null || streamInfo == null) {
                    error = new Throwable("Stream info loading failed. URL: " + stream.getUrl());
                    return;
                }

                mediaSource = callback.sourceOf(streamInfo);
                if (mediaSource == null) {
                    error = new Throwable("Unable to resolve source from stream info. URL: " + stream.getUrl() +
                            ", audio count: " + streamInfo.audio_streams.size() +
                            ", video count: " + streamInfo.video_only_streams.size() + streamInfo.video_streams.size());
                    return;
                }

                mediaSource.prepareSource(exoPlayer, false, listener);
            }
        };

        final Consumer<Throwable> onError = new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "Loading error:", throwable);
                error = throwable;
                state = STATE_LOADED;
            }
        };

        loader = stream.getStream()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(onSuccess, onError);
    }

    @Override
    public void maybeThrowSourceInfoRefreshError() throws IOException {
        if (error != null) {
            throw new IOException(error);
        }

        if (mediaSource != null) {
            mediaSource.maybeThrowSourceInfoRefreshError();
        }
    }

    @Override
    public MediaPeriod createPeriod(MediaPeriodId mediaPeriodId, Allocator allocator) {
        return mediaSource.createPeriod(mediaPeriodId, allocator);
    }

    @Override
    public void releasePeriod(MediaPeriod mediaPeriod) {
        if (mediaSource == null) {
            Log.e(TAG, "releasePeriod() called when media source is null, memory leak may have occurred.");
        } else {
            mediaSource.releasePeriod(mediaPeriod);
        }
    }

    @Override
    public void releaseSource() {
        state = STATE_DISPOSED;

        if (mediaSource != null) {
            mediaSource.releaseSource();
        }
        if (loader != null) {
            loader.dispose();
        }

        /* Do not set mediaSource as null here as it may be called through releasePeriod */
        stream = null;
        callback = null;
        exoPlayer = null;
        listener = null;
    }
}