Skip to content

Most visited

Recently visited


Media Route Provider API

The Android media router framework allows manufacturers to enable playback on their devices through a standardized interface called a MediaRouteProvider. A route provider defines a common interface for playing media on a receiver device, making it possible to play media on your equipment from any Android application that supports media routes.

This guide discusses how to create a media route provider for a receiver device and make it available to other media playback applications that run on Android.


The Android media router framework enables media app developers and media playback device manufacturers to connect through a common API and common user interface. App developers that implement a MediaRouter interface can then connect to the framework and play content to devices that participate in the media router framework. Media playback device manufacturers can participate in the framework by publishing a MediaRouteProvider that allows other applications to connect to and play media on the receiver devices. Figure 1 illustrates how an app connects to a receiving device through the media router framework.

Figure 1. Overview of how media route provider classes provide communication from a media app to a receiver device.

When you build a media route provider for your receiver device, the provider serves the following purposes:

Distribution of route providers

A media route provider is distributed as part of an Android app. Your route provider can be made available to other apps by extending MediaRouteProviderService or wrapping your implementation of MediaRouteProvider with your own service and declaring an intent filter for the media route provider. These steps allow other apps to discover and make use of your media route.

Note: The app containing the media route provider can also include a MediaRouter interface to the route provider, but this is not required.

Media router library

The media router APIs are defined in the v7-mediarouter support library. You must add this library to your app development project. For more information on adding support libraries to your project, see Support Library Setup.

Caution: Be sure to use the implementation of the media router framework. Do not use the older package.

Creating a Provider Service

The media router framework must be able to discover and connect to your media route provider to allow other applications to use your route. In order to do this, the media router framework looks for apps that declare a media route provider intent action. When another app wants to connect to your provider, the framework must be able to invoke and connect to it, so your provider must be encapsulated in a Service.

The following example code shows the declaration of a media route provider service and the intent filter in a manifest, which allows it to be discovered and used by the media router framework:

<service android:name=".provider.SampleMediaRouteProviderService"
        <action android:name="" />

This manifest example declares a service that wraps the actual media route provider classes. The Android media router framework provides the MediaRouteProviderService class for use as a service wrapper for media route providers. The following example code demonstrates how to use this wrapper class:

public class SampleMediaRouteProviderService extends MediaRouteProviderService {

