ExoPlayer

import androidx.media3.exoplayer.ExoPlayer;
import androidx.media3.exoplayer.ExoPlayer.AudioOffloadListener;
import androidx.media3.exoplayer.ExoPlayer.PreloadConfiguration;
import androidx.media3.exoplayer.DefaultRenderersFactory;
import androidx.media3.exoplayer.DefaultLoadControl;
import androidx.media3.exoplayer.ScrubbingModeParameters;
import androidx.media3.exoplayer.trackselection.DefaultTrackSelector;
import androidx.media3.exoplayer.source.MediaSource;
import androidx.media3.exoplayer.image.ImageOutput;
import androidx.media3.common.MediaItem;
import androidx.media3.common.DeviceInfo;

import androidx.media3.exoplayer.ExoPlayer;
import androidx.media3.common.MediaItem;
import android.content.Context;

// Create ExoPlayer instance
ExoPlayer player = new ExoPlayer.Builder(context).build();

// Set media item and prepare
MediaItem mediaItem = MediaItem.fromUri("https://example.com/video.mp4");
player.setMediaItem(mediaItem);
player.prepare();

// Start playback
player.setPlayWhenReady(true);

// Release when done
player.release();

public interface ExoPlayer extends Player {
    static final class Builder {
        public Builder(Context context);
        public Builder setRenderersFactory(RenderersFactory renderersFactory);
        public Builder setTrackSelector(TrackSelector trackSelector);
        public Builder setLoadControl(LoadControl loadControl);
        public Builder setBandwidthMeter(BandwidthMeter bandwidthMeter);
        public Builder setAnalyticsCollector(AnalyticsCollector analyticsCollector);
        public Builder setLooper(Looper looper);
        public Builder setPriorityTaskManager(PriorityTaskManager priorityTaskManager);
        public Builder setClock(Clock clock);
        public Builder setUseLazyPreparation(boolean useLazyPreparation);
        public Builder setPlaybackLooper(Looper playbackLooper);
        public Builder setName(String playerName);
        public Builder experimentalSetForegroundModeTimeoutMs(long timeoutMs);
        public Builder experimentalSetDynamicSchedulingEnabled(boolean dynamicSchedulingEnabled);
        public ExoPlayer build();
    }
    
    void addAnalyticsListener(AnalyticsListener listener);
    void removeAnalyticsListener(AnalyticsListener listener);
    void addAudioOffloadListener(AudioOffloadListener listener);
    void removeAudioOffloadListener(AudioOffloadListener listener);
    int getRendererCount();
    @C.TrackType int getRendererType(int index);
    Renderer getRenderer(int index);
    void setMediaSource(MediaSource mediaSource);
    void setMediaSources(List<MediaSource> mediaSources);
    void addMediaSource(MediaSource mediaSource);
    void setAudioSessionId(int audioSessionId);
    int getAudioSessionId();
    void setVideoEffects(List<Effect> videoEffects);
    void setVideoScalingMode(@C.VideoScalingMode int videoScalingMode);
    void setVideoChangeFrameRateStrategy(@C.VideoChangeFrameRateStrategy int videoChangeFrameRateStrategy);
    void setImageOutput(ImageOutput imageOutput);
    PlayerMessage createMessage(PlayerMessage.Target target);
    void setSeekParameters(SeekParameters seekParameters);
    void setPreloadConfiguration(PreloadConfiguration preloadConfiguration);
    PreloadConfiguration getPreloadConfiguration();
    void setScrubbingModeEnabled(boolean scrubbingModeEnabled);
    boolean isScrubbingModeEnabled();
    void setScrubbingModeParameters(ScrubbingModeParameters scrubbingModeParameters);
    ScrubbingModeParameters getScrubbingModeParameters();
    void setForegroundMode(boolean foregroundMode);
    DeviceInfo getDeviceInfo();
    int getDeviceVolume();
    boolean isDeviceMuted();
    void setDeviceVolume(int volume, @C.VolumeFlags int flags);
    void increaseDeviceVolume(@C.VolumeFlags int flags);
    void decreaseDeviceVolume(@C.VolumeFlags int flags);
    void setDeviceMuted(boolean muted, @C.VolumeFlags int flags);
    boolean isTunnelingEnabled();
    boolean isSleepingForOffload();
    boolean isReleased();
}

public interface MediaSource {
    interface Factory {
        MediaSource createMediaSource(MediaItem mediaItem);
        @C.ContentType int[] getSupportedTypes();
    }
    
    void prepareSource(MediaSourceCaller caller, @Nullable TransferListener mediaTransferListener, PlayerId playerId);
    MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs);
    void releasePeriod(MediaPeriod mediaPeriod);
    boolean canUpdateMediaItem(MediaItem mediaItem);
    MediaSource updateMediaItem(MediaItem mediaItem);
}

public class DefaultTrackSelector extends MappingTrackSelector {
    public static final class Builder {
        public Builder(Context context);
        public Builder setForceLowestBitrate(boolean forceLowestBitrate);
        public Builder setForceHighestSupportedBitrate(boolean forceHighestSupportedBitrate);
        public Builder setTunnelingEnabled(boolean tunnelingEnabled);
        public DefaultTrackSelector build();
    }
    
    public static final class Parameters extends TrackSelectionParameters {
        public static final class Builder extends TrackSelectionParameters.Builder {
            public Builder(Context context);
            public Builder setForceLowestBitrate(boolean forceLowestBitrate);
            public Builder setForceHighestSupportedBitrate(boolean forceHighestSupportedBitrate);
            public Parameters build();
        }
    }
    
    public void setParameters(Parameters parameters);
    public Parameters getParameters();
    public Parameters.Builder buildUponParameters();
}

