Streaming live video/audio in android is one of the very few interesting parts we have. Whenever we talk of streaming, the possibility of using RTMP(Real Time Messaging Protocol) cannot be ruled out. As RTMP is one of the most basic protocols available for streaming live video/audio feed. But unfortunately Android’s standard VideoView does not support the playback of RTMP streams. Therefore to natively play a live RTMP stream on Android, an external library is required which can provide us an Android RTMP player. As of now I have discovered two libraries which can serve this purpose.

First being the Android Vitamio library, and second being the LibVLC SDK for Android. In my opinion the later one is the better one. As this comes in a form of a plug-in solution from the open source organisation that built the worlds greatest video player ever, that right:- VLC. Therefore in this tutorial to build an example of Android RTMP player we will discuss how we can use the LibVLC SDK for Android. But before doing so lets, also have an overview of its counterpart, Vitamio library as well.

Android Vitamio Library

Vitamio is an open source project for Android and iOS built up on FFmpeg code. Vitamio provides us a clean and simple API with full and real hardware accelerated decoder and render-er. Vitamio is a very powerful library which supports a wide variety of video/audio formats like FLV, TS/TP, WMV, DivX, Xvid and many other standard formats. What makes it different is that it also supports the playback of embedded and external subtitles like .mkv and .srt. But Vitamio comes with a license, hence please go through this license page before using it in your project. In this Android RTMP example, we will not only discuss the live streaming of RTMP stream in Android, but will also discuss how we can stream m3u8 playlists(HLS), RTSP streams and MMS (Microsoft Media Stream). But through the usage of VLCs SDK for Android.

Android VLC SDK

VLC Media Player has been the most popular video file playback software available till date. The interesting part about it is that, it supports all major video/audio playback formats. Therefore when compared with other SDKs or libraries like Vitamio for RTMP streaming, it is considered to be far more superior by default. This gives us an obvious answer why we should use this LibVLC SDK for Android. Coincidentally, it is not very difficult to use this SDK in an Android app. Once done, you can play all the playback formats it supports, be it HLS, RTMP, RTSP, or even subtitles. Full SDK docs are available here. Therefore, without waiting lets integrate it in our app.

How to embed VLC Media Player in your Android App?

To use Android VLC Media Player SDK in your app, you may need to include the compiled code for vlc media player in your app. To do so, two ways are available:

Option 1: Manually compile SDK and use it through NDK as .so file:

• Android VLC SDK Compilation Steps

Option 2: Use a Gradle dependency, compiled as an opensource project vlc-android-sdk by mrmaffen (May not be the latest version always).

So for this Android RTMP Streaming Example, I will be using this option. To do so, all you need to do is in your build.gradle (app) file, add a dependency as shown:

dependencies {
    compile "de.mrmaffen:vlc-android-sdk:2.0.6"
}

Streaming RTMP Stream Live in Android

Before heading directly to the implementation part, first lets understand RTMP a little. Real Time Messaging Protocol (RTMP) is a protocol owned by Adobe Systems. This protocol was developed to stream audio and video content to company’s proprietary flash player. But later on as it evolved, a part of it was released for public use. More of it can be read here. Mostly this type of protocol is used for IPTV and live VoD streaming, but it can be used in many other areas as well.

To play an RTMP stream in Android, a normal VideoView cannot be used, as it does not support the RTMP playback. But a WebView can be used to play the RTMP stream without any external library. This solves the problem but in my personal opinion web apps don’t give a nice look and feel to an app. Hence in this Android RTMP example we will be using an external SDK – VLC Media Player for streaming a live RTMP stream. After including it in the project, please add a SurfaceView in your layout file:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <SurfaceView
        android:id="@+id/surface"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_gravity="center"/>
</FrameLayout>

Further to run this Android RTMP player, please code your activity something like this:

package com.truiton.rtmpplayer;

import android.content.res.Configuration;
import android.net.Uri;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.Gravity;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.ViewGroup.LayoutParams;
import android.widget.Toast;

import org.videolan.libvlc.IVLCVout;
import org.videolan.libvlc.LibVLC;
import org.videolan.libvlc.Media;
import org.videolan.libvlc.MediaPlayer;

