tessl/maven-androidx-media3--media3-exoplayer

ExoPlayer module that provides the core ExoPlayer implementation for local media playback on Android, supporting various media formats and streaming protocols

—

Pending

Overview

Eval results

Files

Media Sources

Name: tessl/maven-androidx-media3--media3-exoplayer
Author: tessl

MediaSources define and provide media content to ExoPlayer. They handle loading, parsing, and providing media data to the player. The library includes implementations for various media types including progressive files, DASH, HLS, SmoothStreaming, and more.

MediaSource Interface

The base interface for all media sources that provide media content to ExoPlayer.

public interface MediaSource {
    /**
     * Factory for creating MediaSource instances from MediaItem objects.
     */
    interface Factory {
        /**
         * Creates a MediaSource for the given MediaItem.
         * 
         * @param mediaItem The MediaItem to create a source for
         * @return The created MediaSource
         */
        MediaSource createMediaSource(MediaItem mediaItem);
        
        /**
         * Returns the content types supported by media sources created by this factory.
         * 
         * @return An array of supported content types
         */
        @C.ContentType int[] getSupportedTypes();
        
        /**
         * Sets the SubtitleParserFactory for parsing subtitles.
         * 
         * @param subtitleParserFactory The SubtitleParser.Factory
         * @return This factory
         */
        MediaSource.Factory setSubtitleParserFactory(SubtitleParser.Factory subtitleParserFactory);
        
        /**
         * Sets the video codecs to parse within GOP sample dependencies (experimental).
         * 
         * @param codecsToParseWithinGopSampleDependencies The codec flags
         * @return This factory
         */
        MediaSource.Factory experimentalSetCodecsToParseWithinGopSampleDependencies(@C.VideoCodecFlags int codecsToParseWithinGopSampleDependencies);
        
        /**
         * Sets the CMCD configuration factory.
         * 
         * @param cmcdConfigurationFactory The CmcdConfiguration.Factory
         * @return This factory
         */
        MediaSource.Factory setCmcdConfigurationFactory(CmcdConfiguration.Factory cmcdConfigurationFactory);
    }
    
    /**
     * Prepares the source with the specified caller.
     * 
     * @param caller The MediaSourceCaller
     * @param mediaTransferListener The transfer listener
     * @param playerId The player ID
     */
    void prepareSource(MediaSourceCaller caller, @Nullable TransferListener mediaTransferListener, PlayerId playerId);
    
    /**
     * Creates a MediaPeriod for the specified period.
     * 
     * @param id The MediaPeriodId
     * @param allocator The Allocator for loading data
     * @param startPositionUs The start position in microseconds
     * @return The created MediaPeriod
     */
    MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs);
    
    /**
     * Releases a MediaPeriod.
     * 
     * @param mediaPeriod The MediaPeriod to release
     */
    void releasePeriod(MediaPeriod mediaPeriod);
    
    /**
     * Returns whether the MediaItem can be updated.
     * 
     * @param mediaItem The new MediaItem
     * @return Whether the update is supported
     */
    boolean canUpdateMediaItem(MediaItem mediaItem);
    
    /**
     * Updates the MediaItem.
     * 
     * @param mediaItem The new MediaItem
     * @return The updated MediaSource
     */
    MediaSource updateMediaItem(MediaItem mediaItem);
}

DefaultMediaSourceFactory

The default factory for creating MediaSources from MediaItems, supporting multiple formats.

public final class DefaultMediaSourceFactory implements MediaSource.Factory {
    /**
     * Creates a DefaultMediaSourceFactory.
     * 
     * @param context The context
     */
    public DefaultMediaSourceFactory(Context context);
    
    /**
     * Creates a DefaultMediaSourceFactory with custom DataSource.Factory.
     * 
     * @param dataSourceFactory The DataSource.Factory
     */
    public DefaultMediaSourceFactory(DataSource.Factory dataSourceFactory);
    
    /**
     * Sets the DrmSessionManagerProvider.
     * 
     * @param drmSessionManagerProvider The DrmSessionManagerProvider
     * @return This factory
     */
    public DefaultMediaSourceFactory setDrmSessionManagerProvider(DrmSessionManagerProvider drmSessionManagerProvider);
    
    /**
     * Sets the LoadErrorHandlingPolicy.
     * 
     * @param loadErrorHandlingPolicy The LoadErrorHandlingPolicy
     * @return This factory
     */
    public DefaultMediaSourceFactory setLoadErrorHandlingPolicy(LoadErrorHandlingPolicy loadErrorHandlingPolicy);
    
    /**
     * Sets live target offset for live streams.
     * 
     * @param liveTargetOffsetMs The target offset in milliseconds
     * @return This factory
     */
    public DefaultMediaSourceFactory setLiveTargetOffsetMs(long liveTargetOffsetMs);
    
    @Override
    public MediaSource createMediaSource(MediaItem mediaItem);
    
