How to Implement ExoPlayer in Android?

ExoPlayer is an open-source media player library developed by Google for Android applications. Unlike Android’s native MediaPlayer, ExoPlayer offers more customization and supports features like adaptive streaming, DASH, and smooth streaming. It provides a flexible framework for playing audio and video from various sources with high performance and reliability.

How to Implement ExoPlayer in Android?

Implementing ExoPlayer in Android involves several steps, from setting up dependencies to creating and configuring the player. Here, we will guide you through these steps with a detailed example.

Setting Up Dependencies for ExoPlayer

The first step to answering the question of “How to implement ExoPlayer in Android” is by beginning to add a dependency. Here’s how that goes. 

A. Adding the Dependency

To integrate ExoPlayer into your Android project, you need to add the appropriate dependency to your build.gradle file. This can be done as follows:

1. Open your project’s build.gradle file.
2. Add the ExoPlayer dependency:

implementation 'com.google.android.exoplayer:exoplayer:2.X.X'

For additional functionalities, such as DASH (Dynamic Adaptive Streaming over HTTP) support, you can include specific modules:

implementation 'com.google.android.exoplayer:exoplayer-dash:2.X.X'

By doing so, you ensure that your project includes all the necessary components for handling various media types and streaming protocols. Next, you need to check out the permissions and make some changes there. 

Permissions

For streaming media content, you must declare the internet permission in your AndroidManifest.xml file:

<uses-permission android:name="android.permission.INTERNET"/>

This permission is crucial for accessing media files from the web. Once that is done, the next step in the ExoPlayer Android tutorial is to build out the user interface. 

B. Building the User Interface

To display media content using ExoPlayer, you will use PlayerView (formerly known as SimpleExoPlayerView). This view is essential for rendering the video or audio output on the screen. Add the PlayerView to your layout XML file as shown below:

<com.google.android.exoplayer2.ui.PlayerView
    android:id="@+id/player_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

This XML snippet defines a PlayerView that will occupy the entire screen.

C. Creating and Configuring the ExoPlayer

When it comes to working with ExoPlayer, there are some absolute basics that you must know about in order to get started. Let’s go through some such basics in ExoPlayer first. 

1. Creating an ExoPlayer Instance

To create an instance of ExoPlayer, use the ExoPlayer.Builder class. This builder pattern allows for easy customization and configuration of the player:

ExoPlayer player = new ExoPlayer.Builder(context).build();

This code initializes a new ExoPlayer instance that you can use to control media playback.

2. Setting Up MediaSource

ExoPlayer can play media from various sources. To set up a media source, create a MediaItem object from a media URL:

MediaItem mediaItem = MediaItem.fromUri("https://path/to/media.mp4");

You can also use local files or playlists as media sources, providing flexibility in how you deliver content to your users.

3. Preparing the Player

Before playback can begin, you need to prepare the player with the media item:

player.setMediaItem(mediaItem);
player.prepare();

This code snippet sets the media item and prepares the player for playback.

D. Controlling Playback

ExoPlayer offers a range of methods to control playback, such as playing, pausing, and seeking specific positions. Here are some examples:

player.play(); // Start or resume playback
player.pause(); // Pause playback
player.seekTo(positionMs); // Seek to a specific position in milliseconds

E. Handling Player Events

To handle playback events, implement the Player.EventListener interface. This allows you to respond to changes in playback state, buffering, and other events:

player.addListener(new Player.Listener() {
    @Override
    public void onPlaybackStateChanged(int state) {
        if (state == Player.STATE_BUFFERING) {
            // Handle buffering state
        }
    }
});

This listener setup helps manage the player’s state and provides a better user experience by handling events like buffering or playback completion.

For a complete implementation, you can refer to the ExoPlayer GitHub repository, which contains various examples and documentation.

By following these steps, you can successfully implement ExoPlayer in your Android application, providing a robust and flexible media playback solution for your users.

Advanced Player Options for ExoPlayer

Now, let’s look at some advanced player options that you can implement for your ExoPlayer: 

Change Video Quality in ExoPlayer

ExoPlayer supports adaptive bitrate streaming, which adjusts video quality automatically based on network conditions. To manually change the video quality, you can implement a TrackSelector. This allows users to select different quality levels manually. Here's an example of how to set up a TrackSelector:

DefaultTrackSelector trackSelector = new DefaultTrackSelector(context);
trackSelector.setParameters(
    trackSelector.buildUponParameters().setMaxVideoSize(1280, 720) // Set the max video size to 720p
);
ExoPlayer player = new ExoPlayer.Builder(context)
    .setTrackSelector(trackSelector)
    .build();

This setup restricts the video quality to a maximum resolution of 720p, but you can adjust it as per your requirements.

Changing Aspect Ratio in ExoPlayer