import java.lang.ref.WeakReference;
import java.util.ArrayList;


public class MainActivity extends AppCompatActivity implements IVLCVout.Callback {
    public final static String TAG = "MainActivity";
    private String mFilePath;
    private SurfaceView mSurface;
    private SurfaceHolder holder;
    private LibVLC libvlc;
    private MediaPlayer mMediaPlayer = null;
    private int mVideoWidth;
    private int mVideoHeight;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mFilePath = "rtmp://rrbalancer.broadcast.tneg.de:1935/pw/ruk/ruk";

        Log.d(TAG, "Playing: " + mFilePath);
        mSurface = (SurfaceView) findViewById(R.id.surface);
        holder = mSurface.getHolder();
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        setSize(mVideoWidth, mVideoHeight);
    }

    @Override
    protected void onResume() {
        super.onResume();
        createPlayer(mFilePath);
    }

    @Override
    protected void onPause() {
        super.onPause();
        releasePlayer();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        releasePlayer();
    }


    /**
     * Used to set size for SurfaceView
     *
     * @param width
     * @param height
     */
    private void setSize(int width, int height) {
        mVideoWidth = width;
        mVideoHeight = height;
        if (mVideoWidth * mVideoHeight <= 1)
            return;

        if (holder == null || mSurface == null)
            return;

        int w = getWindow().getDecorView().getWidth();
        int h = getWindow().getDecorView().getHeight();
        boolean isPortrait = getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
        if (w > h && isPortrait || w < h && !isPortrait) {
            int i = w;
            w = h;
            h = i;
        }

        float videoAR = (float) mVideoWidth / (float) mVideoHeight;
        float screenAR = (float) w / (float) h;

        if (screenAR < videoAR)
            h = (int) (w / videoAR);
        else
            w = (int) (h * videoAR);

        holder.setFixedSize(mVideoWidth, mVideoHeight);
        LayoutParams lp = mSurface.getLayoutParams();
        lp.width = w;
        lp.height = h;
        mSurface.setLayoutParams(lp);
        mSurface.invalidate();
    }

    /**
     * Creates MediaPlayer and plays video
     *
     * @param media
     */
    private void createPlayer(String media) {
        releasePlayer();
        try {
            if (media.length() > 0) {
                Toast toast = Toast.makeText(this, media, Toast.LENGTH_LONG);
                toast.setGravity(Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL, 0,
                        0);
                toast.show();
            }

            // Create LibVLC
            // TODO: make this more robust, and sync with audio demo
            ArrayList<String> options = new ArrayList<String>();
            //options.add("--subsdec-encoding <encoding>");
            options.add("--aout=opensles");
            options.add("--audio-time-stretch"); // time stretching
            options.add("-vvv"); // verbosity
            libvlc = new LibVLC(this, options);
            holder.setKeepScreenOn(true);

            // Creating media player
            mMediaPlayer = new MediaPlayer(libvlc);
            mMediaPlayer.setEventListener(mPlayerListener);

            // Seting up video output
            final IVLCVout vout = mMediaPlayer.getVLCVout();
            vout.setVideoView(mSurface);
            //vout.setSubtitlesView(mSurfaceSubtitles);
            vout.addCallback(this);
            vout.attachViews();

            Media m = new Media(libvlc, Uri.parse(media));
            mMediaPlayer.setMedia(m);
            mMediaPlayer.play();
        } catch (Exception e) {
            Toast.makeText(this, "Error in creating player!", Toast
                    .LENGTH_LONG).show();
        }
    }

    private void releasePlayer() {
        if (libvlc == null)
            return;
        mMediaPlayer.stop();
        final IVLCVout vout = mMediaPlayer.getVLCVout();
        vout.removeCallback(this);
        vout.detachViews();
        holder = null;
        libvlc.release();
        libvlc = null;

        mVideoWidth = 0;
        mVideoHeight = 0;
    }

    /**
     * Registering callbacks
     */
    private MediaPlayer.EventListener mPlayerListener = new MyPlayerListener(this);

    @Override
    public void onNewLayout(IVLCVout vout, int width, int height, int visibleWidth, int visibleHeight, int sarNum, int sarDen) {
        if (width * height == 0)
            return;

        // store video size
        mVideoWidth = width;
        mVideoHeight = height;
        setSize(mVideoWidth, mVideoHeight);
    }

    @Override
    public void onSurfacesCreated(IVLCVout vout) {

    }

    @Override
    public void onSurfacesDestroyed(IVLCVout vout) {

    }

    @Override
    public void onHardwareAccelerationError(IVLCVout vlcVout) {
        Log.e(TAG, "Error with hardware acceleration");
        this.releasePlayer();
        Toast.makeText(this, "Error with hardware acceleration", Toast.LENGTH_LONG).show();
    }

    private static class MyPlayerListener implements MediaPlayer.EventListener {
        private WeakReference<MainActivity> mOwner;

        public MyPlayerListener(MainActivity owner) {
            mOwner = new WeakReference<MainActivity>(owner);
        }

        @Override
        public void onEvent(MediaPlayer.Event event) {
            MainActivity player = mOwner.get();

            switch (event.type) {
                case MediaPlayer.Event.EndReached:
                    Log.d(TAG, "MediaPlayerEndReached");
                    player.releasePlayer();
                    break;
                case MediaPlayer.Event.Playing:
                case MediaPlayer.Event.Paused:
                case MediaPlayer.Event.Stopped:
                default:
                    break;
            }
        }
    }
}

