Google Data API – YouTube

Continuando a serie de posts sobre Google Data API, hoje vamos integrar nossa aplicação ao YouTube.

Para aqueles que ainda não viram a introdução, aconselho de ler esse post primeiramente Google Data API

Integrando com o YouTube

Para usar o serviço do YouTube é um pouco diferente, temos que criar uma chave de desenvolvimento (Developer Key) que pode ser adquirida direto no site do Google http://code.google.com/apis/youtube/dashboard no final do cadastro vamos ter uma chave, veja a imagem abaixo

Agora temos que adicionar referência para a dll Google.GData.YouTube.dll em nosso projeto

Vamos implementar o método para realizar o login na API do YouTube usando a chave developer key, veja o código abaixo

[sourcecode language=”csharp”]
private YouTubeRequest Login()
{
YouTubeRequestSettings settings = new YouTubeRequestSettings("NOMEAPLICAÇÃO", "DEVELOPERKEY");
YouTubeRequest request = new YouTubeRequest(settings);
return request;
}
[/sourcecode]

A API do YouTube trabalha com feeds, que são URLs para realizar as consultas, para recuperar um feed padrão, temos que enviar uma solicitação GET HTTP para a URL associado a esse feed. Veja abaixo a URL associado a cada feed padrão:

A API permite que você recupere feeds padrão específicos da região, basta inseriro ID de região na URL. A URL a seguir demonstra o formato que deve ser usado para recuperar feeds padrão específicos da região:

http://gdata.youtube.com/feeds/api/standardfeeds/RegionID/top_rated

Onde regionID pode ser qualquer valor da tabela abaixo:

Vamos criar um pequeno exemplo para ver como que funciona essa requisição, no código abaixo podemos ver que estamos recuperando os vídeos mais populares (most_popular) e fazendo um foreach para recuperar as informações de cada vídeo e adicionando em uma lista para ser visualizada em nossa view.

[sourcecode language=”csharp”]
public ActionResult Index()
{
YouTubeRequest request = Login();
Feed<Video> videoFeed = request.Get<Video>(new Uri("http://gdata.youtube.com/feeds/api/standardfeeds/most_popular"));
List<Videos> lstVideos = printVideoFeed(videoFeed);
return View(lstVideos);
}

private List<Videos> printVideoFeed(Feed<Video> feed)
{
List<Videos> lstVideos = new List<Videos>();
foreach (Video video in feed.Entries)
{
Videos _videos = new Videos();
_videos.Id = video.VideoId;
_videos.Title = video.Title;
_videos.Description = video.Description;
_videos.Keywords = video.Keywords;
_videos.Uploaded = video.Uploader;
_videos.AverageRating = video.RatingAverage.ToString();
_videos.ViewCount = video.ViewCount.ToString();
_videos.UrlWatch = video.WatchPage.AbsoluteUri.ToString();
_videos.UrlThumb = video.Thumbnails[0].Url.ToString();
lstVideos.Add(_videos);
}
return lstVideos;
}
[/sourcecode]

Observe que no método request.Get passamos como parâmetro uma URL que pode ser qualquer uma das que descrevemos acima.

Agora se você não quer se preocupar com essas URLs podemos estas utilizando o método request.GetStandardFeed aonde não passamos uma URL explicita e sim constantes, veja abaixo um exemplo.

[sourcecode language=”csharp”]
public ActionResult Index()
{
YouTubeRequest request = Login();
Feed<Video> videoFeed = request.GetStandardFeed(YouTubeQuery.MostPopular);
List<Videos> lstVideos = printVideoFeed(videoFeed);
return View(lstVideos);
}
[/sourcecode]

Podemos ver na figura abaixo o resultado dos vídeos mais populares

Agora vamos implementar o método que realmente vai trazer o vídeo selecionado para que possamos abrir no player, veja o código abaixo o método que recupera um determinado vídeo.

[sourcecode language=”csharp”]
public ActionResult AssistirVideo(string id)
{
YouTubeRequest request = Login();
Uri videoEntryUrl = new Uri("http://gdata.youtube.com/feeds/api/videos/" + id);
Video video = request.Retrieve<Video>(videoEntryUrl);
Videos _videos = printVideo(video);
return View(_videos);
}
[/sourcecode]

Para visualizar vídeo em nossa página vamos precisar adicionar o player do Youtube apontando para a URL do vídeo (_videos.UrlWatch) que recuperamos no método printVideo, veja abaixo como ficou nossa página.