    public MediaRouteProvider onCreateMediaRouteProvider() {
        return new SampleMediaRouteProvider(this);

Specifying Route Capabilities

Apps connecting to the media router framework can discover your media route through your app's manifest declarations, but they also need to know the capabilities of the media routes you are providing. Media routes can be of different types and have different features, and other apps need to be able to discover these details to determine if they are compatible with your route.

The media router framework allows you to define and publish the capabilities of your media route through IntentFilter objects, MediaRouteDescriptor objects and a MediaRouteProviderDescriptor. This section explains how to use these classes to publish the details of your media route for other apps.

Route categories

As part of the programmatic description of your media route provider, you must specify whether your provider supports remote playback, secondary output, or both. These are the route categories provided by the media router framework:

In order to include these settings in a description of your media route, you insert them into an IntentFilter object, which you later add to a MediaRouteDescriptor object:

public final class SampleMediaRouteProvider extends MediaRouteProvider {
    private static final ArrayList<IntentFilter> CONTROL_FILTERS_BASIC;
    static {
        IntentFilter videoPlayback = new IntentFilter();
        CONTROL_FILTERS_BASIC = new ArrayList<IntentFilter>();

If you specify the CATEGORY_REMOTE_PLAYBACK intent, you must also define what media types and playback controls are supported by your media route provider. The next section describes how to specify these settings for your device.

Media types and protocols

A media route provider for a remote playback device must specify the media types and transfer protocols it supports. You specify these settings using the IntentFilter class and the addDataScheme() and addDataType() methods of that object. The following code snippet demonstrates how to define an intent filter for supporting remote video playback using http, https, and Real Time Streaming Protocol (RTSP):

public final class SampleMediaRouteProvider extends MediaRouteProvider {

    private static final ArrayList<IntentFilter> CONTROL_FILTERS_BASIC;

    static {
        IntentFilter videoPlayback = new IntentFilter();
        addDataTypeUnchecked(videoPlayback, "video/*");
        CONTROL_FILTERS_BASIC = new ArrayList<IntentFilter>();

    private static void addDataTypeUnchecked(IntentFilter filter, String type) {
        try {
        } catch (MalformedMimeTypeException ex) {
            throw new RuntimeException(ex);

Playback controls

A media route provider that offers remote playback must specify the types of media controls it supports. These are the general types of control that media routes can provide:

The following code example demonstrates how to construct an intent filter for supporting basic media route playback controls:

public final class SampleMediaRouteProvider extends MediaRouteProvider {
    private static final ArrayList<IntentFilter> CONTROL_FILTERS_BASIC;
    static {
        IntentFilter playControls = new IntentFilter();
        CONTROL_FILTERS_BASIC = new ArrayList<IntentFilter>();

For more information about the available playback control intents, see the MediaControlIntent class.


After defining the capabilities of your media route using IntentFilter objects, you can then create a descriptor object for publishing to the Android media router framework. This descriptor object contains the specifics of your media route's capabilities so that other applications can determine how to interact with your media route.

The following example code demonstrates how to add the previously created intent filters to a MediaRouteProviderDescriptor and set the descriptor for use by the media router framework:

public SampleMediaRouteProvider(Context context) {

private void publishRoutes() {
    Resources r = getContext().getResources();
    // Create a route descriptor using previously created IntentFilters
    MediaRouteDescriptor routeDescriptor = new MediaRouteDescriptor.Builder(
    // Add the route descriptor to the provider descriptor
    MediaRouteProviderDescriptor providerDescriptor =
            new MediaRouteProviderDescriptor.Builder()

    // Publish the descriptor to the framework

For more information on the available descriptor settings, see the reference documentation for MediaRouteDescriptor and MediaRouteProviderDescriptor.

Controlling Routes

When an application connects to your media route provider, the provider receives playback commands through the media router framework sent to your route by other apps. To handle these requests, you must provide an implementation of a MediaRouteProvider.RouteController class, which processes the commands and handles the actual communication to your receiver device.

The media router framework calls the onCreateRouteController() method of your route provider to obtain an instance of this class and then routes requests to it. These are the key methods of the MediaRouteProvider.RouteController class, which you must implement for your media route provider:

All playback control requests, except for volume changes, are directed to the onControlRequest() method. Your implementation of this method must parse the control requests and respond to them appropriately. Here is an example implementation of this method which processes commands for a remote playback media route:

private final class SampleRouteController extends
        MediaRouteProvider.RouteController {

    public boolean onControlRequest(Intent intent, ControlRequestCallback callback) {

        String action = intent.getAction();

        if (intent.hasCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {
            boolean success = false;
            if (action.equals(MediaControlIntent.ACTION_PLAY)) {
                success = handlePlay(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_ENQUEUE)) {
                success = handleEnqueue(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_REMOVE)) {
                success = handleRemove(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_SEEK)) {
                success = handleSeek(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_GET_STATUS)) {
                success = handleGetStatus(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_PAUSE)) {
                success = handlePause(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_RESUME)) {
                success = handleResume(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_STOP)) {
                success = handleStop(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_START_SESSION)) {
                success = handleStartSession(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_GET_SESSION_STATUS)) {
                success = handleGetSessionStatus(intent, callback);
            } else if (action.equals(MediaControlIntent.ACTION_END_SESSION)) {
                success = handleEndSession(intent, callback);

            Log.d(TAG, mSessionManager.toString());
            return success;
        return false;

It is important to understand that the MediaRouteProvider.RouteController class is intended to act as a wrapper for the API to your media playback equipment. The implementation of the methods in this class is entirely dependent on the programmatic interface provided by your receiving device.

Additional code samples

The Android BasicMediaRouter and Android MediaRouter samples further demonstrate the use of the APIs covered on this page.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields


Seguir a Google Developers en WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience. (Dec 2017 Android Platform & Tools Survey)