Android Sender App

This guide shows you how to create a cast-enabled Android Sender App by walking you through an example app.

To follow along with this guide, download our AdvancedExample.zip, which is a complete Android app that implements casting functionality for videos with ads using the IMA Android SDK.

Prerequisites

This guide builds upon existing knowledge of the Google Cast SDK and the IMA SDK for Android. Users should familiarize themselves with:

This guide discusses the specific setup used in the Advanced Example to communicate with the receiver. It doesn't cover standard Cast setup code or normal IMA ad playback. For more details on implementing the receiver, see our HTML5 Receiver Guide.

Media Player

The functionality for loading the media on to the receiver is implemented in CastApplication.java, along with the majority of the Cast-specific code. The media that this attempts to load is the content URL, it then also sends a custom messsage to the receiver telling it to request ads using the same ad tag and seek to the sender's current timestamp.

CastApplication.java

private void createMediaPlayer() {
    Log.d(TAG, "making media player");
    // Create a Remote Media Player
    mRemoteMediaPlayer = new RemoteMediaPlayer();

    mRemoteMediaPlayer.setOnStatusUpdatedListener(
            new RemoteMediaPlayer.OnStatusUpdatedListener() {
                @Override
                public void onStatusUpdated() {
                    MediaStatus mediaStatus = mRemoteMediaPlayer.getMediaStatus();
                    Log.d(TAG, "Media status: " + mediaStatus);
                }
            });

    mRemoteMediaPlayer.setOnMetadataUpdatedListener(
            new RemoteMediaPlayer.OnMetadataUpdatedListener() {
                @Override
                public void onMetadataUpdated() {
                    MediaInfo mediaInfo = mRemoteMediaPlayer.getMediaInfo();
                    Log.d(TAG, "Media info: " + mediaInfo);
                }
            });

    try {
        Cast.CastApi.setMessageReceivedCallbacks(sApiClient,
                mRemoteMediaPlayer.getNamespace(), mRemoteMediaPlayer);
    } catch (IOException e) {
        Log.e(TAG, "Exception while creating media channel", e);
    }

    mRemoteMediaPlayer
            .requestStatus(sApiClient)
            .setResultCallback(
                    new ResultCallback<RemoteMediaPlayer.MediaChannelResult>() {
                        @Override
                        public void onResult(RemoteMediaPlayer.MediaChannelResult result) {
                            if (!result.getStatus().isSuccess()) {
                                Log.e(TAG, "Failed to request status.");
                            } else {
                                MediaMetadata mediaMetadata =
                                        new MediaMetadata(MediaMetadata.MEDIA_TYPE_MOVIE);
                                mediaMetadata.putString(MediaMetadata.KEY_TITLE, "My video");
                                MediaInfo mediaInfo = new MediaInfo.Builder(mContentUrl)
                                        .setContentType("video/mp4")
                                        .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
                                        .setMetadata(mediaMetadata)
                                        .build();
                                loadMedia(mediaInfo, false);
                            }
                        }
                    });
}

private void loadMedia(MediaInfo mediaInfo, Boolean autoplay) {
    try {
        Log.d(TAG, "loading media");
        mRemoteMediaPlayer.load(sApiClient, mediaInfo, autoplay)
                .setResultCallback(new ResultCallback<RemoteMediaPlayer.MediaChannelResult>() {
                    @Override
                    public void onResult(RemoteMediaPlayer.MediaChannelResult result) {
                        if (result.getStatus().isSuccess()) {
                            boolean adStarted = mVideoPlayerController.hasAdStarted();
                            if (mVideoFragment.isVmap() || !adStarted) {
                                sendMessage("requestAd," + mAdTagUrl + ","
                                        + mVideoPlayerController.getCurrentContentTime());
                            } else {
                                sendMessage("seek,"
                                    + mVideoPlayerController.getCurrentContentTime());
                            }
                        } else {
                            Log.e(TAG, "Error loading Media : "
                                    + result.getStatus().getStatusCode());
                        }
                    }
                });
    } catch (Exception e) {
        Log.e(TAG, "Problem opening media during loading", e);
    }
}

private void sendMessage(String message) {
    if (sApiClient != null && incomingMsgHandler != null) {
        try {
            Log.d(TAG, "Sending message: " + message);
            Cast.CastApi.sendMessage(sApiClient, NAMESPACE, message)
                    .setResultCallback(new ResultCallback<Status>() {
                        @Override
                        public void onResult(Status result) {
                            if (!result.isSuccess()) {
                                Log.e(TAG, "Sending message failed");
                            }
                        }
                    });
        } catch (Exception e) {
            Log.e(TAG, "Exception while sending message", e);
        }
    }
}

Two messages are defined in the onResult callback: seek, to resume playback on the receiver without ads, and requestAd, which re-requests the same ad tag on the receiver. The requestAd message is used for ad playlists and VMAP in this example, but you can define your own behavior for what should happen when you cast. These messages are comma-delimited, where the first parameter is the message name, and the remaining parameters are ad-tag and seek time.

MediaRouter Callback

The MediaRouter.Callback handles starting and stopping casting and controls switching video playback between the Android and cast devices. This involves pausing and seeking the video.

CastApplication.java

private final MediaRouter.Callback mediaRouterCallback = new MediaRouter.Callback() {
    @Override
    public void onRouteSelected(MediaRouter router, MediaRouter.RouteInfo info) {
        // User starts casting. Pause video on device and set Google Cast device.
        mVideoPlayerController = mVideoFragment.getVideoPlayerController();
        mVideoPlayerController.pause();
        mAdTagUrl = mVideoPlayerController.getAdTagUrl();
        mContentUrl = mVideoPlayerController.getContentVideoUrl();
        CastDevice device = CastDevice.getFromBundle(info.getExtras());
        setSelectedDevice(device);
    }

    @Override
    public void onRouteUnselected(MediaRouter router, MediaRouter.RouteInfo info) {
        // User stops casting. Resume video on device and seek to current time of Google Cast.
        mVideoPlayerController.resume();
        if (mCastAdPlaying) {
            mVideoPlayerController.seek(mCastContentTime);
        } else {
            double videoPosition = mRemoteMediaPlayer.getApproximateStreamPosition();
            mVideoPlayerController.seek(videoPosition / 1000.0);
        }

        stopCastApplication();
        setSelectedDevice(null);
    }
};

Messages

The app defines the MessageReceivedCallback to allow the receiver to provide notices of time updates from a casting video and when a casted ad stops and content starts. These are sent by the receiver and handled by two messages, onContentPauseRequested and onContentResumeRequested. These messages are comma-delimited and formatted similarly to the seek and requestAd messages described above.

CastApplication.java

public final Cast.MessageReceivedCallback incomingMsgHandler =
        new Cast.MessageReceivedCallback() {
            @Override
            public void onMessageReceived(CastDevice castDevice, String namespace,
                                          String message) {
                Log.d(TAG, "Receiving message: " + message);
                String[] splitMessage = message.split(",");
                String event = splitMessage[0];
                switch (event) {
                    case "onContentPauseRequested":
                        mCastAdPlaying = true;
                        mCastContentTime = Double.parseDouble(splitMessage[1]);
                        return;
                    case "onContentResumeRequested":
                        mCastAdPlaying = false;
                        return;
                }
            }
        };

Next Steps

At this point you have a good understanding of how the Android sender app interacts with the receiver. To try it out, create a receiver app and register your receiver to receive an app ID that's used with API calls from the sender app.

Send feedback about...

IMA SDK and Google Cast
Need help? Visit our support page.