El API de datos de YouTube permite a las aplicaciones cliente recuperar y actualizar contenido de YouTube como feeds del API de datos de Google. La aplicación cliente puede utilizar los feeds del API de datos de YouTube para extraer, buscar y actualizar vídeos, comentarios, respuestas, listas de reproducción, perfiles de usuario y contactos de usuarios, así como para buscar vídeos que coincidan con unos criterios determinados.
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 PHP. Puedes descargar la biblioteca cliente como versión independiente (distribuida por Zend) o como versión incluida en Zend Framework. Si necesitas ayuda para configurar la biblioteca cliente PHP, consulta la Guía de introducción. Si quieres obtener más información sobre el protocolo que utiliza la biblioteca cliente PHP para interactuar con YouTube, consulta la página de protocolo de la guía del desarrollador.
Este documento está destinado a programadores que deseen crear aplicaciones cliente que puedan interactuar con YouTube mediante la biblioteca cliente PHP. 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 PHP.
Para obtener información de referencia sobre los métodos y las clases PHP, consulta la guía del API 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 datos de Google. 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. Por lo general, se deben autenticar todas las solicitudes que modifican datos de feeds o vídeos. Las solicitudes de sólo lectura para publicar vídeos no requieren autenticación.
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. Por último, se explica el mecanismo de actualización de una entrada de vídeo.
En la sección Recuperación y búsqueda de vídeos se explica cómo extraer listas de vídeos específicas. Entre estas listas se incluyen varios tipos de feeds estándar (como los "vídeos más valorados" o los "más vistos"). Otras listas de vídeos incluyen vídeos subidos por un usuario específico y listas de vídeos relacionados con un vídeo determinado. 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 por 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 subir vídeos como respuestas a otros vídeos.
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. También se indica la forma de modificar favoritos y listas de reproducción de vídeos mediante la adición y eliminación de vídeos.
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.
Para utilizar la biblioteca de cliente PHP, debes disponer de PHP >= 5.1.4 y utilizar Zend_Gdata >= 1.5RC2, que se incluye en Zend Framework. Para obtener más información sobre la forma de configurar tu entorno, consulta la Guía de introducción.
Puedes copiar y pegar en tu código los fragmentos del código de ejemplo que se muestra a continuación y modificarlas en función de tus necesidades. También puedes utilizar una aplicación de ejemplo que se distribuye con la biblioteca cliente y que abarca muchas de las operaciones del API. El código se encuentra en
http://framework.zend.com/svn/framework/demos/Zend/Gdata/YouTubeVideoApp.
Para poder realizar cualquier operación con el API de datos de YouTube, debes iniciar un objeto Zend_Gdata_YouTube como se muestra a continuación. Ten en cuenta que todas las acciones distintas de la recuperación de contenido público requerirán autenticación.
| 
<?php
require_once 'Zend/Loader.php'; // the Zend dir must be in your include_path
Zend_Loader::loadClass('Zend_Gdata_YouTube');
$yt = new Zend_Gdata_YouTube();
Para las funciones con autenticación, también tendrás que incluir una de las siguientes clases de ayudantes, según si vas a utilizar ClientLogin o AuthSub (para obtener información más detallada, consulta la sección Autenticación que aparece a continuación.
Zend_Loader::loadClass('Zend_Gdata_AuthSub');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
La mayoría de los métodos de ejemplo de esta guía funcionan con una instancia de
Zend_Gdata_YouTube.
Nota: el contenido del directorio library de Zend debe estar incluido en la ruta include_path de PHP.
La biblioteca de cliente PHP se puede utilizar para trabajar con feeds públicos o privados. Los feeds públicos son feeds de sólo lectura que no requieren autenticación. Los feeds privados requieren autenticación en los servidores de YouTube. También tendrás que registrarte para obtener una clave de desarrollador de YouTube. La autenticación se puede realizar con ClientLogin (autenticación mediante nombre de usuario y contraseña) o con AuthSub (autenticación mediante servidor proxy).
La autenticación proxy con AuthSub es la que utilizan las aplicaciones web que necesitan autenticar a sus usuarios en cuentas de YouTube/Google. El operador no necesita acceder al nombre de usuario y a la contraseña del usuario de YouTube (sólo se necesitan tokens especiales de AuthSub).
Cuando el usuario visite por primera vez la aplicación, no se habrá autenticado aún en los servicios de Google. En ese caso, tendrás que proporcionarle un enlace que lo dirija a Google para autenticar tu solicitud de acceso a su cuenta de YouTube. La biblioteca cliente de datos de Google PHP de Zend Framework ofrece una función para generar esta URL. El código que se muestra a continuación crea un enlace a la página AuthSubRequest.
// start a new session
session_start();
function getAuthSubRequestUrl($userName)
{
$next = 'http://mysite.com/welcome.php';
$scope = 'http://gdata.youtube.com';
$secure = false;
$session = true;
return Zend_Gdata_AuthSub::getAuthSubTokenUri($next, $scope, $secure, $session);
}
El código del ejemplo anterior genera una URL que solicita un token del servicio YouTube de Google. Se envían los siguientes parámetros al método getAuthSubRequestUrl
:
La URL será parecida a ésta:
https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fgdata.youtube.com&session=1&secure=0&next=http%3A%2F%2Fwww.mysite.com%2Fwelcome.php
El usuario hará clic en el enlace al sitio de Google y se autenticará en su cuenta de Google. Una vez que el usuario vuelva a la URL $next de la aplicación, se enviará el token de un solo uso junto con el redireccionamiento: http://mysite.com/welcome.php?token=DQAADKEDE.
Por seguridad, este token es de un solo uso, por lo que habrá que cambiarlo por un token de sesión. El siguiente fragmento de código muestra la forma de actualizar el token.
$sessionToken = Zend_Gdata_AuthSub::getAuthSubSessionToken($_GET['token']);
En este fragmento, la variable $_GET['token'] contiene el valor del parámetro de consulta token de la URL. Este token representa un token de AuthSub de un solo uso. Al haber especificado $session = true en la función getAuthSubRequestUrl del ejemplo anterior, este token se puede cambiar por un token de sesión de AuthSub mediante la ejecución de getAuthSubSessionToken tal como se ha hecho en el código del ejemplo anterior.
La función del ejemplo siguiente realiza todas estas solicitudes. En primer lugar, comprueba si se ha establecido un token de sesión. En caso negativo, crea una URL de autenticación mediante la función getAuthSubRequestUrl anteriormente descrita. Si se encuentra un token de un solo uso en la cadena de URL ($_GET['token']), el token de un solo uso se actualizará a un token de sesión. Por último, se utilizará tu clave de desarrollador para crear y devolver un objeto Zend_Gdata_Http_Client totalmente autenticado.
function getAuthSubHttpClient($developerKey)
{
if (!isset($_SESSION['sessionToken']) && !isset($_GET['token']) ){
echo '<a href="' . getAuthSubUrl() . '">Login!</a>';
return;
} else if (!isset($_SESSION['sessionToken']) && isset($_GET['token'])) {
$_SESSION['sessionToken'] = Zend_Gdata_AuthSub::getAuthSubSessionToken($_GET['token']);
}
$httpClient = Zend_Gdata_AuthSub::getHttpClient($_SESSION['sessionToken']);
$httpClient->setHeaders('X-GData-Key', "key=${developerKey}");
return $httpClient;
}
Una vez hecho esto, podrás crear un objeto de servicio YouTube totalmente autenticado mediante la transmisión de $httpClient al constructor del objeto de servicio Zend_Gdata_YouTube:
$yt = new Zend_Gdata_YouTube($httpClient);
Este objeto de servicio totalmente autenticado se podrá utilizar para realizar cualquier futura solicitud con el API de YouTube. Los tokens de sesión de AuthSub no caducarán a menos que envíes una solicitud específica para revocarlos o que el usuario decida revocar el acceso visitando la página de sitios autorizados.
La autenticación con ClientLogin se utiliza en aplicaciones instaladas que pueden tener almacenada la información de nombre de usuario y contraseña del usuario o solicitársela. Para utilizar este método de autenticación, debes ejecutar el método getHttpClient estático de la clase Zend_Gdata_ClientLogin, especificando la dirección de correo electrónico y la contraseña del usuario en cuyo nombre envía la consulta la aplicación. Ten en cuenta que también debes incluir la URL especificada a continuación para la autenticación. Por ejemplo:
$authenticationURL= 'https://www.google.com/youtube/accounts/ClientLogin';
$httpClient = Zend_Gdata_ClientLogin::getHttpClient(
$username = 'myuser@gmail.com',
$password = 'mypassword',
$service = 'youtube',
$client = null,
$source = 'MySource', // a short string identifying your application
$loginToken = null,
$loginCaptcha = null,
$authenticationURL);
Una vez establecidas las credenciales, se podrá utilizar el objeto $httpClient para la autenticación de todas las futuras solicitudes enviadas al objeto de servicio Zend_Gdata_YouTube. Asegúrate de transmitir también tu clave de desarrollador a $httpClient:
$myDeveloperKey = 'ABC123 ... ';
$httpClient->setHeaders('X-GData-Key', "key=${myDeveloperKey}");
$yt = new Zend_Gdata_YouTube($httpClient);
Para obtener información más detallada sobre los mecanismos de autenticación con AuthSub y ClientLogin, consulta la documentación de autenticación de API de datos de Google.
El API de datos de YouTube proporciona varios feeds de vídeos que representan listas de vídeos (por ejemplo, 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 están integrados por entradas de vídeos. Estos feeds se pueden configurar fácilmente como objetos Zend_Gdata_YouTube_VideoFeed (que contengan objetos Zend_Gdata_YouTube_VideoEntry). Cada entrada de vídeo corresponde a un único vídeo de YouTube y contiene 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:
function getAndPrintVideoFeed($location = Zend_Gdata_YouTube::VIDEO_URI)
{
$yt = new Zend_Gdata_YouTube();
$videoFeed = $yt->getVideoFeed($location);
foreach ($videoFeed as $videoEntry) {
printVideoEntry($videoEntry); // this function is documented fully here
}
}
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.
Puedes recuperar sólo la información de una entrada de vídeo específica si conoces su ID de vídeo. La URL de la entrada se basa en la ID de vídeo:
http://gdata.youtube.com/feeds/api/videos/videoID
El siguiente código permite recuperar una entrada de vídeo (VideoEntry) correspondiente a un vídeo de YouTube:
$yt->getVideoEntry('the0KZLEacs');
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. La biblioteca cliente PHP reúne la mayoría de estas funciones mediante la asignación de elementos XML a clases PHP. La mayor parte de la información importante sobre una entrada VideoEntry se puede obtener a partir del elemento secundario de media:group, que procede de VideoEntry. Ese elemento XML se asigna al objeto MediaGroup y se puede recuperar mediante la ejecución de $videoEntry->getMediaGroup() o $videoEntry->mediaGroup. Hemos añadido a la biblioteca cliente muchos métodos de ayudante que se pueden ejecutar directamente desde el objeto VideoEntry y que permiten acceder fácilmente a los elementos secundarios de mediaGroup. Uno de estos métodos es $videoEntry->getVideoTitle().
function printVideoEntry($videoEntry, $tabs = "")
{
// the videoEntry object contains many helper functions that access the underlying mediaGroup object
echo $tabs . 'Video: ' . $videoEntry->getVideoTitle() . "\n";
echo $tabs . "\tDescription: " . $videoEntry->getVideoDescription() . "\n";
echo $tabs . "\tCategory: " . $videoEntry->getVideoCategory() . "\n";
echo $tabs . "\tTags: " . implode(", ", $videoEntry->getVideoTags()) . "\n";
echo $tabs . "\tWatch page: " . $videoEntry->getVideoWatchPageUrl() . "\n";
echo $tabs . "\tFlash Player Url: " . $videoEntry->getFlashPlayerUrl() . "\n";
echo $tabs . "\tDuration: " . $videoEntry->getVideoDuration() . "\n";
echo $tabs . "\tView count: " . $videoEntry->getVideoViewCount() . "\n";
echo $tabs . "\tRating: " . $videoEntry->getVideoRatingInfo() . "\n";
echo $tabs . "\tGeo Location: " . $videoEntry->getVideoGeoLocation() . "\n";
// see the paragraph above this function for more information on the 'mediaGroup' object
// here we are using the mediaGroup object directly to its 'Mobile RSTP link' child
foreach ($videoEntry->mediaGroup->content as $content) {
if ($content->type === "video/3gpp") {
echo $tabs . "\tMobile RTSP link: " . $content->url . "\n";
}
}
echo $tabs . "\tThumbnails:\n";
$videoThumbnails = $videoEntry->getVideoThumbnails();
foreach($videoThumbnails as $videoThumbnail) {
echo $tabs . "\t\t" . $videoThumbnail->time . " - " . $videoThumbnail->url;
echo " height=" . $videoThumbnail->height;
echo " width=" . $videoThumbnail->width;
echo "\n";
}
}
Para obtener más información sobre la forma de generar la información necesaria para insertar un vídeo con el reproductor en tu página, consulta la guía de protocolo.
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 URL de todos los feeds estándar
empiezan por http://gdata.youtube.com/feeds/api/standardfeeds/,
seguido del 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. Para obtener una lista completa de ID de entorno local supuestas, consulta la guía de referencia.
El siguiente ejemplo muestra cómo extraer y mostrar estos feeds estándar con el
método YouTube::getVideoFeed().
Las URL de algunos de estos feeds pueden ser constantes definidas, y algunas de ellas se pueden recuperar con métodos de ayudante, pero también se pueden construir manualmente con los valores definidos en la guía de referencia. Ten en cuenta que el objeto de servicio Zend_Gdata_YouTube no se tiene que autenticar para recuperar feeds estándar.
function getAndPrintStandardFeeds()
{
// constructing URL manually
$YOUTUBE_GDATA_SERVER = 'http://gdata.youtube.com';
$STANDARD_FEED_PREFIX = $YOUTUBE_GDATA_SERVER . '/feeds/api/standardfeeds/';
$TOP_RATED_FEED = $STANDARD_FEED_PREFIX . 'top_rated';
getAndPrintVideoFeed($TOP_RATED_FEED);
// URL as a constant in Zend_Gdata_YouTube
getAndPrintVideoFeed(Zend_Gdata_YouTube::STANDARD_TOP_RATED_URI);
// using helper method
$yt = new Zend_Gdata_YouTube();
printVideoFeed($yt->getTopRatedVideoFeed());
// choosing the time period for a standard feed
$yt = new Zend_Gdata_YouTube();
$query = $yt->newVideoQuery(Zend_Gdata_YouTube::STANDARD_TOP_RATED_URI);
$query->setTime('today');
// reusing the getAndPrintVideo feed function defined earlier
getAndPrintVideoFeed($query);
}
Un objeto VideoFeed está constituido por un grupo de objetos VideoEntry. Las siguientes funciones de ayudante permiten mostrar detalles de vídeos devueltos en un feed:
function printVideoFeed($videoFeed, $displayTitle = null)
{
$count = 1;
if ($displayTitle === null) {
$displayTitle = $videoFeed->title->text;
}
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
foreach ($videoFeed as $videoEntry) {
echo 'Entry # ' . $count . "\n";
printVideoEntry($videoEntry);
echo "\n";
$count++;
}
echo "</pre>\n";
}
Cada usuario de YouTube tiene en http://gdata.youtube.com/feeds/api/users/username/uploads un feed de vídeos asociado correspondiente a los vídeos que ha subido.
El siguiente código muestra cómo extraer y mostrar un feed de subidas de un usuario:
function getAndPrintUserUploads($userName)
{
$yt = new Zend_Gdata_YouTube();
printVideoFeed($yt->getuserUploads($userName));
}
También se puede utilizar la cadena "default" en lugar de $userName para recuperar vídeos del usuario autenticado actualmente.
Para recuperar vídeos relacionados, transmite la ID de vídeo del objeto Video_Entry al método getRelatedVideoFeed del objeto Zend_Gdata_YouTube. Esta operación permite recuperar un objeto VideoFeed con entradas relacionadas.
$relatedVideosFeed = $yt->getRelatedVideoFeed($originalVideo->getVideoId());
El API de datos de YouTube permite solicitar un conjunto de entradas que coincidan con los criterios especificados (por ejemplo, entradas de vídeos que hayan sido publicadas por un determinado autor, que tengan un formato de vídeo específico o que contengan una palabra clave en concreto). Para realizar este proceso, debes crear un objeto VideoQuery con tus propios criterios de búsqueda y transmitirlo al método YouTube::getVideoFeed().
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 (conocidos como "vídeos picantes" por el API), deberás utilizar los métodos setVideoQuery, setOrderBy y setRacy del objeto VideoQuery. El siguiente fragmento de código muestra los títulos y resúmenes de todos los vídeos que coinciden con una palabra clave determinada ordenados por volumen de reproducciones (con los vídeos de acceso restringido incluidos):
function searchAndPrint($searchTerms)
{
$yt = new Zend_Gdata_YouTube();
$query = $yt->newVideoQuery();
$query->setOrderBy('viewCount');
$query->setRacy('include');
$query->setVideoQuery($searchTerms);
$videoFeed = $yt->getVideoFeed($query);
printVideoFeed($videoFeed, 'Search results for: ' . $searchTerms);
}
La clase Query y algunas subclases como VideoQuery intervienen en la construcción de URL de feeds. El objeto VideoQuery que aparece en el ejemplo anterior construye una URL equivalente a la siguiente:
http://gdata.youtube.com/feeds/api/videos?vq=searchTerms&racy=include&orderby=viewCount
Éstos son algunos de los métodos VideoQuery más utilizados para el establecimiento de parámetros de búsqueda:
setAuthorsetFormatsetRacysetMaxResultssetStartIndexsetOrderByRELEVANCE), 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).setVideoQuerySi quieres establecer un parámetro que no tenga un método de ayudante correspondiente en la clase VideoQuery, puedes establecer un parámetro personalizado mediante la ejecución del método $query->setParam('name', 'value'). 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.
Puedes restringir los resultados de la búsqueda 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.
El código del siguiente ejemplo muestra cómo realizar búsquedas con palabras clave (etiquetas) cambiando los términos de búsqueda a minúscula. Nota: algunas palabras (como "comedia") pueden equivaler tanto a una palabra clave como a una categoría de YouTube, por lo que en las consultas por palabra clave y categoría se asume que la palabra corresponde a una categoría de YouTube si empieza con mayúscula ("Comedia") y a una palabra clave si empieza con minúscula ("comedia").
function searchAndPrintVideosByKeywords($searchTermsArray)
{
$yt = new Zend_Gdata_YouTube();
$query = $yt->newVideoQuery();
$query->setOrderBy('viewCount');
$query->setRacy('include');
$keywordQuery = '';
foreach ($searchTermsArray as $searchTerm) {
$keywordQuery .= strtolower($searchTerm) . '/';
}
$query->setCategory($keywordQuery);
$videoFeed = $yt->getVideoFeed($query);
printVideoFeed($videoFeed, 'Search results for keyword search:');
}
Las etiquetas de desarrollador son palabras clave ocultas adicionales que pueden utilizar los desarrolladores para marcar el contenido que suben. Estas palabras clave no son visibles para los usuarios y se pueden utilizar para recuperar vídeos. Para buscar vídeos que coincidan con una etiqueta de desarrollador específica, envía una solicitud de búsqueda general del API de datos de YouTube y asegúrate de especificar el esquema de categoría y la etiqueta de desarrollador correspondiente a los vídeos que quieras que se muestren. Para acceder a vídeos que coincidan con una etiqueta de desarrollador, no es necesaria la autenticación de la aplicación cliente, pero sí la especificación de la clave de desarrollador en el encabezado. Puedes recuperar un feed de vídeos que coincida con tu etiqueta de desarrollador ("your_tag_here" en el ejemplo) con la siguiente URL:
$devTagUrl = "http://gdata.youtube.com/feeds/videos/-/%7Bhttp%3A%2F%2Fgdata.youtube.com%2Fschemas%2F2007%2Fdevelopertags.cat%7Dyour_tag_here"; // obtain a feed with videos matching the provided developer tag $yt->getVideoFeed($devTagUrl);
Asegúrate de consultar los diagramas de la guía de protocolo para obtener una visión general del proceso de subida. 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.
Para obtener más información, consulta
developers_guide_protocol.html#Process_Flows_for_Uploading_Videos
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 "mytestmovie.mov" a YouTube con las siguientes propiedades:
| Propiedad | Valor |
|---|---|
| Título | My Test Movie |
| Categoría | Autos |
| Palabras clave | cars, funny |
| Descripción | My description |
| Nombre de archivo | mytestmovie.mov |
| Tipo de archivo MIME | video/quicktime |
| ¿Vídeo privado? | false |
| Ubicación del vídeo | 37,-122 (lat,long) |
| Etiquetas de desarrollador | mydevelopertag, anotherdevelopertag |
El código del siguiente ejemplo crea una entrada de vídeo (VideoEntry) en blanco para subir. Se utiliza un objeto Zend_Gdata_App_MediaFileSource para el archivo de vídeo en sí. Se utiliza un objeto Zend_Gdata_YouTube_MediaGroup para los metadatos del vídeo. $uploadUrl es la ubicación a la que se envía la nueva entrada. Se puede especificar mediante el nombre de usuario ($userName) del usuario autenticado actualmente o utilizando simplemente la cadena "default" como referencia al usuario autenticado actualmente.
$yt = new Zend_Gdata_YouTube($httpClient);
// create a new Zend_Gdata_YouTube_VideoEntry object
$myVideoEntry = new Zend_Gdata_YouTube_VideoEntry();
// create a new Zend_Gdata_App_MediaFileSource object
$filesource = $yt->newMediaFileSource('mytestmovie.mov');
$filesource->setContentType('video/quicktime');
// set slug header
$filesource->setSlug('mytestmovie.mov');
// add the filesource to the video entry
$myVideoEntry->setMediaSource($filesource);
// create a new Zend_Gdata_YouTube_MediaGroup object
$mediaGroup = $yt->newMediaGroup();
$mediaGroup->title = $yt->newMediaTitle()->setText('My Test Movie');
$mediaGroup->description = $yt->newMediaDescription()->setText('My description');
// the category must be a valid YouTube category
// optionally set some developer tags (see Searching by Developer Tags for more details)
$mediaGroup->category = array(
$yt->newMediaCategory()->setText('Autos')->setScheme('http://gdata.youtube.com/schemas/2007/categories.cat'),
$yt->newMediaCategory()->setText('mydevelopertag')->setScheme('http://gdata.youtube.com/schemas/2007/developertags.cat'),
$yt->newMediaCategory()->setText('anotherdevelopertag')->setScheme('http://gdata.youtube.com/schemas/2007/developertags.cat')
);
// set keywords
$mediaGroup->keywords = $service->newMediaKeywords()->setText('cars, funny');
$myVideoEntry->mediaGroup = $mediaGroup;
// set video location
$yt->registerPackage('Zend_Gdata_Geo');
$yt->registerPackage('Zend_Gdata_Geo_Extension');
$where = $yt->newGeoRssWhere();
$position = $yt->newGmlPos('37.0 -122.0');
$where->point = $yt->newGmlPoint($position);
$entry->setWhere($where);
// upload URL for the currently authenticated user
$uploadUrl = 'http://uploads.gdata.youtube.com/feeds/users/default/uploads';
try {
$newEntry = $yt->insertEntry($myVideoEntry, $uploadUrl, 'Zend_Gdata_YouTube_VideoEntry');
} catch (Zend_Gdata_App_Exception $e) {
echo $e->getMessage();
}
La subida basada en el navegador se realiza casi igual que la subida directa, con la diferencia de que no tienes que vincular un objeto MediaFileSource a la entrada de vídeo (VideoEntry) que estés construyendo. Tan sólo tienes que enviar todos los metadatos de tu vídeo para recibir un elemento token que podrás utilizar para construir un formulario de subida HTML.
$yt = new Zend_Gdata_YouTube($httpClient);
// create a Zend_Gdata_YouTube_VideoEntry
$myVideoEntry= new Zend_Gdata_YouTube_VideoEntry();
// set up media group as in the example above
$mediaGroup = $yt->newMediaGroup();
$mediaGroup->title = $yt->newMediaTitle()->setText('My Test Movie');
$mediaGroup->description = $yt->newMediaDescription()->setText('My description');
// note the different schemes for categories and developer tags
$categoryScheme = 'http://gdata.youtube.com/schemas/2007/categories.cat';
$developerTagScheme = 'http://gdata.youtube.com/schemas/2007/developertags.cat';
$mediaGroup->category = array(
$yt->newMediaCategory()->setText('Autos')->setScheme($categoryScheme),
$yt->newMediaCategory()->setText('mydevelopertag')->setScheme($developerTagScheme),
$yt->newMediaCategory()->setText('anotherdevelopertag')->setScheme($developerTagScheme)
);
$mediaGroup->keywords = $yt->newMediaKeywords()->setText('cars, funny');
$myVideoEntry->mediaGroup = $mediaGroup;
$tokenHandlerUrl = 'http://gdata.youtube.com/action/GetUploadToken';
$tokenArray = $yt->getFormUploadToken($myVideoEntry, $tokenHandlerUrl);
$tokenValue = $tokenArray['token'];
$postUrl = $tokenArray['url'];
El código del ejemplo anterior muestra un enlace y un token que se utilizan para construir un formulario HTML que aparece en el navegador del usuario. A continuación se muestra un sencillo formulario de ejemplo en el que $tokenValue representa el contenido del elemento token devuelto, tal como aparece al recuperarlo de la entrada de vídeo ($myVideoEntry) del ejemplo anterior. Para redirigir al usuario a tu sitio web tras el envío del formulario, asegúrate de añadir un parámetro $nextUrl al parámetro $postUrl, que funciona del mismo modo que el parámetro $next de un enlace AuthSub. La única diferencia es que, en este caso, aparece un estado y una variable id en la URL.
// place to redirect user after upload
$nextUrl = 'http://mysite.com/youtube_uploads';
// build the form
$form = '<form action="'. $postUrl .'?nexturl='. $nextUrl .
'" method="post" enctype="multipart/form-data">'.
'<input name="file" type="file"/>'.
'<input name="token" type="hidden" value="'. $tokenValue .'"/>'.
'<input value="Upload Video File" type="submit" />'.
'</form>';
// assuming that $nextUrl was http://mysite.com/youtube_uploads http://mysite.com/youtube_uploads?status=200&id=JPF-DXF7hzc
El parámetro status muestra el estado de transacción HTTP de la transacción de subida. El parámetro id muestra la ID de vídeo de YouTube asignada al vídeo subido.
Una vez que se haya subido un vídeo, éste aparecerá inmediatamente en un feed de subidas del usuario autenticado. 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 del siguiente ejemplo comprueba el estado de una entrada de vídeo (VideoEntry) para determinar si aún no está activa o si se ha rechazado.
// check if video is in draft status
try {
$control = $videoEntry->getControl();
} catch (Zend_Gdata_App_Exception $e) {
echo $e->getMessage();
}
if ($control instanceof Zend_Gdata_App_Extension_Control) {
if ($control->getDraft() != null && $control->getDraft()->getText() == 'yes') {
$state = $videoEntry->getVideoState();
if ($state instanceof Zend_Gdata_YouTube_Extension_State) {
print 'Upload status: '. $state->getName() .' '. $state->getText();
} else {
print "Not able to retrieve the video status information yet. Please try again shortly.\n";
}
}
}
Para actualizar los metadatos de un vídeo, sólo tienes que actualizar el objeto VideoEntry y utilizar a continuación el método updateEntry del servicio Zend_Gdata_YouTube. Ten en cuenta que updateEntry genera una solicitud PUT http, por lo que tendrás que utilizar el enlace "edit" de la entrada de vídeo como ubicación. El código del siguiente ejemplo muestra cómo actualizar el título de un vídeo y obtener después el enlace "edit" del vídeo para enviar la actualización a:
$videoEntry->mediaGroup->title->text = 'A new title'; $putUrl = $videoEntry->getEditLink()->getHref(); $yt->updateEntry($videoEntry, $putUrl);
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 de servicio Zend_Gdata_YouTube, incluyendo la entrada de vídeo (VideoEntry) que se debe eliminar.
$yt->delete($videoEntryToDelete);
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 esa entrada de vídeo.
// create a new Zend_Gdata_App_Entry
$ratingEntry = $service->newEntry();
// create a new Zend_Gdata_App_Extension_Rating element
$rating = $service->newRating();
$rating->setMax(5);
$rating->setMin(1);
// create a custom attribute for gd:rating value="5",
// setting the new rating to be submitted to '5 stars'
$rating->setExtensionAttributes(array(array('namespaceUri' => 'http://schemas.google.com/g/2005', 'name' => 'value', 'value' => '5')));
// add the extension element to the rating entry
$ratingEntry->extensionElements = array($rating);
// obtain the ratings url for the video that you wish to rate
$ratingUrl = $videoEntry->getLink('http://gdata.youtube.com/schemas/2007#video.ratings')->getHref();
// post the $ratingEntry to the $ratingUrl using the insertEntry method of the Zend_Gdata_YouTube service object
try {
$response = $service->insertEntry( $ratingEntry, $ratingUrl );
} catch (Zend_Gdata_App_Exception $e) {
echo $e->getMessage();
}
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:
getAndPrintCommentFeed($videoEntry->videoId);
function getAndPrintCommentFeed($videoId)
{
$yt = new Zend_Gdata_YouTube();
$commentFeed = $yt->getVideoCommentFeed($videoId);
printCommentFeed($commentFeed);
}
function printCommentFeed($commentFeed, $displayTitle = null)
{
$count = 1;
if ($displayTitle === null) {
$displayTitle = $commentFeed->title->text;
}
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
foreach ($commentFeed as $commentEntry) {
echo 'Entry # ' . $count . "\n";
printCommentEntry($commentEntry);
echo "\n";
$count++;
}
echo "</pre>\n";
}
function printCommentEntry($commentEntry)
{
echo 'Comment: ' . $commentEntry->title->text . "\n";
echo "\tFull text: " . $commentEntry->content->text . "\n";
echo "\tAuthor: " . $commentEntry->author->name->text . "\n";
}
Para añadir un nuevo comentario, sólo tienes que utilizar el objeto de servicio Zend_Gdata_YouTube.
$newComment = $yt->newCommentEntry();
$newComment->content = $service->newContent()->setText('new comment');
// post the comment to the comment post URL
$comment_post_url = 'http://gdata.youtube.com/feeds/videos/'. $video_id .'/comments';
$updatedVideoEntry = $yt->insertEntry( $comment2, $comment_post_url );
Para eliminar un comentario, primero debes recuperarlo con el objeto Zend_Gdata_YouTube_CommentFeed. A continuación, podrás utilizar el objeto de servicio Zend_Gdata_YouTube para eliminar esa entrada de comentario (CommentEntry) específica.
$yt->delete($commentEntryToBeDeleted);
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. El código del siguiente ejemplo muestra cómo recuperar y mostrar información sobre las respuestas en vídeo de una entrada de vídeo (VideoEntry) específica:
function getAndPrintVideoResponses($videoEntry)
{
$responsesFeedUrl = $videoEntry->getVideoResponsesLink()->getHref();
getAndPrintVideoFeed($responsesFeedUrl);
}
En este ejemplo se vuelve a utilizar la función getAndPrintVideoFeed(). en este caso, la URL de feed no se construye manualmente, sino que se recupera de forma dinámica mediante la ejecución de VideoEntry::getVideoResponsesLink()->getHref().
Para obtener más información sobre la forma de recuperar feeds sin necesidad de conocer sus URL, 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.
$yt->insertEntry($videoResponseEntry, $responsesFeedUrl);
Ten en cuenta que las respuestas en vídeo deben ser aprobadas por los propietarios de los vídeos respectivos para que aparezcan en YouTube.
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 delete() en el objeto de servicio Zend_Gdata_YouTube, incluyendo la entrada que quieras eliminar.
$yt->delete($videoEntryToBeDeleted);
Para marcar un vídeo como inadecuado, debes enviar (con POST) una entrada Atom al enlace de reclamaciones del objeto VideoEntry. El código del siguiente ejemplo muestra cómo marcar un vídeo.
$complaintUrl = $badVideoEntry->getVideoComplaintsLink()->getHref();
$complaintEntry = $yt->newEntry();
$newComplaint->content = $yt->newContent()->setText('This video is inapproriate.');
// then use the $yt service to insert the entry
try {
$yt->insertEntry($complaintEntry, $complaintUrl);
} catch (Zend_App_Exception $e) {
print $e->getMessage();
}
Los usuarios de YouTube pueden marcar los vídeos que deseen como favoritos. La ubicación general del feed de vídeos favoritos de un usuario es la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username/favorites
Para recuperar los vídeos favoritos de un usuario, sólo tienes que solicitar un feed del objeto de servicio Zend_Gdata_YouTube. El feed devuelto será un feed de vídeo normal que contendrá objetos VideoEntry.
$favoritesFeed = $yt->getUserFavorites($userName);
Nota: también puedes incluir la cadena default para recuperar los vídeos favoritos del usuario autenticado actualmente.
Para añadir un vídeo favorito, utiliza el método insertEntry del objeto de servicio Zend_Gdata_YouTube para enviar tu nuevo vídeo favorito (una entrada Zend_Gdata_YouTube_VideoEntry normal) al feed de vídeos favoritos del usuario.
$yt->insertEntry($newFavoriteVideoEntry, $favoritesFeed);
Para eliminar un vídeo favorito, sólo tienes que utilizar el método delete() en el objeto Zend_Gdata_YouTube_VideoEntry. Asegúrate de recuperar el vídeo favorito del feed de vídeos favoritos del usuario en cuestión. De lo contrario, eliminarás la propia entrada de vídeo.
$favoriteVideoToBeDeleted->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 extraer manualmente una lista de todas las listas de reproducción de un usuario, debes utilizar la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username/playlists
Nota: también puedes incluir la cadena default para recuperar los vídeos favoritos del usuario autenticado actualmente.
function getAndPrintPlaylistListFeed($userName, $showPlaylistContents)
{
$yt = new Zend_Gdata_YouTube();
$playlistListFeed = $yt->getPlaylistListFeed($userName);
printPlaylistListFeed($playlistListFeed, $showPlaylistContents);
}
function printPlaylistListFeed($playlistListFeed, $showPlaylistContents)
{
$count = 1;
if ($displayTitle === null) {
$displayTitle = $playlistListFeed->title->text;
}
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
foreach ($playlistListFeed as $playlistListEntry) {
echo 'Entry # ' . $count . "\n";
printPlaylistListEntry($playlistListEntry, $showPlaylistContents);
echo "\n";
$count++;
}
echo "</pre>\n";
}
Si has recuperado una entrada PlaylistListEntry como la del ejemplo anterior, puedes extraer y mostrar la lista de reproducción correspondiente con el siguiente código:
function printPlaylistListEntry($playlistListEntry, $showPlaylistContents = false)
{
echo 'Playlist: ' . $playlistListEntry->title->text . "\n";
echo "\tDescription: " . $playlistListEntry->description->text . "\n";
if ($showPlaylistContents === true) {
getAndPrintPlaylistVideoFeed($playlistListEntry, "\t\t");
}
}
function getAndPrintPlaylistVideoFeed($playlistListEntry, $tabs = "")
{
$yt = new Zend_Gdata_YouTube();
$playlistVideoFeed = $yt->getPlaylistVideoFeed($playlistListEntry->getPlaylistVideoFeedUrl());
foreach ($playlistVideoFeed as $playlistVideoEntry) {
printVideoEntry($playlistVideoEntry, $tabs . "\t");
}
}
La función printPlaylistListEntry() utiliza el parámetro booleano opcional showPlaylistContents; si el valor del parámetro es "true", la lista de vídeos de cada lista de reproducción se incluirá también en los resultados con las funciones definidas en la siguiente sección.
Para añadir una nueva lista de reproducción, sólo tienes que utilizar el objeto de servicio Zend_Gdata_YouTube para crear una lista y enviarla después a la URL de la lista de reproducción del usuario.
$newPlaylist = $yt->newPlaylistListEntry();
$newPlaylist->description = $yt->newDescription()->setText('description of my new playlist');
$newPlaylist->title = $yt->newTitle()->setText('title of my new playlist');
// post the new playlist
$postLocation = 'http://gdata.youtube.com/feeds/users/default/playlists';
try {
$yt->insertEntry($newPlaylist, $postLocation);
} catch (Zend_Gdata_App_Exception $e) {
echo $e->getMessage();
}
Para actualizar una lista de reproducción, sólo tienes que modificar el objeto Zend_Gdata_YouTube_PlaylistListEntry recuperado y, a continuación, utilizar el método save() para guardar los cambios que hayas realizado.
$playlistToBeUpdated->description->setText('new description for my playlist');
$playlistToBeUpdated->save();
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 nuevo vídeo se añadirá al final de la lista de reproducción.
$postUrl = $playlistToAddTo->getPlaylistVideoFeedUrl();
// video entry to be added
$videoEntryToAdd = $service->getVideoEntry('4XpnKHJAok8');
// create a new Zend_Gdata_PlaylistListEntry, passing in the underling DOMElement of the VideoEntry
$newPlaylistListEntry = $service->newPlaylistListEntry($videoEntryToAdd->getDOM());
$newPlaylistListEntry->description = $service->newDescription()->setText('Custom description');
$newPlaylistListEntry->title = $service->newTitle()->setText('Custom title');
// post
try {
$yt->insertEntry($newPlaylistListEntry, $postUrl);
} catch (Zend_App_Exception $e) {
print $e->getMessage();
}
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 PlaylistVideoEntry del vídeo en cuestión y ejecuta su método update.
// get a Zend_Gdata_PlaylistVideoEntry from the feed generated by $yt->getPlaylistVideoFeedUrl
$playlistVideoEntryToBeModified->setPosition($yt->newPosition(2));
$playlistVideoEntryToBeModified->setTitle($yt->newTitle('Updated title for my video'));
// update by putting the new entry to the entry's edit link
try {
$yt->updateEntry($playlistVideoEntryToBeModified, $playlistVideoEntryToBeModified->getEditLink()->getHref());
}
Nota: Si quieres restablecer el título y la descripción originales de uno de los vídeos de una lista de reproducción, puedes utilizar el código del ejemplo anterior e incluir NULL para el título y la descripción.
Para eliminar un vídeo de una lista de reproducción, utiliza el método delete() de la entrada de lista de reproducción (PlaylistListEntry),
$playlistEntryToBeDeleted->delete();
Para eliminar una lista de reproducción, sólo tienes que utilizar el método delete() en el objeto Zend_Gdata_YouTube_PlaylistListEntry.
$playlistListEntryToBeDeleted->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/username/subscriptions
Nota: también puedes incluir la cadena default para recuperar los vídeos favoritos del usuario autenticado actualmente.
El código del siguiente ejemplo muestra cómo recuperar y mostrar la lista de
objetos SubscriptionEntry de un usuario determinado:
function getAndPrintSubscriptionFeed($userName)
{
$yt = new Zend_Gdata_YouTube();
// obtain a user's subscription feed. Alternatively you can use the string 'default'
// to retrieve subscriptions for the currently authenticated user
$subscriptionFeed = $yt->getSubscriptionFeed($userName);
printSubscriptionFeed($subscriptionFeed);
}
function printSubscriptionFeed($subscriptionFeed)
{
$count = 1;
if ($displayTitle === null) {
$displayTitle = $subscriptionFeed->title->text;
}
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
foreach ($subscriptionFeed as $subscriptionEntry) {
echo 'Entry # ' . $count . "\n";
printSubscriptionEntry($subscriptionEntry);
echo "\n";
$count++;
}
echo "</pre>\n";
}
function printSubscriptionEntry($subscriptionEntry)
{
$type = 'unknown';
$subscriptionFeedLinkMap = array(
'query' => 'http://gdata.youtube.com/schemas/2007#video.query',
'favorites' => 'http://gdata.youtube.com/schemas/2007#user.favorites',
'channel' => 'http://gdata.youtube.com/schemas/2007#user.uploads'
);
echo 'Subscription: ' . $subscriptionEntry->title->text . "\n";
// look at the category property to to determine the type of subscription,
// which is currently one of: query, favorites, channel
foreach ($subscriptionEntry->category as $category) {
if ($category->scheme == 'http://gdata.youtube.com/schemas/2007/subscriptiontypes.cat') {
$type = $category->term;
}
}
echo "\tType: " . $type . "\n";
echo "\tURL: ";
// use the map defined above to fine the appropriate feedLink, depending on
// what type of subscription entry was passed
$feedLink = $subscriptionEntry->getFeedLink($subscriptionFeedLinkMap[$type]);
if ($feedLink !== null) {
echo $feedLink->href;
}
echo "\n";
}
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".
$newSubscription = $yt->newSubscriptionEntry();
$newSubscription->extensionElements = array($yt->newUsername('GoogleDevelopers'));
$subscriptionTypesSchema = 'http://gdata.youtube.com/schemas/2007/subscriptiontypes.cat';
$newSubscription->category = array($yt->newCategory('channel', $subscriptionTypesSchema));
$subscriptionsFeedUrl = 'http://gdata.youtube.com/feeds/users/'. $userName .'/subscriptions';
// and then post using $yt->insertEntry
try {
$yt->insertEntry($newSubscription, $subscriptionsFeedUrl);
} catch (Zend_App_Exception $e) {
echo $e->getMessage();
}
También se pueden añadir suscripciones a los vídeos favoritos del usuario "GoogleDevelopers":
$newSubscription = $yt->newSubscriptionEntry();
$newSubscription->extensionElements = array($yt->newUsername('GoogleDevelopers'));
$subscriptionTypesSchema = 'http://gdata.youtube.com/schemas/2007/subscriptiontypes.cat';
$newSubscription->category = array($yt->newCategory('favorites', $subscriptionTypesSchema));
$subscriptionsFeedUrl = 'http://gdata.youtube.com/feeds/users/default/subscriptions';
// and then post using $yt->insertEntry
try {
$yt->insertEntry($newSubscription, $subscriptionsFeedUrl);
} catch (Zend_App_Exception $e) {
echo $e->getMessage();
}
Por último, existe la posibilidad de suscribirse a términos de búsqueda específicos. A continuación se muestra un ejemplo de suscripción a búsquedas de vídeos sobre "cachorros".
$newSubscription = $yt->newSubscriptionEntry();
// create a yt:querystring extension element to indicate a search for 'puppies'
$ytQuerystringValue = 'puppies';
$ytQuerystringSchema = 'http://gdata.youtube.com/schemas/2007';
$subscriptionTypesSchema = 'http://gdata.youtube.com/schemas/2007/subscriptiontypes.cat';
$newSubscription->extensionElements = array(
new Zend_Gdata_App_Extension_Element('queryString', 'yt', $ytQuerystringSchema, $ytQuerystringValue)
);
$newSubscription->category = array(
$yt->newCategory('query', $subscriptionTypesSchema)
);
// and then post using $yt->insertEntry
$subscriptionsFeedUrl = 'http://gdata.youtube.com/feeds/users/default/subscriptions';
try {
$yt->insertEntry($newSubscription, $subscriptionsFeedUrl);
} catch (Zend_App_Exception $e) {
echo $e->getMessage();
}
Esta función se abstraerá en futuras versiones de la biblioteca cliente PHP. Ofreceremos un método de ayudante para la generación y el establecimiento automáticos de un elemento de extensión yt:querystring.
Para eliminar la suscripción de un usuario, sólo tienes que ejecutar delete() en el objeto SubscriptionEntry:
$subscriptionEntryToBeDeleted->delete();
Para extraer manualmente el perfil de un usuario de YouTube, debes utilizar la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username
Puedes recuperar y mostrar el perfil de un usuario mediante el siguiente código:
function getAndPrintUserProfile($userName)
{
$yt = new Zend_Gdata_YouTube();
$userProfileEntry = $yt->getUserProfile($userName);
$displayTitle = $userProfileEntry->title->text;
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
echo 'Username: ' . $userProfileEntry->getUsername() . "\n";
echo "\tAge: " . $userProfileEntry->getAge() . "\n";
echo "\tGender: " . $userProfileEntry->getGender() . "\n";
echo "\tRelationship: " . $userProfileEntry->getRelationship() . "\n";
echo "\tBooks: " . $userProfileEntry->getBooks() . "\n";
echo "\tCompany: " . $userProfileEntry->getCompany() . "\n";
echo "\tHobbies: " . $userProfileEntry->getHobbies() . "\n";
echo "\tHometown: " . $userProfileEntry->getHometown() . "\n";
echo "\tLocation: " . $userProfileEntry->getLocation() . "\n";
echo "\tMovies: " . $userProfileEntry->getMovies() . "\n";
echo "\tMusic: " . $userProfileEntry->getMusic() . "\n";
echo "\tOccupation: " . $userProfileEntry->getOccupation() . "\n";
echo "\tSchool: " . $userProfileEntry->getSchool() . "\n";
echo "</pre>\n";
}
Ten en cuenta que la cadena default se puede utilizar en lugar de un nombre de usuario para indicar al "usuario autenticado actualmente". La biblioteca cliente utiliza los métodos mágicos sobrecargados disponibles sólo en PHP 5.2. Si utilizas PHP 5.1, tendrás que modificar las llamadas anteriores. En ese caso, algo como $userProfileEntry->getAge() se deberá cambiar por $userProfileEntry->getAge()->getTitle().
La lista de contactos de un usuario específico se puede recuperar mediante la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username/contacts
El código del siguiente ejemplo muestra cómo recuperar y mostrar la lista de contactos de un usuario determinado:
function getAndPrintContactsFeed($userName)
{
$yt = new Zend_Gdata_YouTube();
$contactsFeed = $yt->getContactsFeed($userName);
printContactsFeed($contactsFeed);
}
function printContactsFeed($contactsFeed)
{
$count = 1;
if ($displayTitle === null) {
$displayTitle = $contactsFeed->title->text;
}
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
foreach ($contactsFeed as $contactsEntry) {
echo 'Entry # ' . $count . "\n";
printContactsEntry($contactsEntry);
echo "\n";
$count++;
}
echo "</pre>\n";
}
function printContactsEntry($contactsEntry)
{
echo 'Contact: ' . $contactsEntry->title->text . "\n";
foreach ($contactsEntry->category as $category) {
if ($category->scheme == 'http://schemas.google.com/g/2005#kind') {
$type = $category->term;
}
}
echo "\tType: " . $type . "\n";
}
Para añadir un nuevo contacto como Friend, utiliza el método insertEntry del objeto de servicio Zend_Gdata_YouTube.
$newContact = $yt->newContactEntry();
$newContact->username = $yt->newUsername('newContactsUsername');
$newContact->category = array($yt->newCategory('http://gdata.youtube.com/schemas/2007#friend',
'http://schemas.google.com/g/2005#kind'));
Para aceptar o rechazar a un contacto, puedes actualizar el estado de la entrada ContactEntry correspondiente.
Para aceptar una solicitud:
$contactEntry->setStatus($yt->newStatus('accepted'));
$contactEntry->save();
Para rechazar una solicitud, sólo tienes que incluir el valor 'rejected' en el estado de la entrada ContactEntry.
Para eliminar un contacto, sólo tienes que ejecutar el método delete() en el objeto ContactEntry.
$contactToBeDeleted->delete();
Los usuarios de YouTube que se hayan aceptado mutuamente como contactos podrán enviarse mensajes. Todos los mensajes enviados a través del API deben incluir una entrada VideoEntry.
Para recuperar el contenido de los mensajes recibidos de un usuario, realiza una solicitud autenticada a la URL de los mensajes recibidos del usuario:
http://gdata.youtube.com/feeds/api/users/username/inbox
En el siguiente ejemplo se muestra el contenido de los mensajes recibidos del usuario autenticado.
$inboxFeedUrl = 'http://gdata.youtube.com/feeds/api/users/username/inbox';
$inboxFeed = $yt->getFeed($inboxFeedUrl);
function printVideoMessageFeed($inboxFeed, $displayTitle = null)
{
$count = 1;
if ($displayTitle === null) {
$displayTitle = $videoFeed->title->text;
}
echo '<h2>' . $displayTitle . "</h2>\n";
echo "<pre>\n";
foreach ($inboxFeed as $videoMessageEntry) {
echo 'Entry # ' . $count . "\n";
printVideoMessage($videoMessageEntry);
echo "\n";
$count++;
}
echo "</pre>\n";
}
function printVideoMessage($videoMessageEntry, $tabs = "")
{
echo $tabs . 'Subject: ' . $videoMessageEntry->getVideoTitle() . "\n";
echo $tabs . "\tAuthor: " . $videoEntry->getAuthor() . "\n";
echo $tabs . "\tMessage: " . $videoEntry->getVideoDescription() . "\n";
}
Para enviar un mensaje a un usuario, construye un objeto VideoEntry e insértalo en el feed de los mensajes recibidos del usuario. El siguiente código permite enviar un mensaje con un vídeo a un usuario identificado por la variable $receivingUser. Para insertar un vídeo en tu mensaje, incluye la variable video_id.
$inboxUrl = 'http://gdata.youtube.com/feeds/api/users/' . $receivingUser . '/inbox';
$videoMessageEntry = $yt->newEntry();
// pass in the ID of the video to be included in your message (required)
$newMessage = $yt->newMediaEntry();
$newMessage->id = $yt->newId('video_id');
$newMessage->title = $yt->newTitle('message title');
$newMessage->extensionElements = array($yt->newDescription('message body'));
// insert the message
try {
$yt->insertEntry($newMessage, $inboxUrl);
} catch (Zend_App_Excetion $e) {
print $e->getMessage();
}
El destinatario del mensaje debe ser un contacto aceptado del remitente del mensaje.
Para eliminar un mensaje, sólo tienes que ejecutar delete() en la entrada.
$videoMessageEntryToBeDeleted->delete();