You can change the aspect ratio of the video being played by setting the resize mode of PlayerView. ExoPlayer's PlayerView provides several resize modes, such as RESIZE_MODE_FIT, RESIZE_MODE_FILL, and RESIZE_MODE_ZOOM. Here’s how to set it up:

playerView.setResizeMode(AspectRatioFrameLayout.RESIZE_MODE_FIT);

This code sets the PlayerView to fit the video within the view bounds while maintaining the aspect ratio.

Play Video/Audio from URL in ExoPlayer

Playing media from a URL is straightforward with ExoPlayer. You need to create a MediaItem from the URL and set it to the player. Here's an example:

MediaItem mediaItem = MediaItem.fromUri("https://path/to/media.mp4");
player.setMediaItem(mediaItem);
player.prepare();
player.play();

This code snippet demonstrates how to load and play a media file from a specified URL.

Fast-Forward Video in ExoPlayer

To fast-forward a video in ExoPlayer, you can use the seekTo method to jump to a future position in the video. Here’s an example:

long currentPosition = player.getCurrentPosition();
player.seekTo(currentPosition + 10000); // Fast-forward 10 seconds

This code moves the playback position 10 seconds forward from the current position.

Adaptive Bitrate Streaming in ExoPlayer

ExoPlayer’s adaptive bitrate streaming ensures smooth playback by adjusting the bitrate according to the network speed. This feature is built-in and automatically managed by ExoPlayer when playing adaptive streams like DASH, HLS, or SmoothStreaming. To enable adaptive streaming, you typically use a DefaultTrackSelector and a MediaSource that supports adaptive bitrate:

DefaultTrackSelector trackSelector = new DefaultTrackSelector(context);
ExoPlayer player = new ExoPlayer.Builder(context)
    .setTrackSelector(trackSelector)
    .build();
MediaItem mediaItem = MediaItem.fromUri("https://path/to/adaptive_stream.mpd");
player.setMediaItem(mediaItem);
player.prepare();
player.play();

This setup allows ExoPlayer to automatically adjust the video quality based on the current network conditions, providing the best possible playback experience.

By utilizing these advanced options, you can enhance the functionality and user experience of ExoPlayer in your Android application.

Gumlet’s Video Analytics Support for ExoPlayer

Gumlet provides comprehensive video analytics support for ExoPlayer, allowing you to collect detailed video insights using the Gumlet platform. Integrating Gumlet’s video analytics with ExoPlayer in your Android native application is straightforward and involves a few essential steps. Here’s how you can get started:

Getting Started

To begin with, Gumlet insights integration for ExoPlayer, follow the steps outlined below.

Step 1: Add Gumlet Insights SDK Dependency

First, you need to add the Gumlet Insights SDK dependency to your project. Open your main project (app) build.gradle file and add the following line to the dependencies section:

dependencies {
    implementation 'com.gumlet.gumlet-insights-sdk-exoplayer:collector-exoplayer:1.0.3'
}

This dependency includes the necessary components to collect video insights for ExoPlayer.

Step 2: Initialize the Gumlet SDK

After adding the dependency, you need to initialize the Gumlet SDK in your application. Follow these steps to set up the SDK and ExoPlayer:

1. Add Imports for Gumlet Insights Library

import com.gumlet.insights.GumletInsightsConfig;
import com.gumlet.insights.exoplayer.ExoPlayerCollector;

2. Initialize the ExoPlayerCreate and configure an instance of ExoPlayer. For example:

SimpleExoPlayer.Builder exoBuilder = new SimpleExoPlayer.Builder(this);
exoBuilder.setBandwidthMeter(bandwidthMeter);
player = exoBuilder.build();
player.addListener(this);

3. Create Gumlet Insights Config ObjectCreate a GumletInsightsConfig object with your property ID:

GumletInsightsConfig gumletInsightsConfig = new GumletInsightsConfig("<PROPERTY-ID>", this);

4. Create Gumlet Insights Collector ObjectInitialize the Gumlet Insights Collector with the configuration object and your activity context:

ExoPlayerCollector gumletAnalytics = new ExoPlayerCollector(gumletInsightsConfig, MainActivity.this);

5. Attach ExoPlayer to Gumlet Insights Collector ObjectAttach your ExoPlayer instance to the Gumlet Insights Collector:

gumletAnalytics.attachPlayer(player);

6. Attach Media to the Player and Start PlaybackFinally, attach the media item to the player and start playback. Here is an example of setting up media and initiating playback:

MediaItem mediaItem = MediaItem.fromUri("https://path/to/media.mp4");
player.setMediaItem(mediaItem);
player.prepare();
player.play();

Comprehensive Example

