What is HLS and Why Use It on Android?

Understanding HLS Technology

1. Breaking videos into small segments (typically 2-10 seconds each)
2. Creating multiple versions of these segments at different quality levels
3. Using standard HTTP to deliver the content
4. Dynamically switching between quality levels based on available bandwidth

Benefits of HLS on Android Devices

• Adaptive Quality: Automatically adjusts video quality based on network conditions, preventing buffering while maximizing quality
• Wide Compatibility: Works across virtually all Android versions and device types
• Efficient Bandwidth Usage: Only uses the bandwidth needed for the current network conditions
• Better Battery Life: Less processing power is required for smooth playback
• Reliable Delivery: Standard HTTP delivery means better compatibility with firewalls, proxies, and CDNs
• Built-in Support: Recent Android versions have native support for HLS playback

HLS Workflow Explained

1. Content Preparation: Your source video (typically MP4 or MOV) is encoded into multiple renditions at different bitrates and resolutions.
2. Segmentation: Each rendition is divided into small chunks (usually .ts files).
3. Playlist Creation:
   • A media playlist (.m3u8 file) is created for each quality level, listing its segments
   • A master playlist (.m3u8) lists all available quality levels
4. Delivery: The segments and playlists are hosted on a standard HTTP server.
5. Playback: The HLS player on the Android device:
   • Requests the master playlist
   • Selects the appropriate quality level based on current conditions
   • Downloads segments sequentially for playback
   • Continuously monitors network conditions to switch quality levels as needed

Native Android HLS Playback Options

ExoPlayer: Google's Recommended Media Player

• Native support for HLS adaptive streaming
• Smooth quality transitions without interrupting playback
• Support for live streams and video-on-demand (VOD)
• Customizable buffering behavior
• Advanced features like DRM, subtitles, and multiple audio tracks
• Consistent API across different Android versions
• Regular updates and active maintenance by Google

1// Step 1: Add ExoPlayer dependency to your build.gradle
2// implementation 'com.google.android.exoplayer:exoplayer:2.X.X'
3
4// Step 2: Create a player instance and connect it to your view
5public class PlayerActivity extends AppCompatActivity {
6
7    private SimpleExoPlayer player;
8    private PlayerView playerView;
9
10    @Override
11    protected void onCreate(Bundle savedInstanceState) {
12        super.onCreate(savedInstanceState);
13        setContentView(R.layout.activity_player);
14
15        playerView = findViewById(R.id.player_view);
16
17        // Initialize the player
18        player = new SimpleExoPlayer.Builder(this).build();
19
20        // Attach player to the view
21        playerView.setPlayer(player);
22
23        // Build the media source for HLS
24        String hlsUrl = "https://example.com/playlist.m3u8";
25        MediaSource mediaSource = new HlsMediaSource.Factory(
26                new DefaultHttpDataSourceFactory("user-agent"))
27                .createMediaSource(Uri.parse(hlsUrl));
28
29        // Prepare the player with the source
30        player.setMediaSource(mediaSource);
31        player.prepare();
32
33        // Start playback when ready
34        player.setPlayWhenReady(true);
35    }
36
37    @Override
38    protected void onPause() {
39        super.onPause();
40        if (player != null) {
41            player.setPlayWhenReady(false);
42        }
43    }
44
45    @Override
46    protected void onDestroy() {
47        super.onDestroy();
48        if (player != null) {
49            player.release();
50            player = null;
51        }
52    }
53}
54

1// Using Media3 (the newer version of ExoPlayer)
2// Add dependencies:
3// implementation 'androidx.media3:media3-exoplayer:1.X.X'
4// implementation 'androidx.media3:media3-exoplayer-hls:1.X.X'
5// implementation 'androidx.media3:media3-ui:1.X.X'
6
7class PlayerActivity : AppCompatActivity() {
8
9    private var player: ExoPlayer? = null
10
11    override fun onCreate(savedInstanceState: Bundle?) {
12        super.onCreate(savedInstanceState)
13        setContentView(R.layout.activity_player)
14
15        val playerView = findViewById<PlayerView>(R.id.player_view)
16
17        player = ExoPlayer.Builder(this).build()
18        playerView.player = player
19
20        val mediaItem = MediaItem.fromUri("https://example.com/playlist.m3u8")
21        player?.setMediaItem(mediaItem)
22        player?.prepare()
23        player?.playWhenReady = true
24    }
25
26    override fun onPause() {
27        super.onPause()
28        player?.playWhenReady = false
29    }
30
31    override fun onDestroy() {
32        super.onDestroy()
33        player?.release()
34        player = null
35    }
36}
37