[sourcecode language=”csharp”]
@model GoogleGData.Controllers.Videos

<table>
<tr>
<td>
<h2>@Html.DisplayFor(model => model.Title)</h2>
<p>@Html.DisplayFor(model => model.Description)</p>
<p>
<object>
<param name="movie" value="@Model.Url" />
<param name="allowFullScreen" value="true" />
<param name="allowscriptaccess" value="always" />
<embed src="@Model.Url"
type="application/x-shockwave-flash"
allowscriptaccess="always"
allowfullscreen="true"
width="580"
height="360" >
</embed>
</object>
</p>
<p>Keywords: @Html.DisplayFor(model => model.Keywords)</p>
<p>Uploaded: @Html.DisplayFor(model => model.Uploaded)</p>
<p>AverageRating: @Html.DisplayFor(model => model.AverageRating)</p>
<p>ViewCount: @Html.DisplayFor(model => model.ViewCount)</p>
</td>
</tr>
</table>

<p>
@Html.ActionLink("Voltar", "Index")
</p>
[/sourcecode]

Podemos ver na figura abaixo o vídeo selecionado com as informações básicas.

Agora vamos visualizar os comentários do vídeo, para isso temos que chamar o método GetComments passando como parâmetro o próprio vídeo selecionado, o retorno é uma lista de objetos do tipo Google.YouTube.Comment, veja abaixo o código.

[sourcecode language=”csharp”]
public ActionResult AssistirVideo(string id)
{
YouTubeRequest request = Login();
Uri videoEntryUrl = new Uri("http://gdata.youtube.com/feeds/api/videos/" + id);
Video video = request.Retrieve<Video>(videoEntryUrl);
Videos _videos = printVideo(video);

// comments videos
Feed<Google.YouTube.Comment> comments = request.GetComments(video);
List<Comentarios> lstComentarios = printVideoComments(comments);
_videos.CommentsVideos = lstComentarios;

return View(_videos);
}

private List<Comentarios> printVideoComments(Feed<Google.YouTube.Comment> comments)
{
List<Comentarios> lstComentarios = new List<Comentarios>();

foreach (Google.YouTube.Comment c in comments.Entries)
{
Comentarios _com = new Comentarios();
_com.Author = c.Author;
_com.Text = c.Content;
_com.Title = c.Title;
lstComentarios.Add(_com);
}

return lstComentarios;
}
[/sourcecode]

Veja o resultado abaixo:

Agora vamos visualizar os vídeos relacionados com o que estamos assistindo, para isso temos que chamar o método GetRelatedVideos passando como parâmetro o próprio vídeo selecionado, o retorno é uma lista de objetos do tipo Google.YouTube.Video, veja abaixo 9 o código.

[sourcecode language=”csharp”]
public ActionResult AssistirVideo(string id)
{
YouTubeRequest request = Login();
Uri videoEntryUrl = new Uri("http://gdata.youtube.com/feeds/api/videos/" + id);
Video video = request.Retrieve<Video>(videoEntryUrl);
Videos _videos = printVideo(video);

// comments videos
Feed<Google.YouTube.Comment> comments = request.GetComments(video);
List<Comentarios> lstComentarios = printVideoComments(comments);
_videos.CommentsVideos = lstComentarios;

//Retrieving related videos
Feed<Video> relatedVideos = request.GetRelatedVideos(video);
List<Videos> lstVideos = printVideoFeed(relatedVideos);
_videos.RelatedVideos = lstVideos;

return View(_videos);
}
[/sourcecode]

Veja o resultado abaixo

Agora vamos implementar o método para porcurar videos que segue o mesmo padrão de codificação que já vimos anteriormente, recuperamos a chave que estamos procurando e passamos como parâmetro para o objeto query veja abaixo o código

[sourcecode language=”csharp”]
public ActionResult ProcurarVideos(string valor)
{
YouTubeRequest request = Login();

YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
query.OrderBy = "viewCount";
query.Query = valor;
query.SafeSearch = YouTubeQuery.SafeSearchValues.None;

Feed<Video> videoFeed = request.Get<Video>(query);
List<Videos> lstVideos = printVideoFeed(videoFeed);
return View(lstVideos);
}
[/sourcecode]

Podemos perceber como é extremamente fácil integrar com os serviços do google com essa API

Aquele Abraço!

Sobre Leandro Prado

Leandro Silveira Prado é Premier Field Engineer na Microsoft especializado em Application Lifecycle Management.