public interface AudioSink {
    void configure(Format format, int specifiedBufferSize, @Nullable int[] outputChannels) throws ConfigurationException;
    void play();
    void pause();
    void playToEndOfStream() throws WriteException;
    void reset();
    void release();
    void setVolume(float volume);
    void setAudioAttributes(AudioAttributes audioAttributes);
    void setAuxEffectInfo(AuxEffectInfo auxEffectInfo);
    PlaybackParameters getPlaybackParameters();
    void setPlaybackParameters(PlaybackParameters playbackParameters);
    boolean handleBuffer(ByteBuffer buffer, long presentationTimeUs, int encodedAccessUnitCount) throws WriteException;
}

public class MediaCodecVideoRenderer extends MediaCodecRenderer {
    public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector, long allowedJoiningTimeMs);
    public void setVideoFrameMetadataListener(VideoFrameMetadataListener listener);
    public void clearVideoFrameMetadataListener();
}

public interface VideoSink {
    void onInputStreamChanged(@C.TrackType int inputType, Format format);
    void registerInputStream(@C.TrackType int inputType, List<Effect> effects);
    void setOutputSurfaceInfo(Surface outputSurface, Size outputResolution);
    boolean render(long presentationTimeUs, long releaseTimeNs) throws VideoSinkException;
    void join();
    void release();
}

public interface AnalyticsListener {
    void onPlaybackStateChanged(EventTime eventTime, @Player.State int state);
    void onPlayWhenReadyChanged(EventTime eventTime, boolean playWhenReady, @Player.PlayWhenReadyChangeReason int reason);
    void onIsPlayingChanged(EventTime eventTime, boolean isPlaying);
    void onTimelineChanged(EventTime eventTime, @Player.TimelineChangeReason int reason);
    void onTracksChanged(EventTime eventTime, Tracks tracks);
    void onPlayerError(EventTime eventTime, PlaybackException error);
    void onSeekStarted(EventTime eventTime);
    void onSeekProcessed(EventTime eventTime);
    void onVideoSizeChanged(EventTime eventTime, VideoSize videoSize);
    void onAudioSessionIdChanged(EventTime eventTime, int audioSessionId);
}

public interface DrmSessionManager {
    void prepare();
    @C.CryptoType int getCryptoType(Format format);
    DrmSession acquireSession(Looper playbackLooper, DrmInitData drmInitData);
    void releaseSession(DrmSession drmSession);
    void setMode(@C.CryptoMode int mode, @Nullable byte[] offlineLicenseKeySetId);
    void setPlayer(Looper playbackLooper, PlayerId playerId);
}

public class DownloadManager {
    public DownloadManager(Context context, DownloadIndex downloadIndex, DownloaderFactory downloaderFactory);
    public void addListener(Listener listener);
    public void removeListener(Listener listener);
    public void start();
    public void stop();
    public void pause();
    public void resume();
}

public interface Downloader {
    void download(@Nullable ProgressListener progressListener) throws IOException, InterruptedException;
    void cancel();
    void remove() throws IOException;
}

public final class ExoPlaybackException extends PlaybackException {
    public static final int TYPE_SOURCE = 0;
    public static final int TYPE_RENDERER = 1;
    public static final int TYPE_UNEXPECTED = 2;
    public static final int TYPE_REMOTE = 3;
    
    @Type public int type;
    @Nullable public int rendererIndex;
    @Nullable public Format rendererFormat;
    @Nullable public String rendererName;
    @Nullable public MediaPeriodId mediaPeriodId;
    
    public int getType();
    public int getRendererIndex();
    @Nullable public Format getRendererFormat();
    @Nullable public String getRendererName();
    @Nullable public MediaPeriodId getMediaPeriodId();
    public ExoPlaybackException copyWithMediaPeriodId(@Nullable MediaPeriodId mediaPeriodId);
}

public final class SeekParameters {
    public static final SeekParameters DEFAULT;
    public static final SeekParameters EXACT;
    public static final SeekParameters CLOSEST_SYNC;
    public static final SeekParameters PREVIOUS_SYNC;
    public static final SeekParameters NEXT_SYNC;
    
    public final long toleranceBeforeUs;
    public final long toleranceAfterUs;
}

public final class PlayerMessage {
    public PlayerMessage.Target getTarget();
    public int getType();
    @Nullable public Object getPayload();
    public Looper getLooper();
    public PlayerMessage setType(int messageType);
    public PlayerMessage setPayload(@Nullable Object payload);
    public PlayerMessage setPosition(long positionMs);
    public PlayerMessage setPosition(int mediaItemIndex, long positionMs);
    public PlayerMessage setHandler(Handler handler);
    public PlayerMessage send();
    public boolean cancel();
}

public static final class PreloadConfiguration {
    public static final PreloadConfiguration DEFAULT;
    
    public final long targetPreloadDurationUs;
    
    public PreloadConfiguration(long targetPreloadDurationUs);
}

public final class ScrubbingModeParameters {
    public static final ScrubbingModeParameters DEFAULT;
    
    public final long maxSeekToPreviousPositionMs;
    public final long seekBackIncrementMs;
    public final long seekForwardIncrementMs;
    
    public ScrubbingModeParameters(long maxSeekToPreviousPositionMs, long seekBackIncrementMs, long seekForwardIncrementMs);
}

public interface AudioOffloadListener {
    default void onSleepingForOffloadChanged(boolean isSleepingForOffload);
    default void onOffloadedPlayback(boolean isOffloadedPlayback);
}

// Constants
public interface ExoPlayer extends Player {
    long DEFAULT_RELEASE_TIMEOUT_MS = 500;
    long DEFAULT_DETACH_SURFACE_TIMEOUT_MS = 2000;
}