Core Player

public interface ExoPlayer extends Player {
    // Analytics
    void addAnalyticsListener(AnalyticsListener listener);
    void removeAnalyticsListener(AnalyticsListener listener);
    
    // Audio offload
    void addAudioOffloadListener(AudioOffloadListener listener);
    void removeAudioOffloadListener(AudioOffloadListener listener);
    
    // Renderer access
    int getRendererCount();
    @C.TrackType int getRendererType(int index);
    Renderer getRenderer(int index);
    
    // Media source management
    void setMediaSource(MediaSource mediaSource);
    void setMediaSources(List<MediaSource> mediaSources);
    void addMediaSource(MediaSource mediaSource);
    void addMediaSource(int index, MediaSource mediaSource);
    void addMediaSources(List<MediaSource> mediaSources);
    void addMediaSources(int index, List<MediaSource> mediaSources);
    void removeMediaItem(int index);
    void removeMediaItems(int fromIndex, int toIndex);
    void moveMediaItem(int currentIndex, int newIndex);
    void moveMediaItems(int fromIndex, int toIndex, int newIndex);
    
    // Audio configuration
    void setAudioSessionId(int audioSessionId);
    int getAudioSessionId();
    
    // Video configuration
    void setVideoEffects(List<Effect> videoEffects);
    void setVideoScalingMode(@C.VideoScalingMode int videoScalingMode);
    void setVideoChangeFrameRateStrategy(@C.VideoChangeFrameRateStrategy int videoChangeFrameRateStrategy);
    
    // Image output
    void setImageOutput(ImageOutput imageOutput);
    
    // Message passing
    PlayerMessage createMessage(PlayerMessage.Target target);
    
    // Seek configuration
    void setSeekParameters(SeekParameters seekParameters);
    
    // Preload configuration
    void setPreloadConfiguration(PreloadConfiguration preloadConfiguration);
    PreloadConfiguration getPreloadConfiguration();
    
    // Scrubbing mode
    void setScrubbingModeEnabled(boolean scrubbingModeEnabled);
    boolean isScrubbingModeEnabled();
    void setScrubbingModeParameters(ScrubbingModeParameters scrubbingModeParameters);
    ScrubbingModeParameters getScrubbingModeParameters();
    
    // Playback control
    void setForegroundMode(boolean foregroundMode);
    boolean isTunnelingEnabled();
    boolean isSleepingForOffload();
    boolean isReleased();
    
    // Device information
    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);
}

public static final class Builder {
    /**
     * Creates a builder with the specified context.
     *
     * @param context The context
     */
    public Builder(Context context);
    
    /**
     * Sets the RenderersFactory for creating Renderers for the player.
     * 
     * @param renderersFactory The RenderersFactory
     * @return This builder
     */
    public Builder setRenderersFactory(RenderersFactory renderersFactory);
    
    /**
     * Sets the TrackSelector for selecting tracks to be consumed by the player's renderers.
     * 
     * @param trackSelector The TrackSelector
     * @return This builder
     */
    public Builder setTrackSelector(TrackSelector trackSelector);
    
    /**
     * Sets the LoadControl that will control when the MediaSource buffers more media.
     * 
     * @param loadControl The LoadControl
     * @return This builder
     */
    public Builder setLoadControl(LoadControl loadControl);
    
    /**
     * Sets the BandwidthMeter that will be used by the player.
     * 
     * @param bandwidthMeter The BandwidthMeter
     * @return This builder
     */
    public Builder setBandwidthMeter(BandwidthMeter bandwidthMeter);
    
    /**
     * Sets the AnalyticsCollector that will collect and forward analytics events.
     * 
     * @param analyticsCollector The AnalyticsCollector
     * @return This builder
     */
    public Builder setAnalyticsCollector(AnalyticsCollector analyticsCollector);
    
    /**
     * Sets the Looper that must be used for all calls to the player.
     * 
     * @param looper The Looper
     * @return This builder
     */
    public Builder setLooper(Looper looper);
    
    /**
     * Sets the PriorityTaskManager that will be used to prioritize loading.
     * 
     * @param priorityTaskManager The PriorityTaskManager
     * @return This builder
     */
    public Builder setPriorityTaskManager(@Nullable PriorityTaskManager priorityTaskManager);
    
    /**
     * Sets the Clock that will be used by the player.
     * 
     * @param clock The Clock
     * @return This builder
     */
    public Builder setClock(Clock clock);
    
    /**
     * Sets whether to use the lazy preparation.
     * 
     * @param useLazyPreparation Whether to use lazy preparation
     * @return This builder
     */
    public Builder setUseLazyPreparation(boolean useLazyPreparation);
    
    /**
     * Sets the Looper that will be used for playback.
     * 
     * @param playbackLooper The playback Looper
     * @return This builder
     */
    public Builder setPlaybackLooper(Looper playbackLooper);
    
    /**
     * Sets the player name for identification in PlayerId.
     * 
     * @param playerName The player name
     * @return This builder
     */
    public Builder setName(String playerName);
    
