Android
Youtube-API
Suche…
Bemerkungen
- Zunächst müssen Sie den neuesten Jar-Link unter folgendem Link herunterladen: https://developers.google.com/youtube/android/player/downloads/
- Sie müssen dieses Glas in Ihr Projekt aufnehmen. Kopieren Sie dieses Jar in den libs-Ordner und vergessen Sie nicht, es in Abstufungsdateien für Abhängigkeiten hinzuzufügen {compile files ('libs / YouTubeAndroidPlayerApi.jar')}
- Sie benötigen einen API-Schlüssel, um auf Youtube-APIs zuzugreifen. Folgen Sie diesem Link: https://developers.google.com/youtube/android/player/register , um Ihren API-Schlüssel zu generieren.
- Reinigen und bauen Sie Ihr Projekt. Jetzt können Sie den YoutubeAndroidPlayerApi verwenden. Um ein Youtube-Video abzuspielen, benötigen Sie eine entsprechende Video-ID, damit Sie es auf Youtube abspielen können. Zum Beispiel: https://www.youtube.com/watch?v=B08iLAtS3AQ , B08iLAtS3AQ ist die Video-ID, die Sie zum Abspielen auf Youtube benötigen.
StandAlonePlayerActivity starten
Starten Sie eine eigenständige Spieleraktivität
Intent standAlonePlayerIntent = YouTubeStandalonePlayer.createVideoIntent((Activity) context, Config.YOUTUBE_API_KEY, // which you have created in step 3 videoId, // video which is to be played 100, //The time, in milliseconds, where playback should start in the video true, //autoplay or not false); //lightbox mode or not; false will show in fullscreen context.startActivity(standAlonePlayerIntent);
Aktivität, die YouTubeBaseActivity erweitert
public class CustomYouTubeActivity extends YouTubeBaseActivity implements YouTubePlayer.OnInitializedListener, YouTubePlayer.PlayerStateChangeListener {
private YouTubePlayerView mPlayerView;
private YouTubePlayer mYouTubePlayer;
private String mVideoId = "B08iLAtS3AQ";
private String mApiKey;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mApiKey = Config.YOUTUBE_API_KEY;
mPlayerView = new YouTubePlayerView(this);
mPlayerView.initialize(mApiKey, this); // setting up OnInitializedListener
addContentView(mPlayerView, new LayoutParams(LayoutParams.MATCH_PARENT,
LayoutParams.MATCH_PARENT)); //show it in full screen
}
//Called when initialization of the player succeeds.
@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider,
YouTubePlayer player,
boolean wasRestored) {
player.setPlayerStateChangeListener(this); // setting up the player state change listener
this.mYouTubePlayer = player;
if (!wasRestored)
player.cueVideo(mVideoId);
}
@Override
public void onInitializationFailure(YouTubePlayer.Provider provider,
YouTubeInitializationResult errorReason) {
Toast.makeText(this, "Error While initializing", Toast.LENGTH_LONG).show();
}
@Override
public void onAdStarted() {
}
@Override
public void onLoaded(String videoId) { //video has been loaded
if(!TextUtils.isEmpty(mVideoId) && !this.isFinishing() && mYouTubePlayer != null)
mYouTubePlayer.play(); // if we dont call play then video will not auto play, but user still has the option to play via play button
}
@Override
public void onLoading() {
}
@Override
public void onVideoEnded() {
}
@Override
public void onVideoStarted() {
}
@Override
public void onError(ErrorReason reason) {
Log.e("onError", "onError : " + reason.name());
}
}
YoutubePlayerFragment im Portrait Activty
Der folgende Code implementiert ein einfaches YoutubePlayerFragment. Das Layout der Aktivität ist im Hochformatmodus gesperrt. Wenn sich die Ausrichtung ändert oder der Benutzer im YoutubePlayer auf Vollbildschirm klickt, wird die Landschaft in eine Landschaft mit dem YoutubePlayer umgewandelt. Das YoutubePlayerFragment muss keine Aktivität erweitern, die von der Youtube-Bibliothek bereitgestellt wird. Es muss YouTubePlayer.OnInitializedListener implementiert werden, um den YoutubePlayer zu initialisieren. Die Klasse unserer Aktivität ist also die folgende
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.Toast;
import com.google.android.youtube.player.YouTubeInitializationResult;
import com.google.android.youtube.player.YouTubePlayer;
import com.google.android.youtube.player.YouTubePlayerFragment;
public class MainActivity extends AppCompatActivity implements YouTubePlayer.OnInitializedListener {
public static final String API_KEY ;
public static final String VIDEO_ID = "B08iLAtS3AQ";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
YouTubePlayerFragment youTubePlayerFragment = (YouTubePlayerFragment) getFragmentManager()
.findFragmentById(R.id.youtubeplayerfragment);
youTubePlayerFragment.initialize(API_KEY, this);
}
/**
*
* @param provider The provider which was used to initialize the YouTubePlayer
* @param youTubePlayer A YouTubePlayer which can be used to control video playback in the provider.
* @param wasRestored Whether the player was restored from a previously saved state, as part of the YouTubePlayerView
* or YouTubePlayerFragment restoring its state. true usually means playback is resuming from where
* the user expects it would, and that a new video should not be loaded
*/
@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer youTubePlayer, boolean wasRestored) {
youTubePlayer.setFullscreenControlFlags(YouTubePlayer.FULLSCREEN_FLAG_CONTROL_ORIENTATION |
YouTubePlayer.FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE);
if(!wasRestored) {
youTubePlayer.cueVideo(VIDEO_ID);
}
}
/**
*
* @param provider The provider which failed to initialize a YouTubePlayer.
* @param error The reason for this failure, along with potential resolutions to this failure.
*/
@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult error) {
final int REQUEST_CODE = 1;
if(error.isUserRecoverableError()) {
error.getErrorDialog(this,REQUEST_CODE).show();
} else {
String errorMessage = String.format("There was an error initializing the YoutubePlayer (%1$s)", error.toString());
Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
}
}
}
Ein YoutubePlayerFragment kann wie folgt zum Layout-Xaml der Aktivität hinzugefügt werden
<LinearLayout 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:orientation="vertical"
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=".MainActivity">
<fragment
android:id="@+id/youtubeplayerfragment"
android:name="com.google.android.youtube.player.YouTubePlayerFragment"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
<ScrollView
android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:text="This is a YoutubePlayerFragment example"
android:textStyle="bold"/>
</LinearLayout>
</ScrollView>
</LinearLayout>
Zuletzt müssen Sie die folgenden Attribute in Ihre Manifest-Datei im Tag der Aktivität einfügen
android:configChanges="keyboardHidden|orientation|screenSize"
android:screenOrientation="portrait"
YouTube Player-API
Beziehen des Android-API-Schlüssels:
Zuerst müssen Sie den SHA-1-Fingerabdruck mit Java-Keytool auf Ihrem Computer abrufen. Führen Sie den folgenden Befehl in cmd / terminal aus, um den SHA-1-Fingerabdruck zu erhalten.
keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android
MainActivity.java
public class Activity extends YouTubeBaseActivity implements YouTubePlayer.OnInitializedListener {
private static final int RECOVERY_DIALOG_REQUEST = 1;
// YouTube player view
private YouTubePlayerView youTubeView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
setContentView(R.layout.activity_main);
youTubeView = (YouTubePlayerView) findViewById(R.id.youtube_view);
// Initializing video player with developer key
youTubeView.initialize(Config.DEVELOPER_KEY, this);
}
@Override
public void onInitializationFailure(YouTubePlayer.Provider provider,
YouTubeInitializationResult errorReason) {
if (errorReason.isUserRecoverableError()) {
errorReason.getErrorDialog(this, RECOVERY_DIALOG_REQUEST).show();
} else {
String errorMessage = String.format(
getString(R.string.error_player), errorReason.toString());
Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
}
}
@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider,
YouTubePlayer player, boolean wasRestored) {
if (!wasRestored) {
// loadVideo() will auto play video
// Use cueVideo() method, if you don't want to play it automatically
player.loadVideo(Config.YOUTUBE_VIDEO_CODE);
// Hiding player controls
player.setPlayerStyle(YouTubePlayer.PlayerStyle.CHROMELESS);
}
}
@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(Config.DEVELOPER_KEY, this);
}
}
private YouTubePlayer.Provider getYouTubePlayerProvider() {
return (YouTubePlayerView) findViewById(R.id.youtube_view);
}
}
Erstellen Config.java
Datei Config.java
. Diese Datei enthält den Google Console API-Entwicklerschlüssel und die YouTube-Video-ID
Config.java
public class Config {
// Developer key
public static final String DEVELOPER_KEY = "AIzaSyDZtE10od_hXM5aXYEh6Zn7c6brV9ZjKuk";
// YouTube video id
public static final String YOUTUBE_VIDEO_CODE = "_oEA18Y8gM0";
}
XML-Datei
<com.google.android.youtube.player.YouTubePlayerView
android:id="@+id/youtube_view"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="30dp" />
YouTube-Daten-API auf Android nutzen
In diesem Beispiel erfahren Sie, wie Sie Wiedergabelistendaten mithilfe der YouTube-Daten-API von Android abrufen.
SHA-1 Fingerabdruck
Zuerst benötigen Sie einen SHA-1-Fingerabdruck für Ihre Maschine. Es gibt verschiedene Methoden, um es abzurufen. Sie können eine beliebige Methode auswählen, die in diesem Q & A angegeben ist .
Google API-Konsole und YouTube-Schlüssel für Android
Nachdem Sie einen SHA-1-Fingerabdruck erstellt haben, öffnen Sie die Google API-Konsole und erstellen Sie ein Projekt. Rufen Sie diese Seite auf und erstellen Sie ein Projekt mit diesem SHA-1-Schlüssel, und aktivieren Sie die YouTube-Daten-API. Jetzt bekommst du einen Schlüssel. Dieser Schlüssel wird zum Senden von Anforderungen von Android und zum Abrufen von Daten verwendet.
Gradle Teil
Für die YouTube-Daten-API müssen Sie Ihrer Gradle-Datei die folgenden Zeilen hinzufügen:
compile 'com.google.apis:google-api-services-youtube:v3-rev183-1.22.0'
Um den nativen Client von YouTube zum Senden von Anforderungen zu verwenden, müssen wir in Gradle die folgenden Zeilen hinzufügen:
compile 'com.google.http-client:google-http-client-android:+'
compile 'com.google.api-client:google-api-client-android:+'
compile 'com.google.api-client:google-api-client-gson:+'
Die folgende Konfiguration muss auch in Gradle hinzugefügt werden, um Konflikte zu vermeiden:
configurations.all {
resolutionStrategy.force 'com.google.code.findbugs:jsr305:3.0.2'
}
Nachfolgend wird gezeigt, wie der gradle.build endlich aussehen würde.
build.gradle
apply plugin: 'com.android.application'
android {
compileSdkVersion 25
buildToolsVersion "25.0.2"
defaultConfig {
applicationId "com.aam.skillschool"
minSdkVersion 19
targetSdkVersion 25
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
configurations.all {
resolutionStrategy.force 'com.google.code.findbugs:jsr305:3.0.2'
}
}
dependencies {
compile fileTree(include: ['*.jar'], dir: 'libs')
androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
exclude group: 'com.android.support', module: 'support-annotations'
})
compile 'com.google.apis:google-api-services-youtube:v3-rev183-1.22.0'
compile 'com.android.support:appcompat-v7:25.3.1'
compile 'com.android.support:support-v4:25.3.1'
compile 'com.google.http-client:google-http-client-android:+'
compile 'com.google.api-client:google-api-client-android:+'
compile 'com.google.api-client:google-api-client-gson:+'
}
Nun kommt der Java-Teil. Da wir HttpTransport
zum Vernetzen und GsonFactory
zum Konvertieren von JSON in POJO verwenden werden, benötigen wir keine andere Bibliothek zum Senden von Anforderungen.
Jetzt möchte ich zeigen, wie Playlisten über die YouTube-API abgerufen werden, indem die Playlist-IDs bereitgestellt werden. Für diese Aufgabe werde ich AsyncTask
. Um zu verstehen, wie wir Parameter anfordern, und um den Ablauf zu verstehen, werfen Sie einen Blick auf die YouTube-Daten-API .
public class GetPlaylistDataAsyncTask extends AsyncTask<String[], Void, PlaylistListResponse> {
private static final String YOUTUBE_PLAYLIST_PART = "snippet";
private static final String YOUTUBE_PLAYLIST_FIELDS = "items(id,snippet(title))";
private YouTube mYouTubeDataApi;
public GetPlaylistDataAsyncTask(YouTube api) {
mYouTubeDataApi = api;
}
@Override
protected PlaylistListResponse doInBackground(String[]... params) {
final String[] playlistIds = params[0];
PlaylistListResponse playlistListResponse;
try {
playlistListResponse = mYouTubeDataApi.playlists()
.list(YOUTUBE_PLAYLIST_PART)
.setId(TextUtils.join(",", playlistIds))
.setFields(YOUTUBE_PLAYLIST_FIELDS)
.setKey(AppConstants.YOUTUBE_KEY) //Here you will have to provide the keys
.execute();
} catch (IOException e) {
e.printStackTrace();
return null;
}
return playlistListResponse;
}
}
Die obige asynchrone Task gibt eine Instanz von PlaylistListResponse
die eine eingebaute Klasse des YouTube-SDK ist. Es hat alle erforderlichen Felder, so dass wir keine POJOs selbst erstellen müssen.
Schließlich MainActivity
wir in unserer MainActivity
Folgendes tun:
public class MainActivity extends AppCompatActivity {
private YouTube mYoutubeDataApi;
private final GsonFactory mJsonFactory = new GsonFactory();
private final HttpTransport mTransport = AndroidHttp.newCompatibleTransport();
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_review);
mYoutubeDataApi = new YouTube.Builder(mTransport, mJsonFactory, null)
.setApplicationName(getResources().getString(R.string.app_name))
.build();
String[] ids = {"some playlists ids here seperated by "," };
new GetPlaylistDataAsyncTask(mYoutubeDataApi) {
ProgressDialog progressDialog = new ProgressDialog(getActivity());
@Override
protected void onPreExecute() {
progressDialog.setTitle("Please wait.....");
progressDialog.show();
super.onPreExecute();
}
@Override
protected void onPostExecute(PlaylistListResponse playlistListResponse) {
super.onPostExecute(playlistListResponse);
//Here we get the playlist data
progressDialog.dismiss();
Log.d(TAG, playlistListResponse.toString());
}
}.execute(ids);
}
}