Although the above code is self explanatory, but please dont forget to change the RTMP path to play your stream. At times to stream an RTMP stream in Android, you may have to pass the headers along with the path. Luckily you may have seen above that LibVLC supports that too. Hence all types of RTMP streams can be used with Android VLC SDK. The above example would look something like this:

But before moving on to other parts, please don’t forget to add configChanges flag in your AndroidManifest for this Activity, as shown:

        <activity
            android:name=".MainActivity"
            android:configChanges="orientation|screenSize"
            android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>

Full source code is also available here:

Full Source Code

Android RTSP Streaming

Real Time Streaming Protocol (RTSP) is used for streaming content from media servers. Like YouTube uses RTSP streams to distribute content. The easy part about RTSP streaming is that, it can be done through the standard VideoView of Android. To read more about it please refer to my VideoView Example.

But if you are implementing a solution by using the embedded VLC Media Player Lib, you might prefer using the same for RTSP streaming as well. As a matter of fact Android VLC SDK supports all video/audio formats, hence it also supports the playback of RTSP stream. Therefore If you are building a media playback app, you may use the same code shown in the section above to playback an RTSP stream. All you need to do is replace the URL.

mFilePath = "rtsp://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mov";

Android m3u8 Streaming

How to play m3u8 video in Android? is one of the most common questions among the Android developers. The easiest way to do HTTP Live Streaming (HLS) in Android is through the usage of standard VideoView. But as you might have guessed, there are some limitations to it. Through standard Android VideoView you can stream m3u8 streams but only on the devices having Android 3.0 and above. This is because the HTTP/HTTPS live streaming and HTTP/HTTPS progressive streaming protocols were introduced in Android 3.0 and full support with HTTPS was given in 3.1.

If you wish to do HTTP Live Streaming (HLS) and support Android m3u8 streaming, for earlier versions of android. You should consider using the Android LibVLC, as this library adds the support for playback of m3u8 lists along with many other formats on android API 9 and above. To do so the process is same- as shown in the sections above, just replace the URL with m3u8, HTTP Live Streaming URL:

mFilePath = "http://93.184.221.133/00573D/236/236-0.m3u8";

Playing m3u8 stream on Android with VLC SDK would look something like this:

Android MMS Stream

Another uncommon format for streaming in Android is MMS. Since the Android LibVLC is a powerful library which supports very complex video playback formats, it also supports the playback of Microsoft Media Server (MMS) stream. Hence one should use this SDK to stream MMS as well. MMS is a network streaming protocol, mostly used for webcasts and live radio. Using embedded VLC media player library for the playback of an MMS stream in Android is not that different from using other protocols. All you have to do just replace the path variable to point to an MMS url:

mFilePath = "mms://beotelmedia.beotel.net/studiob";

Conclusion