    /**
     * Sets the foreground mode timeout (experimental).
     * 
     * @param timeoutMs The timeout in milliseconds
     * @return This builder
     */
    public Builder experimentalSetForegroundModeTimeoutMs(long timeoutMs);
    
    /**
     * Enables dynamic scheduling (experimental).
     * 
     * @param dynamicSchedulingEnabled Whether to enable dynamic scheduling
     * @return This builder
     */
    public Builder experimentalSetDynamicSchedulingEnabled(boolean dynamicSchedulingEnabled);
    
    /**
     * Sets the MediaSourceFactory to be used by the player.
     * 
     * @param mediaSourceFactory The MediaSourceFactory
     * @return This builder
     */
    public Builder setMediaSourceFactory(MediaSource.Factory mediaSourceFactory);
    
    /**
     * Builds an ExoPlayer instance.
     * 
     * @return The built ExoPlayer instance
     */
    public ExoPlayer build();
}

// Create with default components
ExoPlayer player = new ExoPlayer.Builder(context).build();

// Create with custom track selector
DefaultTrackSelector trackSelector = new DefaultTrackSelector.Builder(context).build();
ExoPlayer player = new ExoPlayer.Builder(context)
    .setTrackSelector(trackSelector)
    .build();

// Create with custom renderers factory
DefaultRenderersFactory renderersFactory = new DefaultRenderersFactory(context);
ExoPlayer player = new ExoPlayer.Builder(context)
    .setRenderersFactory(renderersFactory)
    .build();

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

// Set multiple media items
List<MediaItem> mediaItems = Arrays.asList(
    MediaItem.fromUri("https://example.com/video1.mp4"),
    MediaItem.fromUri("https://example.com/video2.mp4")
);
player.setMediaItems(mediaItems);

// Add media items dynamically
player.addMediaItem(MediaItem.fromUri("https://example.com/video3.mp4"));
player.addMediaItem(1, MediaItem.fromUri("https://example.com/video_insert.mp4"));

// Prepare and play
player.prepare();
player.setPlayWhenReady(true);

// Get renderer information
int rendererCount = player.getRendererCount();
for (int i = 0; i < rendererCount; i++) {
    @C.TrackType int trackType = player.getRendererType(i);
    Renderer renderer = player.getRenderer(i);
    
    switch (trackType) {
        case C.TRACK_TYPE_AUDIO:
            // Handle audio renderer
            break;
        case C.TRACK_TYPE_VIDEO:
            // Handle video renderer
            break;
        case C.TRACK_TYPE_TEXT:
            // Handle text renderer
            break;
        case C.TRACK_TYPE_METADATA:
            // Handle metadata renderer
            break;
    }
}

// Send message to a renderer
PlayerMessage message = player.createMessage(player.getRenderer(0))
    .setType(MediaCodecRenderer.MSG_SET_VIDEO_DECODER_OUTPUT_BUFFER_RENDERER)
    .setPayload(outputBufferRenderer)
    .send();

// Cancel message if needed
message.cancel();

// Set audio session ID for integration with audio effects
player.setAudioSessionId(audioSessionId);

// Get current audio session ID
int currentSessionId = player.getAudioSessionId();

// Set video effects
List<Effect> videoEffects = Arrays.asList(/* your effects */);
player.setVideoEffects(videoEffects);

// Set video scaling mode
player.setVideoScalingMode(C.VIDEO_SCALING_MODE_SCALE_TO_FIT);

// Set frame rate change strategy
player.setVideoChangeFrameRateStrategy(C.VIDEO_CHANGE_FRAME_RATE_STRATEGY_ONLY_IF_SEAMLESS);

// Set seek parameters for different seeking behaviors
player.setSeekParameters(SeekParameters.EXACT);           // Exact seeking
player.setSeekParameters(SeekParameters.CLOSEST_SYNC);     // Seek to closest sync point
player.setSeekParameters(SeekParameters.PREVIOUS_SYNC);    // Seek to previous sync point
player.setSeekParameters(SeekParameters.NEXT_SYNC);        // Seek to next sync point

// Custom seek parameters
SeekParameters customSeek = new SeekParameters(1000000, 2000000); // 1s before, 2s after tolerance
player.setSeekParameters(customSeek);

// Check player state
@Player.State int playbackState = player.getPlaybackState();
boolean isPlaying = player.isPlaying();
boolean playWhenReady = player.getPlayWhenReady();

// Control playback
player.setPlayWhenReady(true);  // Start/resume playback
player.setPlayWhenReady(false); // Pause playback
player.stop();                  // Stop playback
player.seekTo(30000);           // Seek to 30 seconds
player.seekToDefaultPosition(); // Seek to default position

// Get playback position
long currentPosition = player.getCurrentPosition();
long duration = player.getDuration();
long bufferedPosition = player.getBufferedPosition();

// Always release the player when done
player.release();

// Check if player is released
boolean isReleased = player.isReleased();