Using MediaPlayer for Basic HLS Playback

1MediaPlayer mediaPlayer = new MediaPlayer();
2mediaPlayer.setDataSource("https://example.com/playlist.m3u8");
3mediaPlayer.setOnPreparedListener(mp -> mp.start());
4mediaPlayer.prepareAsync();
5

• Limited control over adaptive streaming behavior
• Inconsistent HLS support across Android versions
• Fewer customization options for buffering and error handling
• Lack of advanced features like DRM and subtitles
• Less reliable playback for complex streams

• For simple playback needs on newer Android devices
• When minimizing dependencies is a priority
• In apps where video playback is not a central feature

Exploring Android HLS Player Libraries

IJKPlayer: A Powerful Alternative

• Based on FFmpeg, providing extensive format support
• Hardware acceleration on supported devices
• Customizable timeouts and buffering behavior
• Support for various protocols beyond HLS
• Active community and regular updates

1// Add dependencies and import statements
2
3IjkMediaPlayer player = new IjkMediaPlayer();
4player.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "framedrop", 1);
5player.setOption(IjkMediaPlayer.OPT_CATEGORY_FORMAT, "http-detect-range-support", 0);
6player.setOption(IjkMediaPlayer.OPT_CATEGORY_CODEC, "skip_loop_filter", 48);
7
8try {
9    player.setDataSource("https://example.com/playlist.m3u8");
10    player.prepareAsync();
11    player.setOnPreparedListener(IMediaPlayer::start);
12} catch (IOException e) {
13    e.printStackTrace();
14}
15

Video.js in WebView: A Web-Based Approach

1WebView webView = findViewById(R.id.webview);
2webView.getSettings().setJavaScriptEnabled(true);
3webView.setWebChromeClient(new WebChromeClient());
4
5String html = "<!DOCTYPE html><html><head>" +
6        "<meta name='viewport' content='width=device-width, initial-scale=1.0'>" +
7        "<link href='https://vjs.zencdn.net/7.15.4/video-js.css' rel='stylesheet'>" +
8        "<script src='https://vjs.zencdn.net/7.15.4/video.min.js'></script>" +
9        "</head><body>" +
10        "<video-js id='player' class='vjs-default-skin' controls preload='auto' width='100%' height='100%'>" +
11        "<source src='https://example.com/playlist.m3u8' type='application/x-mpegURL'>" +
12        "</video-js>" +
13        "<script>" +
14        "var player = videojs('player');" +
15        "player.play();" +
16        "</script>" +
17        "</body></html>";
18
19webView.loadData(html, "text/html", "UTF-8");
20

• Consistent playback behavior across different Android versions
• Leverage web-based HLS players with mature features
• Simplify integration if your app already uses web components
• Easy implementation of custom controls via JavaScript

• Higher memory usage compared to native solutions
• Potential performance issues on lower-end devices
• Limited integration with Android's media systems
• More complex interface between JavaScript and native code

Library Comparison

1Feature          ExoPlayer       MediaPlayer     IJKPlayer       WebView + Video.js
2-----------------------------------------------------------------------------
3Native Android   Yes (Google)    Yes (Built-in)  No              No
4library
5
6HLS support      Excellent       Basic           Very good       Good
7quality
8
9Customization    Extensive       Limited         Good            Via JavaScript
10
11Performance      Excellent       Good            Very good       Moderate
12
13Memory usage     Low             Lowest          Moderate        Highest
14
15Advanced         Extensive       Limited         Moderate        Via plugins
16features (DRM, 
17subtitles)
18
19Maintenance      Active (Google) Part of Android Community       Active web library
20
21Implementation   Moderate        Low             High            Moderate
22complexity
23
24App size impact  ~2 MB           0 (built-in)    ~8 MB           Minimal
25                                                (with FFmpeg)
26