As we discussed above, I would like to conclude by saying that LibVLC SDK is a very powerful multi-platform library, for iOS and Android both. By using Vitamio library one can stream limited types of video formats and protocols like RTMP, RTSP, HTTP Live, and HTTP progressive streaming protocol. But by using the Android VLC SDK, you can stream all the major video/audio formats available till date. Another great playback feature that comes along with LibVLC is that it supports the playback of subtitles and multiple audio tracks as well. Hope this helped. Connect with us through our Facebook, Google+ and Twitter profiles for more updates.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post How To Stream RTMP live in Android appeared first on Truiton.

A lot of people have been asking me how to integrate YouTube channels into an Android app. The answer is, by usage of YouTube data API and YouTube Android player API. Since as of now YouTube Android player does not provide any mechanism to access channels, we need to use the YouTube Data API with it to access the list of channels. Many of us don’t know that, YouTube only provides a player API for Android. As such there is no support for channels in that API. Although YouTube channels functionality is implemented in their official app. Which makes me think, if they can do it, we can do it too.

But first lets understand what YouTube channels are?

Speaking of channels, they are always associated with YouTube users. Actually they are same, users are custom generated URLs, which YouTube channel owners can generate through their account. Reason being channels have a long system generated ID attached to them, which becomes a little difficult for them to distribute. In this YouTube Android API channels tutorial, I would show how videos can be shown from both URLs.

As of now there are two ways through which we can show a YouTube channel in an Android App. But first you may need to add a library for YouTube Android Player API:

1. Download the latest library bundle from this download page.
2. Unzip the downloaded file.
3. Navigate for libs folder in the unzipped folder.
4. Copy the YouTubeAndroidPlayerApi.jar file in your project’s libs folder.
5. Now navigate to this folder in Android Studio.
6. Right click on the YouTubeAndroidPlayerApi.jar file and select the “Add as library”.

And you’re all set, to play YouTube channels in your Android app. Now lets have a look at the two methods through which YouTube Android player API can show channels:

1) Android YouTube Intents

YouTube player API gives us a list of methods through which we can open specific screens of the official YouTube Android app. These methods can be accessed through the YouTubeIntents class in the API. Android YouTube Player API gives us a specific method createUserIntent  through which we can open user screen, in the official YouTube app. Code sample:

Intent intent = YouTubeIntents.createUserIntent(this, "PitbullVEVO");
startActivity(intent);

This can quickly solve your problem of opening YouTube users, without getting into the complexities of channel ID parsing.

Other than this Android YouTube player API provides many more static methods which can be used to send various intents to the YouTube app. Some of the basic types are :

1. createPlayVideoIntent(Context context, String videoId) – This is used for playing a video in YouTube app.
2. createPlayPlaylistIntent(Context context, String playlistId) – This is used for playing a playlist in YouTube app.
3. createUploadIntent(Context context, Uri videoUri) – This is used to open the upload video screen of YouTube Android app.

Recently in January 2015, an update to Android YouTube API was released, which made some additions in YouTubeIntents class. Now through canResolvePlayVideoIntentWithOptions method, we can check whether the installed YouTube app supports the fullscreen mode or not. For more details please refer to the YouTubeIntents class.

2) Android YouTube API Channels

With the help of above mentioned approach you can view YouTube users/channels in official app. But if you want to display channels in your own app, then you might have to a little more coding. As you might have understood by now, channel is not an inbuilt functionality of YouTube. Its a way, through which users can organize their videos. In short a channel/user is nothing but a collection of YouTube playlists.

To show playlists in your app from a username, you might have to make two YouTube Data API calls and then play the chosen playlist through Android YouTube Player API, integrated in your app.

1) YouTube channel list – In Android to get a YouTube channel ID, we have to make a YouTube Data API call for channel list. This API can list down all the channel IDs associated with specified username. To read more about this you can visit the YouTube Data API channel list page, or you can simply use the URL below to get a username’s channelId.

https://www.googleapis.com/youtube/v3/channels?part=snippet&forUsername={USERNAME}&key={YOUR_API_KEY}

Please Note: To access the API please generate an API key form Google API Console, for steps please refer to Android YouTube player example.

This API call would return a JSON object, you may have to parse it and extract the channel id from it, for further usage. See the image below:

2) Android YouTube Data API Playlists – Now that we have a channelId, we are one step closer for displaying YouTube channels in Android app. Next we need to get a list of playlists for our channel ID. To get a list of playlists associated with a channel, we need to make a Playlists list API call. To read more about it please refer to the page YouTube Playlists List, or you can use the URL below to make the call.

https://www.googleapis.com/youtube/v3/playlists?part=snippet&channelId={YOUR_CHANNEL_ID}&key={YOUR_API_KEY}

Please Note: To access the API please generate an API key form Google API Console, for steps please refer to Android YouTube player example.

For e.g. use the channelId (highlighted in point 1 above) in this URL. It would return a JSON object containing a list of playlists. Here each playlist would have an object of its own with an ID associated with it. You may have to parse it for further usage. Please see the image below:

3) Android YouTube API Playlists – Luckily YouTube Player API for Android supports the playlists. But to play a playlist, first we need to implement a YouTube Player in our app. To learn more about how to implement a YouTube player in your app please have a look at this Android YouTube API example. To run playlists in the specified example just replace the cueVideo  method line with:

YPlayer.cuePlaylist("PLRX442jA-zGKxR-wAfC_xUvpZX1Rh0usm");

Here the specified id is playlist id from the point 2.

This concludes the Android YouTube API Example For Channel, although who knows in future, maybe a new way is introduced to show YouTube channels on Android. As the Android YouTube API is in a very nascent stage. Hope this tutorial helped you. Stay connected with us through Facebook, Twitter and Google+.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post Android YouTube API Example For Channels appeared first on Truiton.

Well well its official, on 10th May 2013 Google has finally released YouTube API for android. You might be wondering what difference does it make, earlier too we were able to play YouTube videos on Android. The difference in this API is the way we are accessing it. Earlier to play a YouTube video on an Android device in an app we had to fire an Intent. Further with this Intent the android’s YouTube player App was launched and the video was played over there. But now with this new Android YouTube API we would be able to play HD YouTube videos in our Android app, i.e. without an intent. Also we would have full control over the playback.

Earlier I wrote a tutorial to play YouTube videos on android, in which the only limitation was, that we could not stream HD YouTube videos. Hence I had to write this Android YouTube API Tutorial. With this new API we can we can seamlessly stream high quality YouTube videos and also maintain their state while screen is rotated i.e. resuming video from where it stopped. Although if you would like to give a read to my tutorials on streaming YouTube video on Android please have a look at the following links:

1. Android VideoView Example
2. Android YouTube Player API Tutorial

To start off with Android YouTube Player API there are certain steps that are needed to be performed. But first let me introduce you to the concept through which this player works. Android YouTube Player can be used in any app by importing a library in to that app’s project, but by doing this it does not mean that you have every thing. Android YouTube Player API works along with the device’s native YouTube Player. Means even after importing a library we would require an android device which has YouTube app installed (min ver 4.2.16). In reality this API library which we imported in to our app project, will communicate with a service of Android YouTube app which is bundled with the OS. To begin the tutorial lets follow these steps:

Step 1 : Include a jar file in your project

Download Android YouTube Player API bundle from here. Unzip this file and follow the steps below to include it in your app:

1. Copy the jar file from libs folder to the the libs folder of your project.
2. Right click on your project, Build Path -> Configure Build Path -> Libraries Tab
3. Add Jars -> Select Your project’s libs folder -> Select YouTubeAndroidPlayerAPI.jar ->Ok
4. Order and Export Tab -> Check YouTubeAndroidPlayerAPI.jar – Ok

Step 2 : Create an API Key for Android YouTube Player

To access the Android YouTube Player API on device we need to create an API key from Google API developer console. The steps to do so are:

1. Login to API console
2. Create a Project -> Goto Services -> Turn on the switch for Google YouTube Data API v3
3. Goto API Access -> Create new Android Key-> In popup enter one SHA1 certificate fingerprint and package name (separated by a semicolon) per line.
4. To get SH1 certificate of your app open command prompt, navigate to your Java bin folder and enter this command:

5. keytool.exe -V -list -alias androiddebugkey -keystore "C:\Users\Truiton\.android\debug.keystore" -storepass android -keypass android