    @Override
    @C.ContentType public int[] getSupportedTypes();
}

Progressive Media Sources

For playing progressive media files (MP4, WebM, MP3, etc.).

public final class ProgressiveMediaSource extends BaseMediaSource {
    public static final class Factory implements MediaSource.Factory {
        /**
         * Creates a factory for ProgressiveMediaSource.
         * 
         * @param dataSourceFactory The DataSource.Factory
         * @param extractorsFactory The ExtractorsFactory
         */
        public Factory(DataSource.Factory dataSourceFactory, ExtractorsFactory extractorsFactory);
        
        /**
         * Creates a factory with default extractors.
         * 
         * @param dataSourceFactory The DataSource.Factory
         */
        public Factory(DataSource.Factory dataSourceFactory);
        
        /**
         * Sets custom loading check interval.
         * 
         * @param continueLoadingCheckIntervalBytes The interval in bytes
         * @return This factory
         */
        public Factory setContinueLoadingCheckIntervalBytes(int continueLoadingCheckIntervalBytes);
        
        @Override
        public MediaSource createMediaSource(MediaItem mediaItem);
        
        @Override
        @C.ContentType public int[] getSupportedTypes();
    }
}

DASH Media Sources

For playing DASH (Dynamic Adaptive Streaming over HTTP) content.

public final class DashMediaSource extends BaseMediaSource {
    public static final class Factory implements MediaSource.Factory {
        /**
         * Creates a factory for DashMediaSource.
         * 
         * @param dataSourceFactory The DataSource.Factory
         */
        public Factory(DataSource.Factory dataSourceFactory);
        
        /**
         * Creates a factory with custom chunk source factory.
         * 
         * @param chunkSourceFactory The DashChunkSource.Factory
         * @param dataSourceFactory The DataSource.Factory for manifest loading
         */
        public Factory(DashChunkSource.Factory chunkSourceFactory, DataSource.Factory dataSourceFactory);
        
        /**
         * Sets the manifest parser.
         * 
         * @param manifestParser The DashManifestParser
         * @return This factory
         */
        public Factory setManifestParser(ParsingLoadable.Parser<DashManifest> manifestParser);
        
        /**
         * Sets the compositor factory for effects.
         * 
         * @param compositorFactory The compositor factory
         * @return This factory
         */
        public Factory setCompositorFactory(Compositor.Factory compositorFactory);
        
        @Override
        public MediaSource createMediaSource(MediaItem mediaItem);
        
        @Override
        @C.ContentType public int[] getSupportedTypes();
    }
}

HLS Media Sources

For playing HTTP Live Streaming (HLS) content.

public final class HlsMediaSource extends BaseMediaSource {
    public static final class Factory implements MediaSource.Factory {
        /**
         * Creates a factory for HlsMediaSource.
         * 
         * @param dataSourceFactory The DataSource.Factory
         */
        public Factory(DataSource.Factory dataSourceFactory);
        
        /**
         * Sets the HlsExtractorFactory.
         * 
         * @param hlsExtractorFactory The HlsExtractorFactory
         * @return This factory
         */
        public Factory setExtractorFactory(HlsExtractorFactory hlsExtractorFactory);
        
        /**
         * Sets the playlist tracker factory.
         * 
         * @param playlistTrackerFactory The HlsPlaylistTracker.Factory
         * @return This factory
         */
        public Factory setPlaylistTrackerFactory(HlsPlaylistTracker.Factory playlistTrackerFactory);
        
        /**
         * Sets whether chunkless preparation is allowed.
         * 
         * @param allowChunklessPreparation Whether to allow chunkless preparation
         * @return This factory
         */
        public Factory setAllowChunklessPreparation(boolean allowChunklessPreparation);
        
        @Override
        public MediaSource createMediaSource(MediaItem mediaItem);
        
        @Override
        @C.ContentType public int[] getSupportedTypes();
    }
}

Concatenating Media Sources

For creating playlists by concatenating multiple media sources.

public final class ConcatenatingMediaSource extends CompositeMediaSource<MediaSource> {
    /**
     * Creates an empty ConcatenatingMediaSource.
     */
    public ConcatenatingMediaSource();
    
    /**
     * Creates a ConcatenatingMediaSource with the specified media sources.
     * 
     * @param mediaSources The media sources to concatenate
     */
    public ConcatenatingMediaSource(MediaSource... mediaSources);
    
    /**
     * Creates a ConcatenatingMediaSource with shuffle order support.
     * 
     * @param isAtomic Whether the source is atomic
     * @param shuffleOrder The shuffle order
     * @param mediaSources The media sources
     */
    public ConcatenatingMediaSource(boolean isAtomic, ShuffleOrder shuffleOrder, MediaSource... mediaSources);
    
    /**
     * Adds a media source to the end of the playlist.
     * 
     * @param mediaSource The media source to add
     */
    public void addMediaSource(MediaSource mediaSource);
    
