El API de datos de YouTube permite a las aplicaciones cliente ver contenido de YouTube como feeds del API de datos de Google. La aplicación cliente puede utilizar feeds del API de datos de YouTube para extraer feeds de vídeos, comentarios, respuestas y listas de reproducción, así como consultas de vídeos que coincidan con unos criterios determinados. El API también permite realizar solicitudes autenticadas para modificar esta información y subir nuevo contenido de vídeo al sitio.
Además de ofrecer información sobre las funciones del API de datos de YouTube, este documento contiene ejemplos de formas de interactuar con el API mediante la biblioteca cliente Java. Si deseas obtener ayuda sobre cómo configurar la biblioteca cliente Java, consulta la Guía de introducción.
Si quieres obtener más información sobre el protocolo que utiliza la biblioteca cliente Java para interactuar con YouTube, consulta la Guía de protocolo.
Este documento está destinado a programadores que deseen crear aplicaciones cliente que puedan interactuar con YouTube mediante la biblioteca cliente Java. Contiene una serie de ejemplos de interacciones con API de datos básicas.
Para obtener información de referencia sobre el API de datos de YouTube, consulta la guía de referencia.
En este documento se supone que comprendes los conceptos básicos del protocolo de las API de datos de Google y que conoces el lenguaje Java.
Para obtener información de referencia sobre los métodos y las clases Java, consulta la guía de referencia de Javadoc de la biblioteca cliente.
Este documento consta de las siguientes secciones:
En la sección Autenticación se describen los dos métodos de autenticación disponibles para asociar operaciones de API a la cuenta de un usuario específico. En esta sección también se describen las diferencias entre el sistema de autenticación del API de datos de YouTube y otras API de Google Data. A lo largo de este documento, las explicaciones de funciones de API específicas indicarán claramente si la función requiere la autenticación del usuario.
En la sección Entradas y feeds de vídeos se proporciona un ejemplo de respuesta de API y se explica cómo extraer información sobre un vídeo de una lista de vídeos o un conjunto de resultados de búsqueda. En esta sección también se explica cómo acceder a los metadatos de una entrada de vídeo específica.
En la sección Recuperación y búsqueda de vídeos se explica cómo extraer una lista de vídeos. El API de datos de YouTube define varios tipos de feeds estándar, como los vídeos más valorados o los más vistos. En esta sección también se explica cómo recuperar una lista de vídeos subidos por un usuario específico o una lista de vídeos relacionados. Finalmente, en esta sección también se explica cómo utilizar el API para que los usuarios puedan realizar búsquedas en la biblioteca de vídeos de YouTube de vídeos que coincidan con categorías o términos de búsqueda específicos.
En la sección Subida de vídeos se explican brevemente dos formas de permitir que los usuarios suban vídeos a YouTube desde tu aplicación. En esta sección también se explica cómo permitir a los usuarios eliminar vídeos de tu aplicación. En la Guía de protocolo se explican estas soluciones con más detalle. Es posible que debas dejar a los usuarios subir vídeos para utilizar otras funciones del API. Por ejemplo, el API proporciona una función para añadir una respuesta en vídeo al vídeo. Si el usuario está subiendo un vídeo nuevo como una respuesta en vídeo, la aplicación cliente deberá seguir las instrucciones de subida de vídeos para añadir el vídeo a YouTube antes de identificar el vídeo nuevo como una respuesta.
En la sección Actualización y eliminación de vídeos se describe la forma de utilizar el API para actualizar información sobre un vídeo de YouTube. También se explica cómo eliminar un vídeo con el API.
En la sección Uso de las funciones de la comunidad se describen funciones del API que permiten la interacción de los usuarios con los vídeos de YouTube. Estas funciones definen solicitudes de publicación de puntuaciones, comentarios, respuestas en vídeo o reclamaciones contra vídeos subidos al sitio. También puedes utilizar el API para recuperar listas de comentarios sobre vídeos o para recuperar o eliminar respuestas en vídeo.
En la sección Almacenamiento y recopilación de vídeos se explica cómo utilizar el API para crear, actualizar y acceder a vídeos favoritos, listas de reproducción de vídeos y suscripciones a canales de YouTube.
En la sección Habilitación de la interacción del usuario se explica cómo utilizar el API para la recuperación y actualización de perfiles de usuario. También se explica cómo recuperar, añadir, actualizar y eliminar contactos del usuario, así como la forma de recuperar, enviar y eliminar mensajes.
Si deseas obtener ayuda sobre cómo configurar la biblioteca cliente Java, consulta la Guía de introducción. Para utilizar la biblioteca cliente Java debes ejecutar Java 1.5. Una vez que hayas descargado la biblioteca cliente, encontrarás las clases que necesitas para comenzar a utilizar los archivos java/lib/gdata-client-1.0.jar y java/lib/gdata-youtube-1.0.jar.
Hay disponible una copia de trabajo completa del código de ejemplo en la distribución, en gdata/java/sample/youtube/YouTubeClient.java. En el archivo README.txt del mismo directorio también se incluyen instrucciones de ejecución y creación. El ejemplo realiza una serie de operaciones en los feeds del API de datos de YouTube para mostrar cómo se utiliza el API. Si deseas ver una lista de las operaciones realizadas, consulta el método main de la aplicación cliente de ejemplo.
Para compilar los fragmentos de ejemplo que se proporcionan en este documento en tu propio código, deberás utilizar las siguientes instrucciones de importación:
import com.google.gdata.client.*; import com.google.gdata.client.youtube.*; import com.google.gdata.data.*; import com.google.gdata.data.geo.impl.*; import com.google.gdata.data.media.*; import com.google.gdata.data.media.mediarss.*; import com.google.gdata.data.youtube.*; import com.google.gdata.data.extensions.*; import com.google.gdata.util.*; import java.io.IOException; import java.io.File; import java.net.URL;
La biblioteca cliente Java se puede utilizar para trabajar con feeds públicos o privados. Los feeds públicos son feeds de sólo lectura, pero no requieren autenticación. Es posible acceder a algunos feeds de YouTube sin autenticarse, pero todos los cambios realizados en los feeds requieren autenticación. Esto se puede hacer a través del método de autenticación ClientLogin con nombre de usuario y contraseña o del método de autenticación AuthSub a través de proxy.
Para poder realizar cualquier operación de escritura o subida a través de un API de YouTube, deberás crear una instancia de un objeto YouTubeService con tu clave de desarrollador y tu ID de cliente tal y como se indica a continuación:
YouTubeService service = new YouTubeService(clientID, developer_key);
Podrás solicitar una clave de desarrollador si todavía no la tienes. A través de esta página también podrás obtener una ID de cliente.
Si deseas obtener más información sobre AuthSub y ClientLog, consulta la documentación sobre autenticación.
Para obtener un token de AuthSub para un usuario y un servicio concretos, tu aplicación deberá redirigir al usuario a la dirección URL de AuthSubRequest, que le pedirá que inicie sesión en su cuenta de Google.
Si deseas obtener más información sobre la dirección URL de AuthSubRequest, consulta la documentación de AuthSub.
Si deseas construir una URL de AuthSubRequest para tu aplicación, ejecuta una llamada a la biblioteca cliente Java tal y como se indica a continuación:
| 
String requestUrl =
AuthSubUtil.getRequestUrl("http://www.example.com/RetrieveToken",
"http://gdata.youtube.com",
false,
true);
El método getRequestUrl utiliza varios parámetros (que coinciden con los parámetros de consulta utilizados por el controlador de AuthSubRequest): la dirección URL "next" (que es la dirección URL a la que se redirige Google cuando el usuario inicia sesión en su cuenta y obtiene acceso); el parámetro "scope" (mencionado en la sección anterior); y dos valores booleanos, uno que indica si el token se va a utilizar o no en el modo registrado y otro que indica si el token se va a intercambiar o no posteriormente por un token de sesión. En el ejemplo anterior se muestra una llamada en modo no registrado (el primer valor booleano es false) de un token que posteriormente se va a intercambiar por un token de sesión (el segundo valor booleano es true); ajusta los valores booleanos de la forma más adecuada para tu aplicación.
Tras construir la dirección URL "next", la aplicación de servidor podrá utilizarla de varias formas para enviar al usuario al controlador de AuthSubRequest. El método más habitual es mostrar una página que indique al usuario que debe seleccionar un enlace para permitir a tu aplicación acceder a tu cuenta de Google; a continuación, debes vincular la URL de solicitud al enlace. Por ejemplo, puedes mostrar la siguiente cadena en una página:
String suggestAuthorization = "<p>MyApp needs access to your YouTube account. To authorize MyApp to access your account, <a href=\"" + requestUrl + "\">log in to your account</a>.</p>";
El usuario selecciona el enlace a la página de AuthSub de Google e inicia sesión. A continuación, el sistema AuthSub redirigirá al usuario de nuevo a tu aplicación a través de la URL "next" que has proporcionado.
Cuando Google redirige a un usuario de nuevo a tu aplicación, el token se añade a la URL "next" como parámetro de consulta. Por lo tanto, en el caso de la URL "next" anterior, una vez que el usuario inicia sesión, Google le redirige a una URL del tipo http://www.example.com/RetrieveToken?token=DQAADKEDE.
El navegador del usuario es redirigido a dicha URL. A continuación, el servlet que utiliza dicha URL deberá examinar los parámetros de consulta de la URL solicitada para recuperar el token establecido por Google. Por ejemplo, el servlet puede recuperar el token a partir de la URL mediante la función de conveniencia getTokenFromReply de la biblioteca cliente Java:
String onetimeUseToken = AuthSubUtil.getTokenFromReply(httpServletRequest.getQueryString());
Tu aplicación permite reconocer qué usuarios están autenticados en los servidores de Google a través de AuthSub. Para ello, configura una cookie de autenticación y, a continuación, haz que los usuarios hagan clic en el enlace AuthSub y consulta esta cookie una vez que el usuario se haya autenticado y haya vuelto a tu página web.
El token que se obtiene con getTokenFromReply siempre va a ser un token de un solo uso. Este token se puede intercambiar por un token de sesión a través de la URL de AuthSubSessionToken tal y como se describe en la documentación de AuthSub. Tu aplicación puede realizar este intercambio a través de la biblioteca cliente Java de la forma siguiente:
String sessionToken = AuthSubUtil.exchangeForSessionToken(onetimeUseToken,
null);
Transfiere tu token de un solo uso al método exchangeForSessionToken junto con null (para el modo registrado) o una clave privada (para el modo no registrado), y la interfaz de AuthSub mostrará un token de sesión. Si deseas obtener más información sobre aplicaciones registradas y claves privadas, consulta la documentación de AuthSub.
El token de sesión se puede utilizar para autenticar solicitudes en el servidor si se coloca el token en el encabezado de autenticación tal y como se describe en la documentación de AuthSub. Para indicar a la biblioteca cliente Java que envíe automáticamente la autorización al encabezado (incluido el token de sesión) con cada solicitud, debes ejecutar una llamada al método setAuthSubToken del objeto YouTubeService:
YouTubeService service = new YouTubeService(clientID, developer_key); service.setAuthSubToken(sessionToken, null);
Si estás utilizando el modo registrado, deberás introducir tu clave privada en vez de null. Ten en cuenta que tendrás que enviar una ID de cliente y una clave de desarrollador al creador de YouTubeService.
Una vez que hayas ejecutado una llamada a setAuthSubToken, podrás utilizar las llamadas a la biblioteca de cliente Google Data estándar para interactuar con el servicio, sin tener en cuenta el token.
Si deseas recuperar información sobre los parámetros del token, puedes enviarlo al método getTokenInfo, que devolverá un conjunto de pares nombre-valor con información sobre el token. Por ejemplo:
Map<String, String> info = AuthSubUtil.getTokenInfo(sessionToken, null);
Los tokens de sesión de AuthSub no caducan; la aplicación cliente podrá almacenarlos el tiempo que desee.
Cuando la aplicación cliente haya terminado de utilizar el token de sesión, podrá revocarlo a través del identificador de AuthSubRevokeToken tal y como se describe en la documentación de AuthSub.
Por ejemplo, si deseas administrar tokens de una forma tradicional similar a las sesiones, la aplicación cliente podrá obtener un token al principio de la sesión de un usuario y revocarlo al final de la misma.
Para revocar un token a través de la biblioteca cliente Java, debes ejecutar una llamada a revokeToken. Incluye tu clave privada para el modo registrado, o bien null para el otro modo. Por ejemplo:
AuthSubUtil.revokeToken(sessionToken, null);
Para utilizar ClientLogin (también denominado "autenticación para aplicaciones instaladas"), debes ejecutar el método setUserCredentials de YouTubeService, especificando la ID y la contraseña del usuario en cuyo nombre la aplicación cliente está enviando la solicitud. Por ejemplo:
YouTubeService service = new YouTubeService(clientID, developer_key);
service.setUserCredentials("jo@gmail.com", "password");
Ten en cuenta que también tendrás que proporcionar una ID de cliente y una clave de desarrollador para el objeto YouTubeService si deseas realizar operaciones de escritura y recuperar feeds a través del API de YouTube. Podrás solicitar una clave de desarrollador si todavía no la tienes.
Si deseas obtener más información sobre los sistemas de autenticación, consulta la documentación de Autenticación de cuentas de Google.
El API de datos de YouTube proporciona varios feeds de vídeos que representan listas de vídeos, como favoritos, suscripciones, subidas y feeds estándar. La URL de cada feed aparece documentada en la guía de referencia.
Muchos feeds del API de YouTube consisten en entradas de vídeos. Estos feeds se pueden configurar fácilmente como objetos VideoFeed (que contengan objetos VideoEntry). Cada entrada de vídeo corresponderá a un único vídeo de YouTube y contendrá información sobre el mismo.
El sistema básico de recuperación de una lista de vídeos consiste en construir una URL de acceso a un feed de vídeos y procesar a continuación las entradas de una en una, como se ha hecho en el siguiente ejemplo de código:
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
En la sección Recuperación y búsqueda de vídeos se describen muchas URL de feeds comunes y se explica cómo recuperar diversos feeds de vídeos.
Es posible recuperar la información de una entrada de vídeo específica si conoces su enlace propio, que es un elemento link incluido en la entrada de Atom que describe al vídeo que tiene el atributo rel establecido en self. El enlace propio es una URL que está basada en la ID de vídeo:
http://gdata.youtube.com/feeds/api/videos/videoID
En el caso de las entradas de vídeos, el enlace propio también es idéntico a la ID de entrada proporcionada en el elemento de id.
El siguiente código permite recuperar una entrada de vídeo (VideoEntry) correspondiente a un vídeo de YouTube:
String videoEntryUrl = "http://gdata.youtube.com/feeds/api/videos/ADos_xW4_J0";
VideoEntry videoEntry = service.getEntry(new URL(videoEntryUrl), VideoEntry.class);
System.out.println("Title: " + videoEntry.getTitle().getPlainText());
System.out.println(videoEntry.getMediaGroup().getDescription().getPlainTextContent());
Un objeto VideoEntry cuenta con una gran cantidad de metadatos que se pueden recuperar (por ejemplo, la duración del vídeo, las URL del reproductor y las miniaturas). El siguiente código muestra cómo acceder a parte de esta información. Si deseas ver una lista completa de posibles elementos XML, consulta la guía de referencia.
System.out.println("Title: " + videoEntry.getTitle().getPlainText());
YouTubeMediaGroup mediaGroup = videoEntry.getMediaGroup();
System.out.println("Description: " + mediaGroup.getDescription().getPlainTextContent());
MediaPlayer mediaPlayer = mediaGroup.getPlayer();
System.out.println("Web Player URL: " + mediaPlayer.getUrl());
MediaKeywords keywords = mediaGroup.getKeywords();
System.out.print("Keywords: ");
for(String keyword : keywords.getKeywords()) {
System.out.print(keyword + ",");
}
GeoRssWhere location = videoEntry.getLocation();
if(location != null) {
System.out.println("Latitude: " + location.getLatitude());
System.out.println("Longitude: " + location.getLongitude());
}
Rating rating = videoEntry.getRating();
if(rating != null) {
System.out.println("Average rating: " + rating.getAverage());
}
YtStatistics stats = videoEntry.getStatistics();
if(stats != null ) {
System.out.println("View count: " + stats.getViewCount());
}
System.out.println();
System.out.println("\tThumbnails:");
for(MediaThumbnail mediaThumbnail : mediaGroup.getThumbnails()) {
System.out.println("\t\tThumbnail URL: " + mediaThumbnail.getUrl());
System.out.println("\t\tThumbnail Time Index: " +
mediaThumbnail.getTime());
System.out.println();
}
System.out.println("\tMedia:");
for(YouTubeMediaContent mediaContent : mediaGroup.getYouTubeContents()) {
System.out.println("\t\tMedia Location: "+ mediaContent.getUrl());
System.out.println("\t\tMedia Type: "+ mediaContent.getType());
System.out.println("\t\tDuration: " + mediaContent.getDuration());
System.out.println();
}
El API de datos de YouTube proporciona actualmente feeds estándar de vídeos para diversos criterios. Estos feeds corresponden a todo el sitio, no a usuarios específicos. Las direcciones URL de todos los feeds estándar empiezan por http://gdata.youtube.com/feeds/api/standardfeeds/, seguido por el identificador del feed. A continuación se muestra una tabla de feeds disponibles:
| Nombre del feed | Identificador del feed |
|---|---|
| Más vistos | most_viewed |
| Más valorados | top_rated |
| Últimos destacados | recently_featured |
| Ver en móvil | watch_on_mobile |
| Más comentados | most_discussed |
| Superfavoritos | top_favorites |
| Más enlazados | most_linked |
| Con más respuestas | most_responded |
| Más recientes | most_recent |
También puedes recuperar feeds estándar específicos de un entorno local especificando una ID de entorno local con el formato: http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. Por ejemplo, los vídeos más vistos en Japón serían: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_viewed.
El ejemplo anterior muestra los títulos y la descripción de los vídeos más vistos del sitio:
String feedUrl = "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed";
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
Todos los usuarios de YouTube tienen un feed de vídeos asociado correspondiente a los
vídeos que han subido a /feeds/api/users/userID/uploads.
El código siguiente muestra los títulos y las descripciones de los vídeos que ha subido el usuario de "GoogleDevelopers".
String feedUrl = "http://gdata.youtube.com/feeds/api/users/GoogleDevelopers/uploads";
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
Puedes utilizar el nombre de usuario "predeterminado" para hacer referencia al usuario autenticado actualmente. Por lo tanto, para recuperar vídeos para el usuario autenticado, deberás utilizar la URL http://gdata.youtube.com/feeds/api/users/default/uploads.
Cada entrada de vídeo de un feed de vídeos tiene un enlace a otro feed de vídeos que incluye todos los vídeos relacionados, según lo determine YouTube. El código siguiente muestra cómo recuperar y mostrar información sobre los vídeos relacionados de una entrada de vídeo (VideoEntry) en particular.
if (videoEntry.getRelatedVideosLink() != null) {
String feedUrl = videoEntry.getRelatedVideosLink().getHref();
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
}
El API de datos de YouTube permite solicitar un conjunto de entradas que coincidan con los criterios especificados (por ejemplo, entradas de vídeos publicadas por un determinado autor o con una palabra clave en concreto). Para hacerlo, deberás crear un objeto de YouTubeQuery y transmitirlo al método YouTubeService.query().
Por ejemplo, para realizar una consulta por palabra clave en la que los resultados aparezcan ordenados por volumen de reproducciones y que incluya vídeos de acceso restringido, deberás utilizar los métodos setVideoQuery, setOrderBy y setIncludeRacy del objeto YouTubeQuery. El siguiente fragmento de código muestra los títulos y resúmenes de todos los vídeos que coinciden con la palabra clave "puppy", incluidos los vídeos de acceso restringido ordenados por volumen de reproducciones:
YouTubeQuery query = new YouTubeQuery(new URL("http://gdata.youtube.com/feeds/api/videos"));
// order results by the number of views (most viewed first)
query.setOrderBy(YouTubeQuery.OrderBy.VIEW_COUNT);
// do not exclude restricted content from the search results
query.setIncludeRacy(true);
//search for puppies!
query.setVideoQuery("puppy");
VideoFeed videoFeed = service.query(query, VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
La clase Query y algunas subclases como YouTubeQuery intervienen en la construcción de URL de feeds. Por ejemplo, YouTubeQuery, que aparece anteriormente, construye una URL equivalente a la siguiente:
http://gdata.youtube.com/feeds/api/videos?vq=keyword&racy=include&orderby=viewCount
Éstos son algunos de los métodos YouTubeQuery más utilizados para el establecimiento de parámetros de búsqueda:
setAuthorsetMaxResultssetStartIndexsetVideoQuerysetIncludeRacysetFormatsetOrderByRELEVANCE), volumen de reproducciones (VIEW_COUNT), fecha de actualización (UPDATED) o puntuación (RATING).setTimeTODAY), esta semana (THIS_WEEK), este mes (THIS_MONTH) o siempre (ALL_TIME).Puedes obtener más información sobre los parámetros de consulta en la Guía de referencia del API de datos de YouTube y en la Guía de referencia de las API de datos de Google.
Los resultados de la búsqueda se pueden restringir de forma que sólo se muestren los vídeos que coincidan con un determinado conjunto de categorías y palabras clave. En la guía de referencia se explica cómo especificar tanto categorías de YouTube como palabras clave definidas por el usuario, también conocidas como etiquetas.
En el siguiente código se muestra cómo realizar búsquedas con palabras clave, lo que equivale a utilizar la categorización KEYWORD_SCHEME, y cómo realizar búsquedas con las categorías de YouTube, lo que equivale a utilizar la categorización CATEGORY_SCHEME. Ten en cuenta que los vídeos pueden tener muchas palabras clave, pero sólo una categoría.
YouTubeQuery query = new YouTubeQuery(new URL("http://gdata.youtube.com/feeds/api/videos"));
// a category filter holds a collection of categories to limit the search
Query.CategoryFilter categoryFilter1 = new Query.CategoryFilter();
Query.CategoryFilter categoryFilter2 = new Query.CategoryFilter();
//this restricts to videos tagged with the keyword "puppy".
categoryFilter1.addCategory(new Category(YouTubeNamespace.KEYWORD_SCHEME, "puppy"));
//this restricts to videos in the category of "Comedy".
categoryFilter2.addCategory(new Category(YouTubeNamespace.CATEGORY_SCHEME, "Comedy"));
// multiple filters mean "AND" in a category query
query.addCategoryFilter(categoryFilter1);
query.addCategoryFilter(categoryFilter2);
VideoFeed videoFeed = service.query(query, VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
En el código anterior se recuperan todos los vídeos incluidos en la categoría "Comedia" que tienen la palabra clave "puppy". Si quisieras recuperar vídeos incluidos en la categoría "Comedy" o que tuvieran la palabra clave "puppy", sólo tendrías que utilizar un filtro CategoryFilter que incluyera los dos objetos Category.
Dispones de una lista de las categorías que se pueden utilizar en: http://gdata.youtube.com/schemas/2007/categories.cat.
Las etiquetas de desarrollador son palabras clave ocultas adicionales que permiten a los desarrolladores marcar el contenido que suben. Los usuarios no pueden ver estas palabras clave, pero se pueden utilizar para recuperar vídeos. El código siguiente recupera un feed de todos los vídeos que tengan la etiqueta de desarrollador 'xyzzy':
YouTubeQuery query = new YouTubeQuery(new URL("http://gdata.youtube.com/feeds/api/videos"));
Query.CategoryFilter categoryFilter = new Query.CategoryFilter();
categoryFilter.addCategory(new Category(YouTubeNamespace.DEVELOPER_TAG_SCHEME, "xyzzy"));
query.addCategoryFilter(categoryFilter);
VideoFeed videoFeed = service.query(query, VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
Para recuperar vídeos que tengan una etiqueta de desarrollador, deberás utilizar la clave de desarrollador que se utilizó para subir el vídeo que tiene dicha etiqueta. No tendrás que autenticar la solicitud, sólo proporcionar la clave de desarrollador.
El proceso de subida de vídeos se puede realizar de dos formas: subiendo el vídeo directamente o enviando sólo los metadatos para que el usuario suba después el vídeo a través de un formulario HTML.
Se tardará algún tiempo en procesar e indexar los vídeos subidos en YouTube. Si se suben archivos muy grandes, es posible que no puedan verse en los feeds públicos hasta el día siguiente. Sin embargo, se deberían ver inmediatamente en los feeds de subidas de los usuarios autenticados. Si deseas obtener más información, consulta la sección Comprobación del estado de la subida.
Para subir un vídeo, debes construir primero un nuevo objeto VideoEntry y especificar una serie de componentes necesarios. El ejemplo siguiente muestra cómo subir el vídeo de Quicktime "file.mov" a YouTube con las siguientes propiedades:
| Propiedad | Valor |
|---|---|
| Título | prueba |
| Categoría | Autos |
| Palabras clave | foo |
| Descripción | my description |
| Nombre de archivo | file.mov |
| Tipo de archivo MIME | video/quicktime |
| ¿Vídeo privado? | false |
| Ubicación del vídeo | 37,-122 (lat,long) |
| Etiqueta de desarrollador | xyzzy |
Es obligatorio rellenar los campos siguientes cuando se suba un vídeo: título, descripción, categoría y palabras clave.
VideoEntry newEntry = new VideoEntry();
newEntry.setGeoCoordinates(new GeoRssWhere(37.0,-122.0));
//alternatively, one could specify just a descriptive string
newEntry.setLocation("Mountain View, CA");
YouTubeMediaGroup mg = newEntry.getOrCreateMediaGroup();
mg.addCategory(new MediaCategory(YouTubeNamespace.CATEGORY_SCHEME, "Autos"));
mg.addCategory(new MediaCategory(YouTubeNamespace.DEVELOPER_TAG_SCHEME, "xyzzy"));
mg.setPrivate(false);
mg.setTitle(new MediaTitle());
mg.getTitle().setPlainTextContent("testing");
mg.setKeywords(new MediaKeywords());
mg.getKeywords().addKeyword("foo");
mg.setDescription(new MediaDescription());
mg.getDescription().setPlainTextContent("my description");
MediaFileSource ms = new MediaFileSource(new File("file.mov"), "video/quicktime");
newEntry.setMediaSource(ms);
String uploadUrl = "http://uploads.gdata.youtube.com/feeds/api/users/default/uploads";
VideoEntry createdEntry = service.insert(new URL(uploadUrl), newEntry);
Las subidas basadas en navegador permiten subir el vídeo desde tu sitio directamente a YouTube a través del navegador del usuario. Este método de subida utiliza una URL especial en vez de utilizar la URL de subidas del usuario autenticado:
http://gdata.youtube.com/action/GetUploadToken
Aunque el usuario suba el archivo de vídeo directamente, tu código deberá enviar primero los metadatos del vídeo a YouTube, de forma casi idéntica a la subida directa. La única diferencia, además de la dirección URL personalizada, es que no tienes que vincular ningún objeto MediaFileSource a la VideoEntry que estás construyendo.
Es obligatorio rellenar los campos siguientes cuando se suba un vídeo: título, descripción, categoría y palabras clave.
VideoEntry newEntry = new VideoEntry();
newEntry.setGeoCoordinates(new GeoRssWhere(37.0,-122.0));
//alternatively, one could specify just a descriptive string
newEntry.setLocation("Mountain View, CA");
YouTubeMediaGroup mg = newEntry.getOrCreateMediaGroup();
mg.addCategory(new MediaCategory(YouTubeNamespace.CATEGORY_SCHEME, "Autos"));
mg.addCategory(new MediaCategory(YouTubeNamespace.DEVELOPER_TAG_SCHEME, "xyzzy"));
mg.setTitle(new MediaTitle());
mg.setPrivate(false);
mg.getTitle().setPlainTextContent("testing");
mg.setKeywords(new MediaKeywords());
mg.getKeywords().addKeyword("foo");
mg.setDescription(new MediaDescription());
mg.getDescription().setPlainTextContent("my description");
URL uploadUrl = new URL("http://gdata.youtube.com/action/GetUploadToken");
FormUploadToken token = service.getFormUploadToken(uploadUrl, newEntry);
System.out.println(token.getUrl());
System.out.println(token.getToken());
El código del ejemplo anterior muestra un enlace y un token que se utiliza para construir un formulario HTML que aparece en el navegador del usuario. A continuación se muestra un ejemplo sencillo en el que post_url representa el valor de token.getUrl() y token_value representa el valor de token.getToken().
<form action="post_url" method ="post" enctype="multipart/form-data"> <input type="file" name="file"/> <input type="hidden" name="token" value="token_value"/> <input type="submit" value="go" /> </form>
Para redirigir al usuario a tu sitio web tras el envío del formulario, asegúrate de añadir un parámetro next al parámetro post_url anterior, que funciona del mismo modo que el parámetro next de un enlace AuthSub.
Una vez que se haya subido un vídeo, éste aparecerá inmediatamente en un feed de subidas del usuario autenticado:
http://gdata.youtube.com/feeds/api/users/default/uploads
Sin embargo, no se hará público en el sitio hasta que se haya procesado. Los vídeos que se hayan rechazado o no se hayan podido subir correctamente también aparecerán únicamente en el feed de subidas del usuario autenticado. El código siguiente comprueba el estado de una entrada de vídeo (VideoEntry) para determinar si aún no está activa o si se ha rechazado.
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());
}
}
Para actualizar los metadatos de un vídeo, sólo tienes que actualizar el objeto VideoEntry y utilizar a continuación el método update. En el ejemplo siguiente se actualiza una descripción del vídeo:
entry.getMediaGroup().getDescription().setPlainTextContent("new description");
entry.update();
Para eliminar un vídeo, lo único que hay que hacer es recuperar el feed de subidas del usuario autenticado y ejecutar el método delete en el objeto VideoEntry de dicho vídeo.
videoEntry.delete();
Para puntuar un vídeo, sólo tienes que añadir un objeto Rating a una entrada de vídeo (VideoEntry) y enviarlo (con POST) al enlace de puntuación de dicha entrada VideoEntry.
String ratingUrl = entry.getRatingLink().getHref(); Rating myRating = new Rating(); myRating.setValue(5); myRating.setMax(5); myRating.setMin(1); entry.setRating(myRating); service.insert(new URL(ratingUrl), entry);
Puedes recuperar y mostrar un feed que contenga los comentarios de un determinado vídeo (por ejemplo, el vídeo correspondiente al objeto VideoEntry) con el siguiente
código:
String commentUrl = videoEntry.getComments().getFeedLink().getHref();
CommentFeed commentFeed = service.getFeed(new URL(commentUrl), CommentFeed.class);
for(CommentEntry comment : commentFeed.getEntries()) {
System.out.println(comment.getPlainTextContent());
}
Una vez que hayas recuperado la dirección URL del comentario tal y como se indica en la sección anterior, podrás enviar otro comentario.
CommentEntry newComment = new CommentEntry();
newComment.setContent(new PlainTextConstruct("my pithy comment"));
service.insert(new URL(commentUrl), newComment);
Cada entrada de vídeo de un feed de vídeos puede tener un feed de respuestas en vídeo asociado, que será a su vez un feed de vídeos. En este código se muestra cómo recuperar y mostrar información sobre las respuestas en vídeo de una entrada de vídeo (VideoEntry) específica:
if (videoEntry.getVideoResponsesLink() != null) {
String feedUrl = videoEntry.getVideoResponsesLink().getHref();
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
}
Para obtener más información sobre cómo recuperar feeds a partir de los distintos tipos de objetos, consulta Desplazamiento por los feeds en la guía de referencia.
Después de recuperar el enlace de una respuesta en vídeo, tal como se ha mostrado en la sección anterior, puedes enviar (con POST) una entrada de vídeo (VideoEntry) correspondiente a un vídeo que quieras marcar como respuesta en vídeo para el vídeo original.
service.insert(new URL(responseVideosLink), videoResponseEntry);
Si has recuperado las respuestas en vídeo como un feed, también podrás insertarlas directamente en el objeto VideoFeed.
videoFeed.insert(videoResponseEntry);
Recuerda que todas las respuestas en vídeo tienen que ser aprobadas por el propietario del vídeo al que has respondido antes de que aparezcan en el feed de respuestas en vídeo.
Si eres propietario de uno de los vídeos que aparecen en un objeto VideoFeed que se ha recuperado mediante un enlace de respuestas en vídeo, puedes eliminarlo como respuesta en vídeo. Para hacerlo, debes ejecutar una llamada a delete en dicha entrada.
videoResponseEntry.delete();
Para marcar un vídeo como inadecuado, debes enviar (con POST) una entrada Atom al enlace de reclamaciones del objeto VideoEntry. El código siguiente muestra un ejemplo de cómo marcar un vídeo.
String complaintUrl = badVideoEntry.getComplaintsLink().getHref();
ComplaintEntry complaintEntry = new ComplaintEntry();
complaintEntry.setComment("This video offends my sensibilities.");
service.insert(new URL(complaintUrl), complaintEntry);
Todos los vídeos de YouTube pueden tener vídeos favoritos. Conceptualmente, el feed correspondiente a estos vídeos favoritos es sólo una lista de reproducción sin nombre. El feed de favoritos de un usuario se puede recuperar en la siguiente dirección URL:
http://gdata.youtube.com/feeds/api/users/userID/favorites
El código siguiente muestra una lista de los favoritos de un usuario:
String feedUrl = "http://gdata.youtube.com/feeds/api/users/YTDebates/favorites";
VideoFeed videoFeed = service.getFeed(new URL(feedUrl), VideoFeed.class);
for(VideoEntry entry : videoFeed.getEntries() ) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println(entry.getMediaGroup().getDescription().getPlainTextContent());
}
Ten en cuenta que se puede utilizar la cadena default en lugar de un nombre de usuario para indicar al "usuario autenticado actualmente".
Para añadir un favorito, sólo tienes que insertar la entrada de vídeo (VideoEntry) del vídeo que quieres añadir al feed de favoritos del usuario autenticado.
String videoEntryUrl = "http://gdata.youtube.com/feeds/api/videos/ADos_xW4_J0"; VideoEntry videoEntry = service.getEntry(new URL(videoEntryUrl), VideoEntry.class); service.insert(new URL(feedUrl), videoEntry);
Para eliminar un favorito, sólo tienes que utilizar el método delete en una entrada de vídeo (VideoEntry) en el feed de favoritos del usuario autenticado.
entry.delete();
Cada usuario de YouTube tiene un feed de listas de reproducción asociado. Este feed es una lista de enlaces a un feed que contiene los vídeos de cada lista de reproducción.
Para recuperar un feed de una lista de reproducción de un usuario concreto deberás utilizar la siguiente dirección URL:
http://gdata.youtube.com/feeds/api/users/userID/playlists
El código siguiente muestra cómo recuperar y mostrar un feed de listas de reproducción a través de dicha dirección URL:
String feedUrl = "http://gdata.youtube.com/feeds/api/users/YTdebates/playlists";
PlaylistLinkFeed feed = service.getFeed(new URL(feedUrl), PlaylistLinkFeed.class);
for(PlaylistLinkEntry entry : feed.getEntries()) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println("Description: " + entry.getDescription());
}
Ten en cuenta que se puede utilizar la cadena default en lugar de un nombre de usuario para indicar al "usuario autenticado actualmente".
Si has recuperado una entrada PlaylistLinkEntry como la del ejemplo anterior, puedes extraer y mostrar la lista de reproducción correspondiente con el siguiente código:
String playlistUrl = entry.getFeedLink().getHref();
PlaylistFeed playlistFeed = service.getFeed(new URL(playlistUrl), PlaylistFeed.class);
for(PlaylistEntry playlistEntry : playlistFeed.getEntries()) {
System.out.println("Title: " + playlistEntry.getTitle().getPlainText());
System.out.println("Description: " + playlistEntry.getDescription());
System.out.println("Position: " + playlistEntry.getPosition());
System.out.println("Video URL: " + playlistEntry.getHtmlLink().getHref());
}
Ten en cuenta que PlaylistEntry se hereda de VideoEntry. Si deseas obtener más información sobre lo que se puede recuperar de un objeto VideoEntry, consulta la sección Contenido de la entrada de vídeo.
Para crear una nueva lista de reproducción, inserta una entrada de lista de reproducción (PlaylistLinkEntry) en el feed de listas de reproducciones del usuario autenticado:
String feedUrl = "http://gdata.youtube.com/feeds/api/users/default/playlists";
PlaylistLinkEntry newEntry = new PlaylistLinkEntry();
newEntry.setTitle(new PlainTextConstruct("new playlist"));
newEntry.setDescription("this is my new playlist.");
PlaylistLinkEntry createdEntry = service.insert(new URL(feedUrl), newEntry);
Para actualizar datos de la lista de reproducción como por ejemplo, una pequeña descripción, sólo tienes que modificar el objeto PlaylistLinkEntry y ejecutar una llamada a su método update. El código siguiente actualiza una descripción de la lista de reproducción.
entry.setDescription("updated description");
entry.update();
Para añadir un vídeo a una lista de reproducción, utiliza el objeto VideoEntry. El código del siguiente ejemplo recupera una entrada de vídeo (VideoEntry) con una ID de entrada conocida y, a continuación, la añade a la lista de reproducción correspondiente a la entrada de enlace de lista de reproducción (PlaylistLinkEntry). Al no especificarse una ubicación, el vídeo nuevo se añadirá al final de la lista de reproducción.
String playlistUrl = playlistLinkEntry.getFeedLink().getHref();
String videoEntryUrl = "http://gdata.youtube.com/feeds/api/videos/ADos_xW4_J0";
VideoEntry videoEntry = service.getEntry(new URL(videoEntryUrl), VideoEntry.class);
PlaylistEntry playlistEntry = new PlaylistEntry(videoEntry);
playlistEntry.setTitle(new PlainTextConstruct("Custom title"));
playlistEntry.setDescription("Custom description");
service.insert(new URL(playlistUrl), playlistEntry);
Observa que en el código del ejemplo anterior se especifica un título y una descripción personalizados del vídeo. Esta especificación no es obligatoria. Si no se especifica un título y una descripción personalizados, se utilizarán los existentes.
Para modificar los títulos y las descripciones personalizadas de cada uno de los vídeos de una lista de reproducción, actualiza el objeto PlaylistEntry del vídeo en cuestión y ejecuta su método update.
playlistEntry.setDescription("updated description");
//move this entry to the top of the playlist
playlistEntry.setPosition(0);
playlistEntry.update();
Si deseas cambiar la descripción y el título de un vídeo en una lista de reproducción y volver a poner el título y la descripción originales del vídeo, podrás hacerlo con el código siguiente:
playlistEntry.setDescription(null); playlistEntry.setTitle(null); playlistEntry.update();
Para eliminar un vídeo de una lista de reproducción, utiliza el método delete de la entrada de lista de reproducción (PlaylistEntry):
playlistEntry.delete();
Para eliminar una lista de reproducción, sólo tienes que ejecutar el método delete en el objeto PlaylistLinkEntry correspondiente.
entry.delete();
Para extraer una lista de los canales, las búsquedas y los vídeos favoritos a los que está suscrito un usuario, utiliza la siguiente URL:
http://gdata.youtube.com/feeds/api/users/userID/subscriptions
El código del siguiente ejemplo muestra cómo recuperar y mostrar la lista de suscripciones de un usuario determinado:
String feedUrl = "http://gdata.youtube.com/feeds/api/users/GoogleDevelopers/subscriptions";
SubscriptionFeed feed = service.getFeed(new URL(feedUrl), SubscriptionFeed.class);
for(SubscriptionEntry entry : feed.getEntries()) {
System.out.println("Title: " + entry.getTitle().getPlainText());
System.out.println("Feed Link: " + entry.getFeedLink().getHref());
}
Ten en cuenta que se puede utilizar la cadena default en lugar de un nombre de usuario para indicar al "usuario autenticado actualmente".
Para crear una nueva suscripción, inserta una nueva entrada de suscripción (SubscriptionEntry) en el feed de suscripciones del usuario autenticado. El código del siguiente ejemplo suscribe al usuario autenticado al canal "GoogleDevelopers".
SubscriptionEntry newSubscription = new SubscriptionEntry();
newSubscription.addSubscriptionType(SubscriptionEntry.Type.CHANNEL);
newSubscription.setUsername("GoogleDevelopers");
service.insert(new URL(feedUrl), newSubscription);
También se pueden añadir suscripciones a los vídeos favoritos del usuario "GoogleDevelopers":
SubscriptionEntry newSubscription = new SubscriptionEntry();
newSubscription.addSubscriptionType(SubscriptionEntry.Type.FAVORITES);
newSubscription.setUsername("GoogleDevelopers");
service.insert(new URL(feedUrl), newSubscription);
Por último, existe la posibilidad de suscribirse a términos de búsqueda específicos:
SubscriptionEntry newSubscription = new SubscriptionEntry();
newSubscription.addSubscriptionType(SubscriptionEntry.Type.QUERY);
newSubscription.setQueryString("puppy");
service.insert(new URL(feedUrl), newSubscription);
Para eliminar una suscripción sólo tienes que ejecutar el método delete en el objeto SubscriptionEntry correspondiente.
entry.delete();
Puedes recuperar un perfil de usuario de YouTube como una entrada de Atom en la siguiente dirección URL:
http://gdata.youtube.com/feeds/api/users/userID
El código siguiente muestra varios atributos de un perfil de usuario:
String profileUrl = "http://gdata.youtube.com/feeds/api/users/YTdebates";
UserProfileEntry profileEntry = service.getEntry(new URL(
profileUrl), UserProfileEntry.class);
System.out.println("Username: " + profileEntry.getUsername());
System.out.println("Age : " + profileEntry.getAge());
System.out.println("Gender : " + profileEntry.getGender());
System.out.println("Single? : " + profileEntry.getRelationship());
System.out.println("Books : " + profileEntry.getBooks());
System.out.println("Company : " + profileEntry.getCompany());
System.out.println("Describe: " + profileEntry.getDescription());
System.out.println("Hobbies : " + profileEntry.getHobbies());
System.out.println("Hometown: " + profileEntry.getHometown());
System.out.println("Location: " + profileEntry.getLocation());
System.out.println("Movies : " + profileEntry.getMovies());
System.out.println("Music : " + profileEntry.getMusic());
System.out.println("Job : " + profileEntry.getOccupation());
System.out.println("School : " + profileEntry.getSchool());
YtUserProfileStatistics stats = profileEntry.getStatistics();
if(stats != null) {
System.out.println("Subscriber count: " + stats.getSubscriberCount());
System.out.println("Last web access: " + stats.getLastWebAccess().toUiString());
}
Ten en cuenta que se puede utilizar la cadena default en lugar de un nombre de usuario para indicar al "usuario autenticado actualmente".
Para recuperar una lista de contactos de un usuario puedes utilizar la siguiente dirección URL:
http://gdata.youtube.com/feeds/api/users/userID/contacts
El código siguiente muestra todos los amigos de un usuario específico:
String feedUrl = "http://gdata.youtube.com/feeds/api/users/GoogleDevelopers/contacts";
FriendFeed friendFeed = service.getFeed(new URL(feedUrl), FriendFeed.class);
for(FriendEntry friendEntry : friendFeed.getEntries()) {
System.out.print("Friend: " + friendEntry.getUsername());
System.out.println("Status:" + friendEntry.getStatus().toString());
}
Para añadir un contacto, inserta una nueva entrada de amigo (FriendEntry) en el feed de contactos del usuario autenticado: Se utiliza una categoría para saber en qué grupo de contactos se encuentra el contacto, si es que se encuentra en alguno. El código siguiente añade al usuario de "GoogleDevelopers" como un contacto.
FriendEntry newFriend = new FriendEntry();
newFriend.getCategories().add(new Category(YouTubeNamespace.CONTACT_LIST_SCHEME, "Friends"));
newFriend.setUsername("GoogleDevelopers");
service.insert(new URL(feedUrl), newFriend);
Para aceptar o rechazar a un contacto, puedes actualizar el estado de la entrada FriendEntry correspondiente.
Para aceptar una solicitud:
friendEntry.setStatus(YtStatus.Value.ACCEPTED); friendEntry.update();
Para rechazar una solicitud:
friendEntry.setStatus(YtStatus.Value.REJECTED); friendEntry.update();
Para eliminar un contacto, ejecuta el método delete en una entrada FriendEntry.
friendEntry.delete();
Los usuarios de YouTube pueden enviarse mensajes entre sí, y de forma opcional, incluir vídeos.
Para recuperar el contenido de los mensajes recibidos de un usuario, realiza una solicitud autenticada a la siguiente dirección URL:
http://gdata.youtube.com/feeds/api/users/userID/inbox
En el siguiente ejemplo se muestra el contenido de los mensajes recibidos del usuario autenticado:
String feedUrl = "http://gdata.youtube.com/feeds/api/users/default/inbox";
VideoMessageFeed feed = service.getFeed(new URL(feedUrl), VideoMessageFeed.class);
for(VideoMessageEntry entry : feed.getEntries()) {
System.out.println("Message from: " + entry.getAuthors().get(0).getName());
System.out.println("Subject: " + entry.getTitle().getPlainText());
System.out.println(entry.getDescription());
}
Para enviar un mensaje a un usuario, construye un objeto VideoMessageEntry e insértalo en el feed de los mensajes recibidos. Todos los mensajes enviados a través de un API necesitan que se incluya un objeto VideoEntry.
El siguiente código permite enviar un mensaje con un vídeo a un usuario identificado por la variable receivingUser:
String msgUrl = "http://gdata.youtube.com/feeds/api/users/"+receivingUser+"/inbox";
String videoEntryUrl = "http://gdata.youtube.com/feeds/api/videos/Wegp-JOae0g";
VideoEntry videoEntry = service.getEntry(new URL(videoEntryUrl), VideoEntry.class);
VideoMessageEntry newMessage = new VideoMessageEntry(videoEntry);
newMessage.setTitle(new PlainTextConstruct("my subject"));
newMessage.setDescription("This is the message body.");
service.insert(new URL(msgUrl), newMessage);
El destinatario del mensaje debe ser un contacto aceptado del remitente del mensaje.
Para eliminar un mensaje, ejecuta el método delete en un objeto VideoMessageEntry:
entry.delete();