6. In the above command just replace the keystore user path with your system’s user path, and this should work.
7. From here copy Sh1 certificate and also copy package name of your spp from eclipse.
8. Now enter these values in the API Console popup in the desired format, you key will be generated.

Step 3 : Write code for Android YouTube Player API

Now that we have all the prerequisites in place lets start with the app manifest first:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.truiton.youtubeapi"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="17" />

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

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.truiton.youtubeapi.TruitonYouTubeAPIActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Lets define the layout which we are going to use for Android YouTube API:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".TruitonYouTubeAPIActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />

    <com.google.android.youtube.player.YouTubePlayerView
        android:id="@+id/youtube_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</RelativeLayout>

Have a look at the above layout, here the com.google.android.youtube.player.YouTubePlayerView is being used to display the YouTube Video. Next lets have a look at the code through which Android YouTube Player API can be used:

package com.truiton.youtubeapi;

import com.google.android.youtube.player.YouTubeBaseActivity;
import com.google.android.youtube.player.YouTubeInitializationResult;
import com.google.android.youtube.player.YouTubePlayer;
import com.google.android.youtube.player.YouTubePlayerView;
import com.google.android.youtube.player.YouTubePlayer.Provider;

import android.os.Bundle;
import android.content.Intent;
import android.view.Menu;
import android.widget.Toast;

public class TruitonYouTubeAPIActivity extends YouTubeBaseActivity implements
		YouTubePlayer.OnInitializedListener {

	private YouTubePlayer YPlayer;
	private static final String YoutubeDeveloperKey = "AIzaSyDhEeq_FYAdCzMMSigmMcRwF_nQEhUXS-0";
	private static final int RECOVERY_DIALOG_REQUEST = 1;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_you_tube_api);

		YouTubePlayerView youTubeView = (YouTubePlayerView) findViewById(R.id.youtube_view);
		youTubeView.initialize(YoutubeDeveloperKey, this);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.you_tube_api, menu);
		return true;
	}

	@Override
	public void onInitializationFailure(YouTubePlayer.Provider provider,
			YouTubeInitializationResult errorReason) {
		if (errorReason.isUserRecoverableError()) {
			errorReason.getErrorDialog(this, RECOVERY_DIALOG_REQUEST).show();
		} else {
			String errorMessage = String.format(
					"There was an error initializing the YouTubePlayer",
					errorReason.toString());
			Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
		}
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (requestCode == RECOVERY_DIALOG_REQUEST) {
			// Retry initialization if user performed a recovery action
			getYouTubePlayerProvider().initialize(YoutubeDeveloperKey, this);
		}
	}

	protected YouTubePlayer.Provider getYouTubePlayerProvider() {
		return (YouTubePlayerView) findViewById(R.id.youtube_view);
	}

	@Override
	public void onInitializationSuccess(Provider provider,
			YouTubePlayer player, boolean wasRestored) {
		YPlayer = player;
		/*
		 * Now that this variable YPlayer is global you can access it
		 * throughout the activity, and perform all the player actions like
		 * play, pause and seeking to a position by code.
		 */
		if (!wasRestored) {
			YPlayer.cueVideo("2zNSgSzhBfM");
		}
	}

}

To make the above Android YouTube API example work you need to specify your developer key. In above example first onCreate method is called, in this method YouTubePlayerView is initialized by YouTubePlayerView.initialize() method. Further if the initialization is successful, onInitializationSuccess() method is called. In this method one can specify the video that needs to be played. Also if you notice I have declared the player variable as a global variable by the name of YPlayer. With the help of this variable we would be able to access the Android YouTube Player API throughout the Activity, and perform play, pause, seek and various other functions.

After performing all the above steps, your app would look something like the screenshots above. An interesting feature of using this Android YouTube Player API, is that we don’t have to do any sort of programming to make the video run in full screen mode. Also no effort is required to stream HD YouTube videos. Another interesting feature is that while playback if the screen is rotated, the video playback starts exactly from where it stopped, ain’t that great as no amount of coding is to be done for this feature too. Hope this Android YouTube API Tutorial helped you in some way. If it did or you simply liked it, please like and share it with your friends on Google+ and Facebook.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post Android YouTube API Tutorial appeared first on Truiton.