Combining all the steps, here’s a complete example of integrating Gumlet’s video analytics with ExoPlayer in your Android application:

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.SimpleExoPlayer;
import com.google.android.exoplayer2.ui.PlayerView;
import com.google.android.exoplayer2.source.MediaItem;
import com.gumlet.insights.GumletInsightsConfig;
import com.gumlet.insights.exoplayer.ExoPlayerCollector;
public class MainActivity extends AppCompatActivity {
    private ExoPlayer player;
    private ExoPlayerCollector gumletAnalytics;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        PlayerView playerView = findViewById(R.id.player_view);
        // Initialize the ExoPlayer
        SimpleExoPlayer.Builder exoBuilder = new SimpleExoPlayer.Builder(this);
        player = exoBuilder.build();
        playerView.setPlayer(player);
        // Create Gumlet Insights config object
        GumletInsightsConfig gumletInsightsConfig = new GumletInsightsConfig("<PROPERTY-ID>", this);
        // Create Gumlet Insights Collector object
        gumletAnalytics = new ExoPlayerCollector(gumletInsightsConfig, MainActivity.this);
        // Attach ExoPlayer to Gumlet Insights Collector object
        gumletAnalytics.attachPlayer(player);
        // Attach the media to the player and start playback
        MediaItem mediaItem = MediaItem.fromUri("https://path/to/media.mp4");
        player.setMediaItem(mediaItem);
        player.prepare();
        player.play();
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (player != null) {
            player.release();
        }
        if (gumletAnalytics != null) {
            gumletAnalytics.detachPlayer();
        }
    }
}

By following these steps, you can successfully integrate Gumlet's video analytics into your ExoPlayer-based Android application, enabling comprehensive insights into video playback and user engagement. For more detailed instructions, refer to the Gumlet Video Analytics for ExoPlayer documentation.

How to Play DRM-Protected Content in ExoPlayer?

ExoPlayer supports the playback of DRM-protected content through the use of classes like DefaultDrmSessionManager and ExoMediaDrm. These classes handle the complexities of digital rights management (DRM) by providing mechanisms to enforce content protection policies and ensure secure media playback. Here’s a basic example of how to implement DRM-protected content playback in ExoPlayer.

To start, you need to configure a DefaultDrmSessionManager with the appropriate DRM scheme (e.g., Widevine) and license URL. Here’s an example setup:

DefaultDrmSessionManager drmSessionManager;
String licenseUrl = "https://your.license.server.com";
DrmSessionManagerProvider drmSessionManagerProvider = new DefaultDrmSessionManagerProvider();
DefaultDrmSessionManagerProvider drmSessionManagerProvider = new DefaultDrmSessionManagerProvider();
drmSessionManagerProvider.setDrmHttpDataSourceFactory(new DefaultHttpDataSource.Factory());
drmSessionManagerProvider.setDrmLicenseUrl(licenseUrl);
MediaItem mediaItem = new MediaItem.Builder()
        .setUri("https://path/to/drm-protected/content.mpd")
        .setDrmUuid(C.WIDEVINE_UUID)
        .setDrmLicenseUri(licenseUrl)
        .build();
ExoPlayer player = new ExoPlayer.Builder(context)
        .setDrmSessionManagerProvider(drmSessionManagerProvider)
        .build();
player.setMediaItem(mediaItem);
player.prepare();
player.play();

In this example, the DefaultDrmSessionManagerProvider is configured with the DRM license URL and an appropriate data source factory. The MediaItem is then created with the DRM UUID (Widevine in this case) and the DRM license URL. Finally, the ExoPlayer instance is built with the DRM session manager provider, and the media item is set up for playback.

It is important to keep in mind that ExoPlayer is compatible with various DRM systems, ensuring secure and reliable playback across different platforms. Here’s a quick overview of the supported DRM systems:

DRM System	Compatibility
Widevine	Supported
PlayReady	Supported
ClearKey	Supported

This compatibility allows developers to implement a wide range of DRM-protected content, ensuring that their media assets are secure and compliant with industry standards. By following these steps, you can effectively integrate DRM support into your ExoPlayer setup, enabling the secure playback of protected content in your Android application.

Concluding Remarks

Implementing ExoPlayer in Android enhances media playback capabilities with advanced features and customization options. Following the steps outlined in this tutorial will help you integrate ExoPlayer seamlessly into your Android applications.

FAQs

1. VLC vs ExoPlayer: Which is better for Android?

VLC offers a more versatile media player with support for a wide range of formats, while ExoPlayer provides better integration and customization options for Android applications.

2. Why does my ExoPlayer keep buffering?

Buffering issues in ExoPlayer can be caused by network problems or inadequate buffer settings. Adjusting buffer configurations can help mitigate this issue.

3. What is the buffer size in ExoPlayer?

ExoPlayer allows customization of buffer size through DefaultLoadControl, enabling developers to set specific buffer durations.

4. What is the difference between ExoPlayer and VideoView?

ExoPlayer offers more advanced features and better performance than VideoView, which is simpler but less flexible.

5. What is the difference between ExoPlayer and MediaPlayer?

ExoPlayer provides more functionality and customization options compared to MediaPlayer, which is more basic and easier to implement for simple use cases.