Tilman
847 lines
27 KiB
Java
847 lines
27 KiB
Java
/* Copyright (c) 2008 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
|
|
|
|
package sample.youtube;
|
|
|
|
import com.google.gdata.client.Service;
|
|
import sample.util.SimpleCommandLineParser;
|
|
import com.google.gdata.client.youtube.YouTubeService;
|
|
import com.google.gdata.data.PlainTextConstruct;
|
|
import com.google.gdata.data.TextConstruct;
|
|
import com.google.gdata.data.media.MediaFileSource;
|
|
import com.google.gdata.data.media.mediarss.MediaCategory;
|
|
import com.google.gdata.data.media.mediarss.MediaDescription;
|
|
import com.google.gdata.data.media.mediarss.MediaKeywords;
|
|
import com.google.gdata.data.media.mediarss.MediaPlayer;
|
|
import com.google.gdata.data.media.mediarss.MediaTitle;
|
|
import com.google.gdata.data.youtube.CommentEntry;
|
|
import com.google.gdata.data.youtube.PlaylistEntry;
|
|
import com.google.gdata.data.youtube.PlaylistFeed;
|
|
import com.google.gdata.data.youtube.PlaylistLinkEntry;
|
|
import com.google.gdata.data.youtube.PlaylistLinkFeed;
|
|
import com.google.gdata.data.youtube.UserEventEntry;
|
|
import com.google.gdata.data.youtube.UserEventFeed;
|
|
import com.google.gdata.data.youtube.VideoEntry;
|
|
import com.google.gdata.data.youtube.VideoFeed;
|
|
import com.google.gdata.data.youtube.YouTubeMediaGroup;
|
|
import com.google.gdata.data.youtube.YouTubeNamespace;
|
|
import com.google.gdata.data.youtube.YtPublicationState;
|
|
import com.google.gdata.util.AuthenticationException;
|
|
import com.google.gdata.util.ServiceException;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.net.URL;
|
|
import java.util.List;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
|
|
|
|
/**
|
|
* Demonstrates authenticated YouTube Data API operations using the Java client
|
|
* library.
|
|
*/
|
|
public class YouTubeWriteClient {
|
|
|
|
/**
|
|
* Input stream for reading user input.
|
|
*/
|
|
private static final BufferedReader bufferedReader = new BufferedReader(
|
|
new InputStreamReader(System.in));
|
|
|
|
/**
|
|
* The name of the server hosting the YouTube GDATA feeds.
|
|
*/
|
|
public static final String YOUTUBE_GDATA_SERVER = "http://gdata.youtube.com";
|
|
|
|
|
|
/**
|
|
* The URL of the videos feed
|
|
*/
|
|
public static final String VIDEOS_FEED = YOUTUBE_GDATA_SERVER
|
|
+ "/feeds/api/videos";
|
|
|
|
/**
|
|
* The prefix of the user feeds
|
|
*/
|
|
public static final String USER_FEED_PREFIX = YOUTUBE_GDATA_SERVER
|
|
+ "/feeds/api/users/";
|
|
|
|
/**
|
|
* The prefix of recent activity feeds
|
|
*/
|
|
public static final String ACTIVITY_FEED_PREFIX = YOUTUBE_GDATA_SERVER
|
|
+ "/feeds/api/events";
|
|
|
|
/**
|
|
* The URL suffix of the test user's uploads feed
|
|
*/
|
|
public static final String UPLOADS_FEED_SUFFIX = "/uploads";
|
|
|
|
/**
|
|
* The URL suffix of the test user's favorites feed
|
|
*/
|
|
public static final String FAVORITES_FEED_SUFFIX = "/favorites";
|
|
|
|
/**
|
|
* The URL suffix of the test user's playlists feed
|
|
*/
|
|
public static final String PLAYLISTS_FEED_SUFFIX = "/playlists";
|
|
|
|
/**
|
|
* The URL suffix of the friends activity feed
|
|
*/
|
|
public static final String FRIENDS_ACTIVITY_FEED_SUFFIX = "/friendsactivity";
|
|
|
|
/**
|
|
* The default username.
|
|
*/
|
|
public static final String DEFAULT_USER = "default";
|
|
|
|
/**
|
|
* The default video to use for examples.
|
|
*/
|
|
public static final String DEFAULT_VIDEO_ID = "scoMN8DYkCw";
|
|
|
|
/**
|
|
* The URL used to upload video
|
|
*/
|
|
public static final String VIDEO_UPLOAD_FEED =
|
|
"http://uploads.gdata.youtube.com/feeds/api/users/"
|
|
+ DEFAULT_USER + "/uploads";
|
|
|
|
/**
|
|
* Enum to deal with various playlist operations:
|
|
* VIEW = print user's playlists
|
|
* LIST = print contents of a playlist
|
|
* CREATE = create new playlist
|
|
* ADD = add video to playlist
|
|
*/
|
|
private enum PlaylistOperation {
|
|
VIEW, LIST, CREATE, ADD
|
|
}
|
|
|
|
/**
|
|
* Prints a String, a newline, and a number of '-' characters equal to the
|
|
* String's length.
|
|
*
|
|
* @param stringToUnderline - the string to print underlined
|
|
*/
|
|
private static void printUnderlined(String stringToUnderline) {
|
|
System.out.println(stringToUnderline);
|
|
for (int i = 0; i < stringToUnderline.length(); ++i) {
|
|
System.out.print("-");
|
|
}
|
|
System.out.println("\n");
|
|
}
|
|
|
|
/**
|
|
* Prints a VideoEntry, optionally showing its responses and comment feeds.
|
|
*
|
|
* @param entry The VideoEntry to be printed
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void printVideoEntry(VideoEntry entry) throws IOException,
|
|
ServiceException {
|
|
System.out.println("Title:" + entry.getTitle().getPlainText());
|
|
|
|
YouTubeMediaGroup mediaGroup = entry.getMediaGroup();
|
|
|
|
if (mediaGroup != null) {
|
|
if (mediaGroup.isPrivate()) {
|
|
System.out.println("Video is private");
|
|
}
|
|
MediaPlayer player = mediaGroup.getPlayer();
|
|
if (player != null) {
|
|
System.out.println("Video URL: " + player.getUrl());
|
|
}
|
|
}
|
|
|
|
if (entry.isDraft()) {
|
|
System.out.println("Video is not live");
|
|
YtPublicationState pubState = entry.getPublicationState();
|
|
if (pubState.getState() == YtPublicationState.State.PROCESSING) {
|
|
System.out.println("Video is still being processed.");
|
|
} else if (pubState.getState() == YtPublicationState.State.REJECTED) {
|
|
System.out.print("Video has been rejected because: ");
|
|
System.out.println(pubState.getDescription());
|
|
System.out.print("For help visit: ");
|
|
System.out.println(pubState.getHelpUrl());
|
|
} else if (pubState.getState() == YtPublicationState.State.FAILED) {
|
|
System.out.print("Video failed uploading because: ");
|
|
System.out.println(pubState.getDescription());
|
|
System.out.print("For help visit: ");
|
|
System.out.println(pubState.getHelpUrl());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Prints a PlaylistEntry by retrieving the description of the playlist,
|
|
* followed by the titles and URLs of each entry in the feed.
|
|
*
|
|
* @param prefix A string to be printed before each entry.
|
|
* @param playlistLinkEntry The PlaylistEntry to be printed
|
|
* @param showPlaylistContents If true, show the list of videos in the
|
|
* playlist.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void printPlaylistEntry(String prefix,
|
|
PlaylistLinkEntry playlistLinkEntry, boolean showPlaylistContents)
|
|
throws IOException, ServiceException {
|
|
System.out.println(prefix);
|
|
System.out.printf("Description: %s\n",
|
|
playlistLinkEntry.getSummary().getPlainText());
|
|
if (showPlaylistContents) {
|
|
printPlaylist(
|
|
playlistLinkEntry.getService(), playlistLinkEntry.getFeedUrl());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints a playlist feed as a series of titles and URLs.
|
|
*
|
|
* @param service A YouTubeService object.
|
|
* @param playlistUrl The url of the playlist.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void printPlaylist(Service service, String playlistUrl)
|
|
throws IOException, ServiceException {
|
|
PlaylistFeed playlistFeed = service.getFeed(new URL(playlistUrl),
|
|
PlaylistFeed.class);
|
|
if (playlistFeed != null) {
|
|
for (PlaylistEntry e : playlistFeed.getEntries()) {
|
|
System.out.println("\tPlaylist Entry: " + e.getTitle().getPlainText());
|
|
System.out.println("\tPlaylist URL: " + e.getHtmlLink().getHref());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads a line of text from the standard input.
|
|
*
|
|
* @throws IOException If unable to read a line from the standard input.
|
|
* @return A line of text read from the standard input.
|
|
*/
|
|
private static String readLine() throws IOException {
|
|
return bufferedReader.readLine();
|
|
}
|
|
|
|
/**
|
|
* Reads a line of text from the standard input and returns the parsed
|
|
* integer representation.
|
|
*
|
|
* @throws IOException If unable to read a line from the standard input.
|
|
* @return An integer read from the standard input.
|
|
*/
|
|
private static int readInt() throws IOException {
|
|
String input = readLine();
|
|
|
|
try {
|
|
return Integer.parseInt(input);
|
|
} catch (NumberFormatException nfe) {
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Solicits the user for a video ID (hash) or tries to figure one out
|
|
* from the video's watch URL.
|
|
*
|
|
* @return String containing a video ID.
|
|
* @throws IOException If there are problems reading user input.
|
|
*/
|
|
private static String readVideoID() throws IOException {
|
|
System.out.println(
|
|
"Input a valid video ID or a watch URL (default: " + DEFAULT_VIDEO_ID
|
|
+ "):");
|
|
|
|
String input = readLine();
|
|
if (input.equals("")) {
|
|
return DEFAULT_VIDEO_ID;
|
|
}
|
|
|
|
Pattern p = Pattern.compile("http.*\\?v=([a-zA-Z0-9_\\-]+)(?:&.)*");
|
|
Matcher m = p.matcher(input);
|
|
|
|
if (m.matches()) {
|
|
input = m.group(1);
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
|
|
/**
|
|
* Displays a menu of the main activities a user can perform.
|
|
*/
|
|
private static void printMenu() {
|
|
System.out.println("\n");
|
|
System.out.println("Choose one of the following demo options:");
|
|
System.out.println("\t1) My Uploads");
|
|
System.out.println("\t2) My Playlists");
|
|
System.out.println("\t3) My Favorites");
|
|
System.out.println("\t4) Comment on a video");
|
|
System.out.println("\t5) Upload a new video");
|
|
System.out.println("\t6) Add a favorite");
|
|
System.out.println("\t7) Print user activity");
|
|
System.out.println("\t8) Print my friends' activity");
|
|
System.out.println("\t0) Exit");
|
|
System.out.println("\nEnter Number (0-8): ");
|
|
}
|
|
|
|
/**
|
|
* Shows the usage of how to run the sample from the command-line.
|
|
*/
|
|
private static void printUsage() {
|
|
System.out.println("Usage: java YouTubeWriteClient.jar "
|
|
+ " --username <user@gmail.com> " + " --password <pass> "
|
|
+ " --key <developer key>");
|
|
}
|
|
|
|
|
|
/**
|
|
* Displays a user's playlists and lets the user manipulate them.
|
|
*
|
|
* @param service A YouTubeService object.
|
|
* @throws IOExcep
|
|
* tion Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void showPlaylists(YouTubeService service) throws IOException,
|
|
ServiceException {
|
|
doPlaylistFeedOperation(service, PlaylistOperation.VIEW);
|
|
|
|
while (true) {
|
|
System.out.println("\nWhat would you like to do?");
|
|
System.out.println("\t1) Create a new playlist");
|
|
System.out.println("\t2) Add a video to a playlist");
|
|
System.out.println("\t3) Print playlists");
|
|
System.out.println("\t4) Print playlist contents");
|
|
System.out.println("\t0) Back to main menu");
|
|
System.out.println("\nEnter Number (0-5): ");
|
|
|
|
int choice = readInt();
|
|
|
|
switch (choice) {
|
|
case 1:
|
|
doPlaylistFeedOperation(service, PlaylistOperation.CREATE);
|
|
break;
|
|
case 2:
|
|
doPlaylistFeedOperation(service, PlaylistOperation.ADD);
|
|
break;
|
|
case 3:
|
|
doPlaylistFeedOperation(service, PlaylistOperation.VIEW);
|
|
break;
|
|
case 4:
|
|
doPlaylistFeedOperation(service, PlaylistOperation.LIST);
|
|
break;
|
|
case 0:
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows a user's favorites and lets the user manipulate them.
|
|
*
|
|
* @param service a YouTubeService object.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void showFavorites(YouTubeService service) throws IOException,
|
|
ServiceException {
|
|
printVideoFeed(service, USER_FEED_PREFIX + DEFAULT_USER
|
|
+ FRIENDS_ACTIVITY_FEED_SUFFIX);
|
|
}
|
|
|
|
/**
|
|
* Shows a user's activity feed.
|
|
*
|
|
* @param service a YouTubeService object.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void showActivity(YouTubeService service) throws IOException,
|
|
ServiceException {
|
|
|
|
System.out.println("Type in a comma separated list of YouTube usernames:");
|
|
|
|
String users = readLine();
|
|
printActivityFeed(service, ACTIVITY_FEED_PREFIX + "?author=" + users);
|
|
}
|
|
|
|
/**
|
|
* Shows a user's friends' activity feed.
|
|
*
|
|
* @param service a YouTubeService object.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void showFriendsActivity(YouTubeService service) throws IOException,
|
|
ServiceException {
|
|
printActivityFeed(service, USER_FEED_PREFIX + DEFAULT_USER
|
|
+ FRIENDS_ACTIVITY_FEED_SUFFIX);
|
|
}
|
|
|
|
/**
|
|
* Demonstrates adding a comment to a video.
|
|
*
|
|
* @param service The YouTubeService object controlling the connection to the
|
|
* server.
|
|
* @throws IOException Error sending request or reading the response.
|
|
*/
|
|
|
|
private static void addComment(YouTubeService service) throws IOException {
|
|
System.out.println("First, choose a video you want to comment on.");
|
|
String videoID = readVideoID();
|
|
|
|
System.out.println("Okay, adding a comment to: " + videoID);
|
|
|
|
URL entryUrl = new URL("http://gdata.youtube.com/feeds/api/videos/"
|
|
+ videoID);
|
|
|
|
VideoEntry videoEntry = null;
|
|
try {
|
|
videoEntry = service.getEntry(entryUrl, VideoEntry.class);
|
|
} catch (ServiceException se) {
|
|
// an invalid video ID was used.
|
|
}
|
|
|
|
if (videoEntry == null) {
|
|
System.out.println("Sorry, the video ID you entered was not valid.\n");
|
|
return;
|
|
}
|
|
|
|
System.out.println("Enter your comment: ");
|
|
|
|
String input = readLine();
|
|
|
|
String commentUrl = videoEntry.getComments().getFeedLink().getHref();
|
|
|
|
CommentEntry newComment = new CommentEntry();
|
|
newComment.setContent(new PlainTextConstruct(input));
|
|
|
|
try {
|
|
service.insert(new URL(commentUrl), newComment);
|
|
} catch (ServiceException se) {
|
|
System.out.println("There was an error adding your comment.\n");
|
|
return;
|
|
}
|
|
|
|
System.out.println("Comment added successfully!\n");
|
|
}
|
|
|
|
/**
|
|
* Uploads a new video to YouTube.
|
|
*
|
|
* @param service An authenticated YouTubeService object.
|
|
* @throws IOException Problems reading user input.
|
|
*/
|
|
private static void uploadVideo(YouTubeService service) throws IOException {
|
|
System.out.println("First, type in the path to the movie file:");
|
|
|
|
|
|
File videoFile = new File(readLine());
|
|
|
|
if (!videoFile.exists()) {
|
|
System.out.println("Sorry, that video doesn't exist.");
|
|
return;
|
|
}
|
|
|
|
System.out.println(
|
|
"What is the MIME type of this file? (ex. 'video/quicktime' for .mov)");
|
|
|
|
String mimeType = readLine();
|
|
|
|
System.out.println("What should I call this video?");
|
|
String videoTitle = readLine();
|
|
|
|
VideoEntry newEntry = new VideoEntry();
|
|
|
|
YouTubeMediaGroup mg = newEntry.getOrCreateMediaGroup();
|
|
|
|
mg.addCategory(new MediaCategory(YouTubeNamespace.CATEGORY_SCHEME, "Tech"));
|
|
mg.setTitle(new MediaTitle());
|
|
mg.getTitle().setPlainTextContent(videoTitle);
|
|
mg.setKeywords(new MediaKeywords());
|
|
mg.getKeywords().addKeyword("gdata-test");
|
|
mg.setDescription(new MediaDescription());
|
|
mg.getDescription().setPlainTextContent(videoTitle);
|
|
MediaFileSource ms = new MediaFileSource(videoFile, mimeType);
|
|
newEntry.setMediaSource(ms);
|
|
|
|
try {
|
|
service.insert(new URL(VIDEO_UPLOAD_FEED), newEntry);
|
|
} catch (ServiceException se) {
|
|
System.out.println("Sorry, your upload was invalid:");
|
|
System.out.println(se.getResponseBody());
|
|
return;
|
|
}
|
|
|
|
System.out.println("Video uploaded successfully!");
|
|
}
|
|
|
|
/**
|
|
* Adds a video as a favorite.
|
|
*
|
|
* @param service An authenticated YouTubeService object.
|
|
* @throws IOException Problems reading user input.
|
|
*/
|
|
private static void addFavorite(YouTubeService service) throws IOException {
|
|
System.out.println("First, choose a video to favorite.");
|
|
String videoID = readVideoID();
|
|
|
|
System.out.println("Okay, favoriting: " + videoID);
|
|
|
|
URL entryUrl = new URL("http://gdata.youtube.com/feeds/api/videos/"
|
|
+ videoID);
|
|
|
|
VideoEntry videoEntry = null;
|
|
try {
|
|
videoEntry = service.getEntry(entryUrl, VideoEntry.class);
|
|
} catch (ServiceException se) {
|
|
// an invalid video ID was used.
|
|
}
|
|
|
|
if (videoEntry == null) {
|
|
System.out.println("Sorry, the video ID you entered was not valid.\n");
|
|
return;
|
|
}
|
|
|
|
URL feedUrl = new URL(USER_FEED_PREFIX + DEFAULT_USER
|
|
+ FAVORITES_FEED_SUFFIX);
|
|
|
|
try {
|
|
service.insert(feedUrl, videoEntry);
|
|
} catch (ServiceException e) {
|
|
System.out.println("Error adding favorite.");
|
|
return;
|
|
}
|
|
|
|
System.out.println("Video favorited.");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Adds a video to a particular playlist.
|
|
*
|
|
* @param service An authenticated YouTubeService object.
|
|
* @param entry The PlaylistLinkEntry describing the playlist
|
|
* to add the video to.
|
|
* @throws IOException Error reading user input.
|
|
*/
|
|
private static void addPlaylistVideo(YouTubeService service,
|
|
PlaylistLinkEntry entry) throws IOException {
|
|
System.out.println("Choose a video to add to this playlist.");
|
|
|
|
String videoID = readVideoID();
|
|
|
|
System.out.println("Okay, adding this video: " + videoID);
|
|
|
|
URL entryUrl = new URL("http://gdata.youtube.com/feeds/api/videos/"
|
|
+ videoID);
|
|
|
|
VideoEntry videoEntry = null;
|
|
try {
|
|
videoEntry = service.getEntry(entryUrl, VideoEntry.class);
|
|
} catch (ServiceException se) {
|
|
// an invalid video ID was used.
|
|
}
|
|
|
|
if (videoEntry == null) {
|
|
System.out.println("Sorry, the video ID you entered was not valid.\n");
|
|
return;
|
|
}
|
|
|
|
String playlistUrl = entry.getFeedUrl();
|
|
PlaylistEntry playlistEntry = new PlaylistEntry(videoEntry);
|
|
|
|
try {
|
|
service.insert(new URL(playlistUrl), playlistEntry);
|
|
} catch (ServiceException e) {
|
|
System.out.println("Error adding vide to playlist");
|
|
return;
|
|
}
|
|
|
|
System.out.println("Video added to the playlist!");
|
|
}
|
|
|
|
|
|
/**
|
|
* Prints the user's uploaded videos.
|
|
*
|
|
* @param service An authenticated YouTubeService object.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void printUploads(YouTubeService service) throws IOException,
|
|
ServiceException {
|
|
|
|
printVideoFeed(service, USER_FEED_PREFIX + DEFAULT_USER
|
|
+ UPLOADS_FEED_SUFFIX);
|
|
}
|
|
|
|
/**
|
|
* Fetches a feed known to be a VideoFeed, printing each VideoEntry with in a
|
|
* numbered list, optionally prompting the user for the number of a video
|
|
* entry which should have its comments and responses printed.
|
|
*
|
|
* @param service An authenticated YouTubeService object
|
|
* @param feedUrl The url of the video feed to print.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void printVideoFeed(YouTubeService service, String feedUrl)
|
|
throws IOException, ServiceException {
|
|
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
|
|
String title = videoFeed.getTitle().getPlainText();
|
|
|
|
printUnderlined(title);
|
|
List<VideoEntry> videoEntries = videoFeed.getEntries();
|
|
if (videoEntries.size() == 0) {
|
|
System.out.println("This feed contains no entries.");
|
|
return;
|
|
}
|
|
int count = 1;
|
|
for (VideoEntry entry : videoEntries) {
|
|
System.out.println("(Video #" + String.valueOf(count) + ")");
|
|
printVideoEntry(entry);
|
|
count++;
|
|
}
|
|
|
|
System.out.println();
|
|
}
|
|
|
|
/**
|
|
* Fetches a feed of activities and prints information about them.
|
|
*
|
|
* @param service An authenticated YouTubeService object
|
|
* @param feedUrl The url of the video feed to print.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void printActivityFeed(YouTubeService service, String feedUrl)
|
|
throws IOException, ServiceException {
|
|
UserEventFeed activityFeed = service.getFeed(new URL(feedUrl),
|
|
UserEventFeed.class);
|
|
String title = activityFeed.getTitle().getPlainText();
|
|
|
|
printUnderlined(title);
|
|
if (activityFeed.getEntries().size() == 0) {
|
|
System.out.println("This feed contains no entries.");
|
|
return;
|
|
}
|
|
for (UserEventEntry entry : activityFeed.getEntries()) {
|
|
String user = entry.getAuthors().get(0).getName();
|
|
if(entry.getUserEventType() == UserEventEntry.Type.VIDEO_UPLOADED) {
|
|
System.out.println(user + " uploaded a video " + entry.getVideoId());
|
|
}
|
|
else if(entry.getUserEventType() == UserEventEntry.Type.VIDEO_RATED) {
|
|
System.out.println(user + " rated a video " + entry.getVideoId() +
|
|
" " + entry.getRating().getValue() + " stars");
|
|
}
|
|
else if(entry.getUserEventType() == UserEventEntry.Type.VIDEO_FAVORITED) {
|
|
System.out.println(user + " favorited a video " + entry.getVideoId());
|
|
}
|
|
else if(entry.getUserEventType() == UserEventEntry.Type.VIDEO_SHARED) {
|
|
System.out.println(user + " shared a video " + entry.getVideoId());
|
|
}
|
|
else if(entry.getUserEventType() == UserEventEntry.Type.VIDEO_COMMENTED) {
|
|
System.out.println(user + " commented on video " + entry.getVideoId());
|
|
}
|
|
else if(entry.getUserEventType()
|
|
== UserEventEntry.Type.USER_SUBSCRIPTION_ADDED) {
|
|
System.out.println(user + " subscribed to the channel of " +
|
|
entry.getUsername());
|
|
}
|
|
else if(entry.getUserEventType() == UserEventEntry.Type.FRIEND_ADDED) {
|
|
System.out.println(user + " friended " + entry.getUsername());
|
|
}
|
|
}
|
|
|
|
System.out.println();
|
|
}
|
|
|
|
/**
|
|
* Performs a given operation on the user's playlists feed
|
|
*
|
|
* @param service An authenticated YouTubeService object.
|
|
* @param op The operation to perform on the playlists feed.
|
|
* @throws IOException Error sending request or reading the feed.
|
|
* @throws ServiceException If the service is unable to handle the request.
|
|
*/
|
|
private static void doPlaylistFeedOperation(YouTubeService service,
|
|
PlaylistOperation op) throws IOException, ServiceException {
|
|
String feedUrl = USER_FEED_PREFIX + DEFAULT_USER + PLAYLISTS_FEED_SUFFIX;
|
|
|
|
|
|
if (op == PlaylistOperation.CREATE) {
|
|
System.out.println("Creating new playlist!");
|
|
System.out.println("Enter a title: ");
|
|
String title = readLine();
|
|
System.out.println("Enter a description: ");
|
|
String description = readLine();
|
|
|
|
PlaylistLinkEntry newEntry = new PlaylistLinkEntry();
|
|
newEntry.setTitle(new PlainTextConstruct(title));
|
|
newEntry.setSummary(
|
|
TextConstruct.create(TextConstruct.Type.TEXT, description, null));
|
|
|
|
service.insert(new URL(feedUrl), newEntry);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
PlaylistLinkFeed playlistLinkFeed = service.getFeed(new URL(feedUrl),
|
|
PlaylistLinkFeed.class);
|
|
String title = playlistLinkFeed.getTitle().getPlainText();
|
|
|
|
printUnderlined(title);
|
|
List<PlaylistLinkEntry> playlistEntries = playlistLinkFeed.getEntries();
|
|
int count = 1;
|
|
for (PlaylistLinkEntry pe : playlistEntries) {
|
|
printPlaylistEntry("(Playlist #" + count + ")", pe, false);
|
|
count++;
|
|
}
|
|
|
|
if (op == PlaylistOperation.LIST) {
|
|
System.out.printf("\nWhich playlist do you want to see? (1-%d): \n",
|
|
count - 1);
|
|
int whichVideo = readInt();
|
|
if (whichVideo < 1 || whichVideo > count - 1) {
|
|
System.out.println("Invalid choice.");
|
|
} else {
|
|
printPlaylistEntry("", playlistEntries.get(whichVideo - 1), true);
|
|
}
|
|
}
|
|
|
|
if (op == PlaylistOperation.ADD) {
|
|
System.out.printf("\nWhich playlist do you want to add to? (1-%d): \n",
|
|
count - 1);
|
|
int whichVideo = readInt();
|
|
if (whichVideo < 1 || whichVideo > count - 1) {
|
|
System.out.println("Invalid choice.");
|
|
} else {
|
|
addPlaylistVideo(service, playlistEntries.get(whichVideo - 1));
|
|
}
|
|
}
|
|
|
|
System.out.println();
|
|
}
|
|
|
|
/**
|
|
* YouTubeWriteClient is a sample command line application that
|
|
* demonstrates many features of the YouTube Data API using the Java Client
|
|
* library.
|
|
*
|
|
* This sample demonstrates both upload and write activities in the API.
|
|
*
|
|
* @param args Used to pass the username and password of a test account.
|
|
*/
|
|
public static void main(String[] args) {
|
|
SimpleCommandLineParser parser = new SimpleCommandLineParser(args);
|
|
String username = parser.getValue("username", "user", "u");
|
|
String password = parser.getValue("password", "pass", "p");
|
|
String developerKey = parser.getValue("key", "k");
|
|
boolean help = parser.containsKey("help", "h");
|
|
|
|
if (help || username == null || password == null || developerKey == null) {
|
|
printUsage();
|
|
System.exit(1);
|
|
}
|
|
|
|
YouTubeService service = new YouTubeService("gdataSample-YouTubeAuth-1",
|
|
developerKey);
|
|
|
|
try {
|
|
service.setUserCredentials(username, password);
|
|
} catch (AuthenticationException e) {
|
|
System.out.println("Invalid login credentials.");
|
|
System.exit(1);
|
|
}
|
|
|
|
while (true) {
|
|
try {
|
|
|
|
printMenu();
|
|
int choice = readInt();
|
|
|
|
switch (choice) {
|
|
case 1:
|
|
// Prints out the user's uploaded videos
|
|
printUploads(service);
|
|
break;
|
|
case 2:
|
|
// Accesses the user's playlists
|
|
showPlaylists(service);
|
|
break;
|
|
case 3:
|
|
// Accesses the user's favorites
|
|
showFavorites(service);
|
|
break;
|
|
case 4:
|
|
// Adds a comment to a video
|
|
addComment(service);
|
|
break;
|
|
case 5:
|
|
// Uploads a new video to YouTube
|
|
uploadVideo(service);
|
|
break;
|
|
case 6:
|
|
// adds a new favorite video
|
|
addFavorite(service);
|
|
break;
|
|
case 7:
|
|
// print the user's activities
|
|
showActivity(service);
|
|
break;
|
|
case 8:
|
|
// print the user's friends' activities
|
|
showFriendsActivity(service);
|
|
break;
|
|
case 0:
|
|
default:
|
|
System.out.println("Bye!");
|
|
System.exit(0);
|
|
}
|
|
} catch (IOException e) {
|
|
// Communications error
|
|
System.err.println(
|
|
"There was a problem communicating with the service.");
|
|
e.printStackTrace();
|
|
} catch (ServiceException e) {
|
|
// Server side error
|
|
System.err.println("The server had a problem handling your request.");
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|