    /**
     * Adds a media source at the specified index.
     * 
     * @param index The index to insert at
     * @param mediaSource The media source to add
     */
    public void addMediaSource(int index, MediaSource mediaSource);
    
    /**
     * Adds multiple media sources.
     * 
     * @param mediaSources The media sources to add
     */
    public void addMediaSources(Collection<MediaSource> mediaSources);
    
    /**
     * Removes a media source at the specified index.
     * 
     * @param index The index to remove
     */
    public void removeMediaSource(int index);
    
    /**
     * Removes media sources in the specified range.
     * 
     * @param fromIndex The start index (inclusive)
     * @param toIndex The end index (exclusive)
     */
    public void removeMediaSourceRange(int fromIndex, int toIndex);
    
    /**
     * Moves a media source from one index to another.
     * 
     * @param currentIndex The current index
     * @param newIndex The new index
     */
    public void moveMediaSource(int currentIndex, int newIndex);
    
    /**
     * Gets the size of the playlist.
     * 
     * @return The number of media sources
     */
    public int getSize();
}

Clipping Media Sources

For playing only a portion of a media source.

public final class ClippingMediaSource extends WrappingMediaSource {
    /**
     * Creates a ClippingMediaSource that clips from the start.
     * 
     * @param mediaSource The media source to clip
     * @param startPositionUs The start position in microseconds
     */
    public ClippingMediaSource(MediaSource mediaSource, long startPositionUs);
    
    /**
     * Creates a ClippingMediaSource with start and end positions.
     * 
     * @param mediaSource The media source to clip
     * @param startPositionUs The start position in microseconds
     * @param endPositionUs The end position in microseconds
     */
    public ClippingMediaSource(MediaSource mediaSource, long startPositionUs, long endPositionUs);
    
    /**
     * Creates a ClippingMediaSource with full configuration.
     * 
     * @param mediaSource The media source to clip
     * @param startPositionUs The start position in microseconds
     * @param endPositionUs The end position in microseconds
     * @param enableInitialDiscontinuity Whether to enable initial discontinuity
     * @param allowDynamicClippingUpdates Whether to allow dynamic updates
     * @param relativeToDefaultPosition Whether positions are relative to default position
     */
    public ClippingMediaSource(MediaSource mediaSource, long startPositionUs, long endPositionUs, 
                              boolean enableInitialDiscontinuity, boolean allowDynamicClippingUpdates, 
                              boolean relativeToDefaultPosition);
}

Usage Examples

Basic Media Source Creation

// Create from URI
MediaItem mediaItem = MediaItem.fromUri("https://example.com/video.mp4");
DefaultMediaSourceFactory factory = new DefaultMediaSourceFactory(context);
MediaSource mediaSource = factory.createMediaSource(mediaItem);

// Set to player
player.setMediaSource(mediaSource);
player.prepare();

Creating Specific Media Sources

// Progressive media source
DataSource.Factory dataSourceFactory = new DefaultDataSource.Factory(context);
ProgressiveMediaSource progressiveSource = new ProgressiveMediaSource.Factory(dataSourceFactory)
    .createMediaSource(MediaItem.fromUri("https://example.com/video.mp4"));

// DASH media source  
DashMediaSource dashSource = new DashMediaSource.Factory(dataSourceFactory)
    .createMediaSource(MediaItem.fromUri("https://example.com/manifest.mpd"));

// HLS media source
HlsMediaSource hlsSource = new HlsMediaSource.Factory(dataSourceFactory)
    .createMediaSource(MediaItem.fromUri("https://example.com/playlist.m3u8"));

Playlist Creation

// Create concatenating source for playlist
ConcatenatingMediaSource concatenatingSource = new ConcatenatingMediaSource();

// Add multiple sources
concatenatingSource.addMediaSource(progressiveSource);
concatenatingSource.addMediaSource(dashSource);
concatenatingSource.addMediaSource(hlsSource);

// Play playlist
player.setMediaSource(concatenatingSource);

Clipping Media

// Play only 30-60 seconds of a video
long startUs = 30 * C.MICROS_PER_SECOND;
long endUs = 60 * C.MICROS_PER_SECOND;

ClippingMediaSource clippingSource = new ClippingMediaSource(
    progressiveSource, 
    startUs, 
    endUs
);

player.setMediaSource(clippingSource);

Dynamic Playlist Management

ConcatenatingMediaSource playlist = new ConcatenatingMediaSource();
player.setMediaSource(playlist);
player.prepare();

// Add items dynamically during playback
playlist.addMediaSource(factory.createMediaSource(MediaItem.fromUri("uri1")));
playlist.addMediaSource(factory.createMediaSource(MediaItem.fromUri("uri2")));

// Remove items
playlist.removeMediaSource(0);

// Move items
playlist.moveMediaSource(0, 2);

Install with Tessl CLI

npx tessl i tessl/maven-androidx-media3--media3-exoplayer

docs