Finding Android HLS Player GitHub Options

1. Google's ExoPlayer

• Comprehensive HLS support
• Clear documentation and examples
• Regular releases
• Apache 2.0 license
• Extensive community support

2. Bilibili's IJKPlayer

• Extensive format support via FFmpeg
• Hardware acceleration
• Cross-platform (Android and iOS)
• LGPL/GPL license
• Active community

3. JWPlayer Android SDK (Commercial with GitHub Examples)

• Enterprise-grade HLS playback
• Analytics and monitoring
• Advertising integration
• Commercial license with GitHub examples
• Professional support

Evaluating GitHub Projects for Your Needs

1. Activity and maintenance: Check the frequency of commits and releases
2. Issue resolution speed: See how quickly bugs are addressed
3. Documentation quality: Look for clear setup instructions and examples
4. License compatibility: Ensure the license works with your project
5. Community size: A larger community means more resources and faster bug identification
6. Code quality: Review the code organization and architecture
7. Size and dependencies: Consider the impact on your app's size

Optimizing HLS Playback on Android

Video Streaming Optimization Guide

Adaptive Bitrate Configuration

1. Prepare multiple quality levels: Create renditions at different resolutions and bitrates.

   1# Example FFmpeg command for multiple renditions
   2ffmpeg -i input.mp4 \
   3    -vf scale=1920:1080 -c:v h264 -b:v 5000k -c:a aac -b:a 192k high.mp4 \
   4    -vf scale=1280:720 -c:v h264 -b:v 2500k -c:a aac -b:a 128k medium.mp4 \
   5    -vf scale=640:360 -c:v h264 -b:v 1000k -c:a aac -b:a 96k low.mp4
   6
2. Optimize segment length: 4-6 seconds is typically ideal (balancing quality switching speed vs. overhead)

   1# Example HLS segmentation with 4-second segments
   2ffmpeg -i input.mp4 -c:v h264 -c:a aac -f hls -hls_time 4 -hls_list_size 0 -hls_segment_filename "segment_%03d.ts" playlist.m3u8
   3
3. Configure appropriate starting quality: Set initial quality selection based on connection type

   1// ExoPlayer example: set initial bitrate constraint
   2DefaultTrackSelector trackSelector = new DefaultTrackSelector(context);
   3trackSelector.setParameters(
   4    trackSelector.buildUponParameters()
   5        .setMaxVideoBitrate(getInitialBitrateForNetwork())
   6);
   7
   8ExoPlayer player = new ExoPlayer.Builder(context)
   9    .setTrackSelector(trackSelector)
   10    .build();
   11

Buffering Strategies

1. Configure buffer sizes appropriately:

   1// ExoPlayer example: customize buffering parameters
   2LoadControl loadControl = new DefaultLoadControl.Builder()
   3    .setBufferDurationsMs(
   4        DefaultLoadControl.DEFAULT_MIN_BUFFER_MS, // Min buffer duration
   5        30000, // Max buffer duration (30 seconds)
   6        DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS,
   7        DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS)
   8    .build();
   9
   10ExoPlayer player = new ExoPlayer.Builder(context)
   11    .setLoadControl(loadControl)
   12    .build();
   13
2. Preload content when possible:

   1// Preload the next video while the current one is playing
   2player.addListener(new Player.Listener() {
   3    @Override
   4    public void onPositionDiscontinuity(Player.PositionInfo oldPosition,
   5                                      Player.PositionInfo newPosition,
   6                                      int reason) {
   7        // Near the end of current video
   8        if (player.getDuration() - player.getCurrentPosition() < 10000) {
   9            // Prepare the next item in background
   10            prepareNextVideo();
   11        }
   12    }
   13});
   14
3. Handle network transitions gracefully:

   1// Register a network callback to handle network changes
   2ConnectivityManager connectivityManager =
   3    (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
   4
   5ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
   6    @Override
   7    public void onCapabilitiesChanged(Network network,
   8                                    NetworkCapabilities capabilities) {
   9        // Adjust buffer strategy based on network capability
   10        boolean isUnmetered =
   11            capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
   12        updateBufferStrategy(isUnmetered);
   13    }
   14};
   15
   16NetworkRequest request = new NetworkRequest.Builder()
   17    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
   18    .build();
   19
   20connectivityManager.registerNetworkCallback(request, networkCallback);
   21

Error Handling and Monitoring

1. Implement comprehensive error handling:

   1player.addListener(new Player.Listener() {
   2    @Override
   3    public void onPlayerError(PlaybackException error) {
   4        // Log error for analytics
   5        logPlaybackError(error);
   6
   7        // Attempt recovery based on error type
   8        if (error.errorCode == PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED) {
   9            // Show user-friendly message
   10            showErrorMessage("Network connection lost. Retrying...");
   11
   12            // Retry playback after delay
   13            handler.postDelayed(() -> {
   14                resetPlayer();
   15                prepareAndPlay(currentMediaItem);
   16            }, 5000);
   17        } else {
   18            // Handle other error types
   19            showErrorMessage("Playback error: " + getReadableErrorMessage(error));
   20        }
   21    }
   22});
   23
2. Monitor playback quality:

   1player.addAnalyticsListener(new AnalyticsListener() {
   2    @Override
   3    public void onBandwidthEstimate(EventTime eventTime,
   4                                  int totalLoadTimeMs,
   5                                  long totalBytesLoaded,
   6                                  long bitrateEstimate) {
   7        // Log bandwidth for analytics
   8        logBandwidthSample(bitrateEstimate);
   9
   10        // Potentially adjust player settings based on bandwidth trends
   11        analyzeBandwidthHistory();
   12    }
   13
   14    @Override
   15    public void onDroppedVideoFrames(EventTime eventTime,
   16                                   int droppedFrames,
   17                                   long elapsedMs) {
   18        // Log frame drops for performance monitoring
   19        logFrameDrops(droppedFrames, elapsedMs);
   20
   21        // Consider reducing quality if frame drops are excessive
   22        if (isFrameDropRateHigh(droppedFrames, elapsedMs)) {
   23            reducePlaybackQuality();
   24        }
   25    }
   26});
   27

Performance Tuning

1. Use hardware acceleration when available:

   1// ExoPlayer selects hardware acceleration by default when available
   2// You can force software rendering if needed:
   3DefaultRenderersFactory renderersFactory = new DefaultRenderersFactory(context)
   4    .setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF);
   5
   6ExoPlayer player = new ExoPlayer.Builder(context)
   7    .setRenderersFactory(renderersFactory)
   8    .build();
   9
2. Optimize for battery life:

   1// Release player resources when not visible
   2@Override
   3protected void onPause() {
   4    super.onPause();
   5    if (Util.SDK_INT <= 23) {
   6        releasePlayer();
   7    }
   8}
   9
   10@Override
   11protected void onStop() {
   12    super.onStop();
   13    if (Util.SDK_INT > 23) {
   14        releasePlayer();
   15    }
   16}
   17
   18private void releasePlayer() {
   19    if (player != null) {
   20        player.release();
   21        player = null;
   22    }
   23}
   24
3. Consider the device's capabilities:

   1private int getMaxSupportedResolution() {
   2    // Check device capability to handle different resolutions
   3    ActivityManager activityManager =
   4        (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
   5    ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
   6    activityManager.getMemoryInfo(memoryInfo);
   7
   8    // Low-end device detection
   9    boolean isLowEndDevice =
   10        memoryInfo.totalMem < 2L * 1024L * 1024L * 1024L; // < 2GB RAM
   11
   12    if (isLowEndDevice) {
   13        return 720; // Cap at 720p for low-end devices
   14    } else {
   15        return 1080; // Allow up to 1080p for higher-end devices
   16    }
   17}
   18

Key Takeaways

• ExoPlayer is the recommended solution for most Android HLS playback needs due to its comprehensive feature set, active maintenance by Google, and excellent performance
• Consider device and network diversity when configuring adaptive bitrate settings to ensure smooth playback across the Android ecosystem
• Open-source GitHub projects provide valuable resources, with ExoPlayer and IJKPlayer being the most prominent options
• Proper error handling and buffering strategies are critical for a positive user experience
• Optimize for battery life by properly managing player resources

Conclusion