Procurar e Integrar o Google Buzz Streams com PHP

Use PHP para processar e integrar fluxos de atividade do Google Buzz com um aplicativo da Web

Google Buzz permite aos usuários postar atualizações de status em tempo real, notícias e conteúdo na sua Conta Google e subscrever para atualizações semelhantes de outros. Os desenvolvedores de aplicativos da Web conseguem acessar e procurar esse conteúdo por meio da API REST do Google Buzz. Este artigo apresenta a API do Google Buzz e a demonstra no conteúdo de um aplicativo PHP, explicando como procurar, recuperar, incluir e editar diferentes tipos de conteúdo no Google Buzz.

Introdução

Acrônimos usados frequentemente

  • API: Interface de programação de aplicativos
  • DOM: Document Object Model
  • HTTP: Protocolo de transporte de Hipertexto
  • JSON: Notação de objeto JavaScript
  • REST: REpresentational State Transfer
  • URL: Localizador Uniforme de Recursos
  • XML: Linguagem de marcação extensível

Desde seu lançamento em fevereiro de 2010, o Google Buzz tem criado..., bem, muitos rumores. Ao permitir aos usuários o compartilhamento de conteúdo rico como vídeos e fotos, além de oferecer atualizações de status simples, Buzz tornou-se rapidamente um dos serviços mais populares do Google e a forte integração com o Gmail também não atrapalha!

Se você for desenvolvedor da Web, existe mais motivos ainda para se entusiasmar com o Google Buzz. Como muitos outros serviços Google, o Google Buzz vem com uma API do desenvolvedor que permite trabalhar diretamente no núcleo do serviço e criar seus próprios mashups em cima dele. E como a API usa REST, é possível integrá-la facilmente com a maioria dos kits de ferramentas de programação—incluindo a que uso com mais frequência, PHP.

Este artigo apresenta a API do Google Buzz, mostrando como integrar e usar conteúdo do Google Buzz com aplicativos PHP. Então, vamos começar!


Entendendo as alimentações do Google Buzz

Antes de começar a desenvolver aplicativos com o Google Buzz, é necessário entender como ele funciona. Do mesmo modo que com todos os serviços baseados em REST, as coisas começam com uma solicitação de HTTP para um recurso designado. A solicitação de HTTP contém uma consulta com um ou mais parâmetros de entrada. O servidor responde a consulta com um feed Atom ou JSON. O "verbo" HTTP usado na solicitação—GET para leituras, POST e PUT para gravações e DELETE para exclusões—indica o tipo de ação solicitada e o código de status HTTP retornado pelo servidor indica se a ação foi bem-sucedida ou não.

Para ver como isso funciona, conecte-se à sua Conta Google e tente solicitar a URL https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@public no seu navegador da Web favorito. Lembre-se de substituir a cadeia de caractere YOUR_ID na URL pelo seu ID do Google que ele pode ser obtido na sua URL do Google Profile, a qual está exibida na página Google Account Settings. A resposta a essa solicitação (que pode ser visualizada no código de origem da página resultante) conterá uma lista das suas postagens mais recentes no Google Buzz e poderá ter uma aparência semelhante a listagem 1:

Listagem 1. Um exemplo de alimentação do Google Buzz
<?xml version="1.0" encoding="UTF-8"?>
<feed gd:kind="buzz#activityFeed"
  xmlns="http://www.w3.org/2005/Atom"
  xmlns:activity="http://activitystrea.ms/spec/1.0/"
  xmlns:buzz="http://schemas.google.com/buzz/2010"
  xmlns:crosspost="http://purl.org/syndication/cross-posting"
  xmlns:gd="http://schemas.google.com/g/2005"
  xmlns:georss="http://www.georss.org/georss"
  xmlns:media="http://search.yahoo.com/mrss/"
  xmlns:poco="http://portablecontacts.net/ns/1.0"
  xmlns:thr="http://purl.org/syndication/thread/1.0">
  <link href="http://pubsubhubbub.appspot.com/" rel="hub"/>
  <link
   href="https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@public?alt=atom"
   rel="self" type="application/atom+xml"/>
  <title type="text">Google Buzz Public Feed</title>
  <updated>2010-11-23T18:16:47.108Z</updated>
  <id>tag:google.com,2010:buzz-feed:public:posted:YOUR_ID</id>
  <generator uri="http://www.google.com/buzz">Google Buzz</generator>
  <entry gd:kind="buzz#activity">
    <title>Watching it rain and planning tomorrow's shopping</title>
    <published>2010-06-18T14:13:51.000Z</published>
    <updated>2010-11-23T14:13:51.400Z</updated>
    <id>tag:google.com,2010:buzz:s12ard75xvreh35</id>
    <link href="http://www.google.com/buzz/YOUR_ID/fqFn7S27Va4" rel="alternate"
     type="text/html"/>
    <link href="https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@self/
     tag:google.com,2010:buzz:s12ard75xvreh35?alt=atom" rel="self"
     type="application/atom+xml"/>
    <link href="https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@self/
     tag:google.com,2010:buzz:s12ard75xvreh35/@comments?alt=atom" rel="replies"
     thr:count="0" thr:updated="2010-11-23T14:13:51.400Z"
     type="application/atom+xml"/>
    <author>
      <poco:id>YOUR_ID</poco:id>
      <poco:photoUrl/>
      <name>Vikram Vaswani (Melonfire)</name>
      <uri>http://www.google.com/profiles/YOUR_ID</uri>
      <link href="" rel="photo" type="image/jpeg"/>
      <activity:object-type>http://activitystrea.ms/schema/1.0/
       person</activity:object-type>
    </author>
    <content type="text/html">Watching it rain and planning
     tomorrow&#39;s shopping</content>
    <activity:verb>http://activitystrea.ms/schema/1.0/post
     </activity:verb>
    <activity:object>
      <activity:object-type>http://activitystrea.ms/schema/1.0/note
       </activity:object-type>
      <content type="text/html">Watching it rain and planning
       tomorrow&#39;s shopping</content>
      <buzz:original-content type="text"/>
      <link href="http://www.google.com/buzz/YOUR_ID/fqFn7S27Va4"
       rel="alternate" type="text/html"/>
    </activity:object>
    <source>
      <activity:service>
        <title>Buzz</title>
      </activity:service>
    </source>
    <buzz:visibility>
      <buzz:aclentry type="group">
        <poco:id>tag:google.com,2010:buzz-group:@me:@public</poco:id>
        <uri>https://www.googleapis.com/buzz/v1/people/@me/
         @groups/@public?alt=atom</uri>
        <poco:name>Public</poco:name>
      </buzz:aclentry>
    </buzz:visibility>
    <link buzz:count="0" href="https://www.googleapis.com/buzz/v1/
     activities/YOUR_ID/@self/tag:google.com,2010:buzz:s12ard75xvreh35/
     @liked?alt=atom" rel="http://schemas.google.com/buzz/2010#liked"
     type="application/poco+xml"/>
  </entry>
  <entry>
  ...
  </entry>
</feed>

A API do Google Buzz responde a solicitações REST com um feed Atom ou JSON que contém os dados solicitados. Google Buzz oferece várias alimentações interessantes, incluindo:

  • A alimentação de atividade por usuário, que contém todas as postagens públicas de um usuário específico
  • A alimentação de atividade global, que contém todas as postagens públicas no Google Buzz
  • A alimentação de comentários por atividade, que contém uma lista de comentários do usuário sobre uma atividade específica
  • A alimentação de pessoa por usuário, que contém uma lista de usuários que seguem e são seguidos por um usuário específico

Algumas dessas alimentações são acessíveis e pesquisáveis publicamente. Outras estão disponíveis somente ao proprietário da alimentação após autenticação bem-sucedida. A maioria das alimentações suporta operações de leitura e gravação com autenticação, isso significa que um usuário autenticado pode postar programaticamente novo conteúdo na sua alimentação de atividade pública ou gravar comentários nas alimentações públicas de outro usuário por meio da API do Google Buzz.

A própria alimentação é uma alimentação feed Atom padrão com o elemento <feed> mais externo contendo elementos <link> com URLs para a página atual (e, onde aplicável, as páginas próxima e anterior) do conjunto de resultados. O elemento <feed> mais externo também contém um ou mais elementos <entry> que representam uma postagem do Google Buzz. Cada entrada contém metadados descritivos, incluindo o ID da postagem, o título, o autor, a data da publicação e a URL. Cada <entry> também contém um elemento <author> que fornece o ID do perfil, a URL do perfil, a URL da foto e o nome do autor da postagem e elementos <link> que fornecem links de URL para a alimentação de comentários de postagem ou a alimentação "like".

Vale a pena destacar que os elementos <activity:> com namespace, que fornecem informações específicas sobre a atividade do Google Buzz. O elemento <activity:verb> especifica o tipo de atividade, enquanto o elemento <activity:object> especifica o conteúdo da atividade.

Antes de continuar, observe que o uso de conteúdo do Google Buzz em aplicativos de terceiros é controlado pelos Termos de Serviço do Google Buzz. O seu aplicativo também deve atender as Diretrizes de Marca e as Políticas de Desenvolvedor do Google Buzz. Vale a pena, enquanto lê estes documentos antes de iniciar o desenvolvimento, garantir o atendimento de todas as regras necessárias. Consulte os detalhes de Recursos para obter links para essas três diretrizes.


Recuperando postagens públicas

Agora que você sabe como acessar alimentações de atividade do Google Buzz através da API REST pública, veja como fazer a mesma coisa de dentro de um aplicativo PHP. Uma maneira é usar as extensões de processamento XML integradas do PHP (SimpleXML, DOM ou XMLReader) para analisar o feed Atom retornado pelo Google Buzz e extrair os fragmentos de informações relevantes. No entanto, isso pode ser muito cansativo, principalmente se estiver lidando com alimentações grandes ou grandes volumes de informações com namespace.

Existem duas outras abordagens mais convenientes:

  • O componente Zend_Rest_Client no Zend Framework é projetado especificamente para desenvolvedores que tentam integrar aplicativos PHP com serviços da Web baseados em REST. Esse cliente é usado para executar respostas GET, POST, PUT e DELETE para um terminal de serviço REST. As respostas REST são retornadas como instâncias de objetos Zend_Rest_Client_Response, o que torna fácil acessar propriedades de respostas individuais.
  • A Google Buzz PHP Client Library é uma biblioteca de cliente de software livre projetada especificamente para uso com alimentações do Google Buzz. Essa biblioteca também retorna alimentações do Google Buzz como objetos PHP nativos, simplificando o acesso a dados.

Para usar a Google Buzz PHP Client Library também será necessário registrar seu aplicativo da Web no Google e obter o segredo de consumidor OAuth necessário para a autenticação OAuth. Instruções e links de download para as duas bibliotecas podem ser encontrados em Recursos . Ao instalar essas bibliotecas, lembre-se de atualizar o 'include_path' do seu PHP para refletir sua localização.

Qual dessas duas opções é melhor? No momento, a Google Buzz PHP Client Library tem uma vantagem porque também inclui suporte de autenticação OAuth. Esse suporte reduz de maneira significativa o trabalho envolvido em enviar solicitações autenticadas ao serviço Google Buzz. Usuários especialistas ainda podem combinar a biblioteca Zend_Rest_Client com o componente Zend_Oauth para obter o mesmo resultado, mas o processo é um pouco mais complexo. Por isso, os exemplos neste artigo usarão a Google Buzz PHP Client Library, embora os primeiros exemplos demonstrem também o uso da biblioteca Zend_Rest_Client para solicitações não autenticadas.

listagem 2 ilustra como usar a Google Buzz PHP Client Library para recuperar e analisar a alimentação de atividade pública de um usuário (a mesma alimentação na listagem 1):

Listagem 2. Listagem de postagens públicas com o cliente Buzz PHP
<?php
// include PHP client library
require_once 'buzz.php';

try {
  // set up file store
  $storage = new buzzFileStorage('/tmp/cache');

  // get user ID
  $uid = 1;

  // perform authentication with Google
  $auth = buzzOAuth::performOAuthLogin($storage, $uid);

  // initialize Buzz object
  $buzz = new buzz($storage, $auth);

  // fetch authenticated user's public feed
  $result = $buzz->getPosts('@public', '@me');

  // iterate through feed data
  echo '<h1>' . $result->title . '</h1>';
  echo count($result->posts) . ' post(s) found. <br/>';
  echo '<ol>';
  foreach ($result->posts as $post) {
    echo '<li>';
    echo isset($post->links['alternate'][0]->href) ? 
     '<a href="' . $post->links['alternate'][0]->href . 
     '">' . $post->title . '</a>' : $post->title;
    echo ' (' . date("d M Y h:i", strtotime($post->published)) . ')';
    echo '</li>';
  }
  echo '</ol>';
} catch (Exception $e) {
  echo 'ERROR:' . $e->getMessage();
}
?>

listagem 2 começa incluindo os arquivos de origem e, em seguida, criando um novo buzz . Esse objeto buzz serve como um ponto de comunicação central com a API do Google Buzz, expondo numerosos métodos para acessar dados do Google Buzz. Para reinicializar o objeto, passe dois argumentos ao construtor:

  • Um objeto buzzStorage configurado corretamente, que especifica como o armazenamento em cache local ocorrerá. A Google Buzz PHP Client Library suporta Alternative PHP Cache (APC), memcached e armazenamento em cache baseado em arquivos, representado pelas classes buzzApcStorage, buzzMemcacheStoragee pela buzzFileStorage respectivamente.
  • Um objeto buzzOAuth configurado corretamente. Esse objeto é gerado pelo método buzzOAuth::performOAuthLogin() estático, que aceita dois argumentos: um objeto buzzStorage e um identificador de usuário local. A opção buzzOAuth::performOAuthLogin() se encarrega da execução da autenticação OAuth com os servidores Google, exibindo os prompts apropriados ao usuário para conceder ou negar o acesso do aplicativo aos dados do Google Buzz do usuário e executando o redirecionamento necessário.

Após criar o objeto buzz primário, é possível usar o método getPosts() do objeto para acessar uma alimentação de atividade do usuário. Esse método aceita cinco argumentos: o tipo de alimentação, o ID do usuário e o número de comentários, likes e postagens para incluir nos resultados da alimentação. O valor de retorno desse método é uma série de objetos PHP aninhados, cada um representando uma entrada na alimentação de resultado Atom. Agora fica bem fácil iterar sobre essa coleção de objetos, extraindo informações relevantes para exibição usando notação objeto->propriedade padrão. Figura 1 ilustra a aparência do resultado.

Figura 1. Uma lista de postagens públicas
Uma lista de postagens públicas

Um resumo rápido sobre os tipos de alimentação. A API do Google Buzz oferece três tipos de alimentação:

  1. A alimentação public do usuário, que contém as postagens públicas do usuário e é referenciada como @public. Essa alimentação geralmente está localizada em https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@public
  2. A alimentação consumption do usuário, que contém postagens de usuários que estão sendo seguidos e é referenciada como @consumption. Essa alimentação geralmente está localizada em https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@consumption
  3. A alimentação personal do usuário, que contém as postagens públicas e privadas do usuário e é referenciada como @personal. Essa alimentação geralmente está localizada em https://www.googleapis.com/buzz/v1/activities/YOUR_ID/@personal

As alimentações pessoais e consumo precisam de autenticação, enquanto que a alimentação pública não precisa. A cadeia de caractere do ID do usuário especial @me também pode ser usada como um atalho conveniente para referir-se ao "usuário autenticado atualmente" em vez do ID numérico do Google.

Listagem 3 produz um resultado equivalente à listagem 2 usando a bibliotecaZend_Rest_Client:

Listagem 3. Listando postagens públicas com o cliente Zend REST
<?php
// load Zend classes
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Rest_Client');

try {
  // get feed of user public activities
  $client = new Zend_Rest_Client('https://www.googleapis.com/buzz/v1/
   activities/YOUR_ID_HERE/@public');
  $result = $client->get();

  // iterate through returned feed
  echo '<h1>' . $result->title . '</h1>';
  echo count($result->entry) . ' post(s) found. <br/>';
  echo '<ol>';
  foreach ($result->entry as $entry) {
    echo '<li>';
    echo isset($entry->link[0][@href]) ? '<a href="' . 
     $entry->link[0][@href] . '">' . $entry->content . 
     '</a>' : $entry->content;
    echo ' (' . date("d M Y h:i", strtotime($entry->published)) . ')';
    echo '</li>';
  }
  echo "</ol>";

} catch (Exception $e) {
  echo 'ERROR:' . $e->getMessage();
}
?>

listagem 3 primeiro carrega as bibliotecas classe Zend e, em seguida, inicializa uma instância da classe Zend_Rest_Client. Use esse cliente para inicializar uma solicitação GET não autenticada para a alimentação pública do usuário, como foi feito anteriormente na listagem 1. Observe que a URL de alimentação nesse caso deve conter o ID do Perfil Google do usuário. A feed Atom retornada é analisada e convertida em um objeto Zend_Rest_Client_Response. Como antes, agora fica bem fácil iterar sobre essa coleção de objetos e extrair os detalhes de postagens específicas.


Procura em postagens públicas

Seria incomum se a API do Google Buzz deixasse de incluir um recurso de procura, afinal, é Google. Assim, a API oferece uma alimentação de procura pública que pode ser usada para procurar em todas as postagens públicas por todos os usuários e retornar as que correspondem a um termo de procura especificado. Essa alimentação de procura pública é acessível em https://www.googleapis.com/buzz/v1/activities/search.

Se estiver usando a Google Buzz PHP Client Library, você pode simplesmente chamar o método search() e passar-lhe seu termo de consulta. listagem 4 ilustra:

Listagem 4. Procurando postagens com o cliente Buzz PHP
<!DOCTYPE html 
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Searching public activity feeds</title>
<style>
body {
font-family: Verdana;      
}
li {
border-bottom: solid black 1px;      
margin: 10px; 
padding: 2px; 
width: auto;
padding-bottom: 20px;
}
</style>    
</head>
<body>  
<form method="post" 
action="<?php echo $_SERVER['PHP_SELF']; ?>">
Search for: <input type="text" name="q" />
<input type="submit" name="submit" value="Search">
</form>    
<?php

if (isset($_POST['submit'])) {
// include PHP client library
require_once 'buzz.php';

try {
// set up file store
$storage = new buzzFileStorage('/tmp/cache');

// get user ID
$uid = 1;

// perform authentication with Google 
$auth = buzzOAuth::performOAuthLogin($storage, $uid);

// initialize Buzz object  
$buzz = new buzz($storage, $auth);

// fetch authenticated user's public feed
$result = $buzz->search($_POST['q']);

// iterate through feed data
echo '<h1>' . $result->title . '</h1>';
echo count($result->posts) . ' post(s) found. <br/>';
echo '<ol>';
foreach ($result->posts as $post) {
echo '<li>';
echo isset($post->links['alternate'][0]->href) ? 
'<a href="' . $post->links['alternate'][0]->href . 
'">' . $post->title . '</a><br/>' : 
$post->title . '<br/>';
echo $post->person->name . ' (' . 
date("d M Y h:i", strtotime($post->published)) . ')';  
echo '</li>';
}
echo '</ol>';
} catch (Exception $e) {
echo 'ERROR:' . $e->getMessage();  
}
}
?>
</body>
</html>

listagem 4 começa exibindo um formulário da Web para o usuário inserir um ou mais termos de procura. Após esse formulário ser enviado, o script cria um novo objeto buzz e passa os termos de procura para o search() do objeto. Esse método gera a solicitação REST necessária para a API do Google Buzz e converte a alimentação de resultado em uma coleção de objetos buzzPost . Tudo que resta a fazer agora é efetuar loop pela coleção, imprimindo o conteúdo, o autor e a data de publicação de cada um.

Figura 2 ilustra o resultado de uma procura por chocolate.

Figura 2. O resultado de uma procura do Google Buzz
O resultado de uma procura do Google Buzz

Como a alimentação de procura é pública, também é possível consultá-la usando qualquer cliente HTTP não autenticado. listagem 5 ilustra a utilização da biblioteca Zend_Rest_Client para solicitar diretamente a URL da alimentação de procura e processar a resposta:

Listagem 5. Procurando postagens com o cliente Zend REST
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Searching public activity feeds</title>
    <style>
    body {
      font-family: Verdana;
    }
    li {
      border-bottom: solid black 1px;
      margin: 10px;
      padding: 2px;
      width: auto;
      padding-bottom: 20px;
    }
    </style>
  </head>
  <body>
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for: <input type="text" name="q" />
    <input type="submit" name="submit" value="Search">
    </form>
    <?php

    if (isset($_POST['submit'])) {
      // load Zend classes
      require_once 'Zend/Loader.php';
      Zend_Loader::loadClass('Zend_Rest_Client');

      try {
        if (empty($_POST['q'])) {
          throw new Exception('No search term provided');
        }

        // search all feeds
        $url = 'https://www.googleapis.com/buzz/v1/activities/search?q=' . 
         urlencode($_POST['q']);
        $client = new Zend_Rest_Client($url);
        $result = $client->get();

        // iterate through returned feed
        // display results
        echo '<h1>' . $result->title . '</h1>';
        echo count($result->entry) . ' post(s) found. <br/>';
        echo '<ol>';
        foreach ($result->entry as $entry) {
          echo '<li>';
          echo '<a href="' . $entry->link[0][@href] . '">' . 
           $entry->content . '</a><br/>';
          echo $entry->author->name;
          echo ' (' . date("d M Y h:i", strtotime($entry->published)) . ')';
          echo '</li>';
        }
        echo "</ol>";
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

listagem 5 inicializa um novo cliente REST e o utiliza para enviar uma solicitação GET não autenticada para a alimentação de procura pública. Os parâmetros de procura fornecidos pelo usuário são codificados com URL e anexados à solicitação por meio do q especial. Use um loop foreach() para iterar sobre a coleção de objetos resultante, como na listagem 3, para produzir saída equivalente à da listagem 4.

Como acontece com outras alimentações Google, a API do Google Buzz permite aos desenvolvedores customizar a saída adicionando os seguintes parâmetros à solicitação REST:

  • O parâmetro alt , que especifica o formato da alimentação ('atom' ou 'json')
  • O parâmetro max-results , que especifica o número máximo de entradas a recuperar
  • O parâmetro max-comments , que especifica o número máximo de comentários a recuperar por entrada
  • Os parâmetros lat elon , que especificam filtros geográficos para os resultados da procura

Também é possível anexar operadores de consulta de procura avançada à URL da solicitação. Consulte o Guia dos Desenvolvedores de API do Google Buzz (consulte Recursos para obter um link) a fim de obter uma lista completa de operadores, com exemplos.


Incluindo, editando e excluindo postagens

Isso é responsável pela listagem e procura de postagens. Agora, que tal incluir, editar e excluí-las?

Como API compatível com REST, a API do Google Buzz suporta o uso de verbos HTTP regulares para indicar o tipo de ação requerida. Portanto, para adicionar uma nova postagem, basta enviar uma solicitação POST autenticada à URL da alimentação, anexando o conteúdo da postagem ao corpo da solicitação. Em um estilo semelhante, para editar ou excluir uma postagem envia-se uma solicitação PUT ou DELETE contendo o ID da postagem para a URL de alimentação.

Para tornar as coisas mais simples para os desenvolvedores, a Google Buzz PHP Client Library encapsula as tarefas acima em dois métodos: updatePost() edeletePost(). Para ilustrar, considere a listagem 6, que demonstra como adicionar uma nova postagem do Google Buzz com PHP:

Listagem 6. Incluindo postagens
<?php
// include PHP client library
require_once 'buzz.php';

try {
  // set up file store
  $storage = new buzzFileStorage('/tmp/cache');

  // get user ID
  $uid = 1;

  // perform authentication with Google
  $auth = buzzOAuth::performOAuthLogin($storage, $uid);

  // initialize Buzz object
  $buzz = new buzz($storage, $auth);

  // add a new post
  $object = new buzzObject('Adding this post through the Buzz API...woohoo!');
  $post = buzzPost::createPost($object);
  $result = $buzz->updatePost($post);
  echo 'Added new post with ID: ' . $result->id;
} catch (Exception $e) {
  echo 'ERROR:' . $e->getMessage();
}
?>

A primeira ordem de negócios é criar uma nova instância buzz . Em seguida, criar uma nova instância buzzObject e inicializá-la com o conteúdo a ser postado. Em seguida, esse buzzObject é convertido em uma entrada do Google Buzz através do método buzzPost::createPost() e usa o método updatePost() para POST do pacote de solicitações inteiro nos servidores do Google Buzz. Após a nova postagem ser criada, o servidor envia de volta um código de status 201 (Created) e um fragmento <entry> completo representando a postagem recém-incluída.

Figura 3 ilustra a saída de A listagem 6:

Figura 3. O resultado da inclusão de uma nova postagem do Google Buzz
O resultado da inclusão de uma nova postagem do Google Buzz

Editar uma postagem é um pouco diferente: é necessário primeiro criar uma nova postagem e, em seguida, definir seu ID para o ID da postagem que deseja substituir. listagem 7 ilustra:

Listagem 7. Modificando postagens
<?php
// include PHP client library
require_once 'buzz.php';

try {
  // set up file store
  $storage = new buzzFileStorage('/tmp/cache');

  // get user ID
  $uid = 1;

  // perform authentication with Google
  $auth = buzzOAuth::performOAuthLogin($storage, $uid);

  // initialize Buzz object
  $buzz = new buzz($storage, $auth);

  // edit a post
  $object = new buzzObject('Updating this post through the Buzz API...yeehaw!');
  $post = buzzPost::createPost($object);
  $post->id = 'tag:google.com,2010:buzz:z133';
  $result = $buzz->updatePost($post);
  echo 'Updated post with ID: ' . $result->id;
} catch (Exception $e) {
  echo 'ERROR:' . $e->getMessage();
}
?>

Na listagem 7, o código inicializa um novo objeto buzzPost com o conteúdo correto e define seu ID para o ID da postagem a ser editada. O método updatePost() envia em seguida uma solicitação PUT aos servidores do Google Buzz com a entrada revisada. Se bem-sucedido, o servidor responderá com um código de status 201 (OK) e a <entry> revisada. Figura 4 ilustra a saída provável:

Figura 4. O resultado de editar uma postagem do Google Buzz
O resultado de editar uma postagem do Google Buzz

Excluir uma postagem é comparativamente simples: forneça o ID da postagem ao método deletePost() e a Google Buzz PHP Client Library construirá e transmitirá uma solicitação DELETE para a API REST. A listagem 8 ilustra o processo:

Listagem 8. Excluindo postagens
<?php
// include PHP client library
require_once 'buzz.php';

try {
  // set up file store
  $storage = new buzzFileStorage('/tmp/cache');

  // get user ID
  $uid = 1;

  // perform authentication with Google
  $auth = buzzOAuth::performOAuthLogin($storage, $uid);

  // initialize Buzz object
  $buzz = new buzz($storage, $auth);

  // delete a post
  $id = 'tag:google.com,2010:buzz:z13';
  $buzz->deletePost($id);
  echo 'Deleted post with ID: ' . $id;
} catch (Exception $e) {
  echo 'ERROR:' . $e->getMessage();
}
?>

Figura 5 exibe a saída:

Figura 5. O resultado de excluir uma postagem do Google Buzz
O resultado de excluir uma postagem do Google Buzz

Procurando usuários

Além de permitir procurar por palavras-chave, a API do Google Buzz também permite procurar pessoas pelo nome. Isso é realizado enviando uma solicitação HTTP GET à URL https://www.googleapis.com/buzz/v1/people/search, anexando a ela os termos de procura necessários. A resposta a essa solicitação é uma alimentação Atom ou JSON contendo uma lista de usuários correspondentes, junto com seu nome e ID do Google.

listagem 9 ilustra como fazer isso usando a Google Buzz PHP Client Library:

Listagem 9. Procurando usuários com o cliente Buzz PHP
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Searching for people</title>
    <style>
    table {
      border-collapse: yes;
    }
    tr {
      border-bottom: solid black 1px;
    }
    td {
      vertical-align: top;
      border: solid black 1px;
    }
    li {
      margin: 10px;
      padding: 2px;
      width: auto;
      padding-bottom: 20px;
    }
    </style>
  </head>
  <body>
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for people: <input type="text" name="q" />
    <input type="submit" name="submit" value="Search">
    </form>
    <?php
    if (isset($_POST['submit'])) {
      // include PHP client library
      require_once 'buzz.php';

      try {
        // set up file store
        $storage = new buzzFileStorage('/tmp/cache');

        // get user ID
        $uid = 1;

        // perform authentication with Google
        $auth = buzzOAuth::performOAuthLogin($storage, $uid);

        // initialize Buzz object
        $buzz = new buzz($storage, $auth);

        // fetch authenticated user's public feed
        $result = $buzz->searchPeople($_POST['q']);

        // iterate through feed data
        echo '<h1>Search Results</h1>';
        echo '<table>';
        foreach ($result as $person) {
          echo '<tr>';
          // display user full name and photo
          echo '<td><img src="' . $person->thumbnailUrl . 
           '" /><br/>';
          echo '<strong>' . $person->name . 
           '</strong></td><td>';

          // fetch user's public feed
          $result = $buzz->getPosts('@public',
           $person->id, false, false, 3);

          // iterate through feed data
          echo 'Recent updates: <br/>';
          echo '<ol>';
          foreach ($result->posts as $post) {
            echo '<li>';
            $url = isset($post->links->self[0]->href) ? 
             $post->links->self[0]->href : '#';
            echo '<a href="' . $url . '">' . $post->title . '</a>';
            echo ' (' . date("d M Y h:i", strtotime($post->published)) . ')';
            echo '</li>';
          }
          echo '</ol></td>';
          echo '</tr>';
        }
        echo '</table>';
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

A listagem 9 pede ao usuário para inserir o nome de uma pessoa em um formulário de procura e usa o método searchPeople() para consultar a API do Google Buzz para obter pessoas correspondentes. O valor de retorno desse método é uma coleção de objetos buzzPerson , e cada um destes contém informações sobre o usuário: nome e sobrenome, ID do Google, URL do Perfil do Google, URL da foto e outras informações pessoais. A listagem 9 extrai essas informações e utiliza o ID do Google com o método getPosts() para recuperar também as três postagens mais recentes do usuário. Todas essas informações são formatadas em uma página da Web legível, como na Figura 6..

Figura 6. O resultado de uma procura por pessoas no Google Buzz
O resultado de uma procura por pessoas no Google Buzz

A listagem 10 oferece uma alternativa à listagem 9, usando a biblioteca Zend_Rest_Client para obter o mesmo resultado:

Listagem 10. Procurando usuários com o cliente Zend REST
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Searching for people</title>
    <style>
    table {
      border-collapse: yes;
    }
    tr {
      border-bottom: solid black 1px;
    }
    td {
      vertical-align: top;
      border: solid black 1px;
    }
    li {
      margin: 10px;
      padding: 2px;
      width: auto;
      padding-bottom: 20px;
    }
    </style>
  </head>
  <body>
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for people: <input type="text" name="q" />
    <input type="submit" name="submit" value="Search">
    </form>
    <?php
    if (isset($_POST['submit'])) {
      // load Zend classes
      require_once 'Zend/Loader.php';
      Zend_Loader::loadClass('Zend_Rest_Client');

      try {
        if (empty($_POST['q'])) {
          throw new Exception('No search term provided');
        }

        // search people feed
        $client = new Zend_Rest_Client('https://www.googleapis.com/buzz/v1/
         people/search?q=' . urlencode($_POST['q']));
        $result = $client->get();

        // iterate through returned feed
        // for each result, display user name and photo
        echo '<h1>Search Results</h1>';
        echo '<table>';
        foreach ($result->entry as $entry) {
          echo '<tr>';
          echo '<td><img src="' . $entry->thumbnailUrl . 
           '" /><br/>';
          echo $entry->displayName . '</td><td>';
          // get feed of user's three most recent public posts
          $client2 = new Zend_Rest_Client('https://www.googleapis.com/buzz/
           v1/activities/' . $entry->id . '/@public?max-results=3');
          $result2 = $client2->get();
          echo 'Recent updates: <br/>';
          echo '<ol>';
          foreach ($result2->entry as $entry2) {
            echo '<li>';
            echo '<a href="' . $entry2->link[0][@href] . '">' . 
             $entry2->content . '</a>';
            echo ' (' . date("d M Y h:i", strtotime($entry2->published)) . ')';
            echo '</li>';
          }
          echo "</ol></td>";
          echo '</tr>';
        }
        echo '</table>';
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

A listagem 10 usa a biblioteca Zend_Rest_Client para acessar diretamente o terminal REST para o serviço de procura de pessoas, retornando uma representação de objeto de um feed Atom. Essa coleção de objetos pode ser usada conforme necessário para extrair informações relevantes. Neste caso, observe que o termo de consulta deve ser codificado por URL manualmente.


Gerenciando seguidores

Google Buzz permite que os usuários "sigam" uns aos outros. Seguir um usuário automaticamente torna suas postagens parte da alimentação de consumo de um usuário. A API do Google Buzz torna essas informações disponíveis através das alimentações follower efollowing nas URLs https://www.googleapis.com/buzz/v1/people/YOUR_ID/@groups/@followers e https://www.googleapis.com/buzz/v1/people/YOUR_ID/@groups/@following respectivamente.

Para obter essas informações usando a biblioteca de cliente PHP, use os métodos followers() efollowing() , que retornam coleções de objetos buzzPerson representando os seguidores e os seguidos do usuário. A listagem 11 contém um exemplo:

Listagem 11. Listando seguidores e seguidos
<?php
// include PHP client library
require_once 'buzz.php';

try {
  // set up file store
  $storage = new buzzFileStorage('/tmp/cache');

  // get user ID
  $uid = 1;

  // perform authentication with Google
  $auth = buzzOAuth::performOAuthLogin($storage, $uid);

  // initialize Buzz object
  $buzz = new buzz($storage, $auth);

  // get followers
  $followers = $buzz->followers('@me');

  echo '<h1>Currently being followed by:</h1>';
  foreach ($followers as $person) {
    displayUserBlock($person);
  }

  // get following
  $following = $buzz->following('@me');
  echo '<h1>Currently following:</h1>';
  foreach ($following as $person) {
    displayUserBlock($person);
  }

} catch (Exception $e) {
  echo 'ERROR:' . $e->getMessage();
}

// render user block
function displayUserBlock($person) {
    // get object from global scope
    global $buzz;

    // display user full name
    echo '<strong>' . $person->name . '</strong><br/>';

    // fetch user's public feed
    $result = $buzz->getPosts('@public', $person->id, false, false, 3);

    // iterate through feed data
    echo '<ol>';
    foreach ($result->posts as $post) {
      echo '<li>';
      $url = isset($post->links->self[0]->href) ? 
       $post->links->self[0]->href : '#';
      echo '<a href="' . $url . '">' . $post->title . 
       '</a>';
      echo ' (' . date("d M Y h:i", strtotime($post->published)) . ')';
      echo '</li>';
    }
    echo '</ol>';
}
?>

A listagem 11 usa, primeiramente, o método followers() para recuperar uma lista dos seguidores do usuário autenticado. O valor de retorno desse método é uma coleção de objetos buzzPerson e cada um destes é passado para o displayUserBlock() definido pelo usuário. Esse método recupera o nome e o ID de cada seguidor e utiliza o ID para fazer uma seguinte solicitação, desta vez através do método getPosts() , para recuperar as três postagens mais recentes do seguidor. Essas informações são formatadas para exibição.

Depois disso, use o método following() para recuperar uma lista dos usuários que estão sendo seguidos atualmente pelo usuário autenticado. A coleção retornada por esse método é processada de maneira semelhante.

A API do Google Buzz também torna possível seguir ou não seguir programaticamente usuários específicos. Esses métodos da API são refletidos nos métodos follow() eunfollow() , e ambos incluem ou descartam esse ID do usuário da fila de seguimento do usuário autenticado.


Um aplicativo de exemplo

Agora que você sabe um pouco sobre como a API do Google Buzz funciona, vamos montar um aplicativo da Web simples que demonstra como usá-la de maneira interativa. A listagem 12 atualiza a listagem 2, criando um formulário AddD e anexando links Delete em cada postagem. Essas adições permitem aos usuários autenticados visualizar sua alimentação pública, adicionar novas postagens a ela de maneira interativa ou excluir postagens existentes, —tudo sem usar a interface Google Buzz.

Listagem 12. Listando postagens do usuário
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <style>
    body {
      font-family: Verdana;
    }
    li {
      margin: 10px;
      padding: 2px;
      width: auto;
      padding-bottom: 20px;
    }
    </style>
  </head>
  <body>

  <h1>Add New Post</h1>
  <form method="post" action="add.php">
  Message: <br/>
  <textarea name="buzz" cols="60" rows="5"></textarea><br/>
  <input type="submit" name="submit" value="Post!" />
  </form>

  <h1>Recent Posts</h1>
  <?php
  // include PHP client library
  require_once 'buzz.php';

  try {
    // set up file store
    $storage = new buzzFileStorage('/tmp/cache');

    // get user ID
    $uid = 1;

    // perform authentication with Google
    $auth = buzzOAuth::performOAuthLogin($storage, $uid);

    // initialize Buzz object
    $buzz = new buzz($storage, $auth);

    // fetch authenticated user's public feed
    $result = $buzz->getPosts('@public', '@me');

    // iterate through feed data
    echo count($result->posts) . ' post(s) found. <br/>';
    echo '<ol>';
    foreach ($result->posts as $post) {
      echo '<li>';
      echo isset($post->links['alternate'][0]->href) ? 
       '<a href="' . $post->links['alternate'][0]->href . 
       '">' . $post->title . '</a>' : $post->title;
      echo ' (' . date("d M Y h:i", strtotime($post->published)) . ') ';
      echo '<a href="delete.php?id=' . $post->id . '">[Delete this post]</a>';
      echo '</li>';
    }
    echo '</ol>';
  } catch (Exception $e) {
    echo 'ERROR:' . $e->getMessage();
  }
  ?>

  </body>
</html>

A listagem 12 está dividida em duas partes:

  • A primeira parte inicializa um objeto buzz e usa seu método getPosts() para recuperar a alimentação pública do usuário. Cada postagem é acompanhada por um link que permite ao usuário excluir a postagem através do script delete.php. O ID da postagem é passado para o script delete.php como um parâmetro GET padrão.
  • A segunda parte contém um formulário HTML que fornece um campo de entrada para o usuário inserir uma nova postagem. Os dados enviados através do formulário são transferidos para o script add.php através de POST.

A listagem 13 contém o script add.php, que recebe dados de entrada através de POST e os converte em um buzzPost . Esse objeto, em seguida, é transmitido ao serviço Google Buzz como uma solicitação POST através do método updatePost() discutido anteriormente. A listagem 13 mostra o código:

Listagem 13. Incluindo novas postagens
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
  </head>
  <body>
  <?php
  if (!isset($_POST['buzz'])) {
    die('ERROR: Please enter some Buzz content!');
  }

  // include PHP client library
  require_once 'buzz.php';

  try {
    // set up file store
    $storage = new buzzFileStorage('/tmp/cache');

    // get user ID
    $uid = 1;

    // perform authentication with Google
    $auth = buzzOAuth::performOAuthLogin($storage, $uid);

    // initialize Buzz object
    $buzz = new buzz($storage, $auth);

    // add a new post
    $object = new buzzObject($_POST['buzz']);
    $post = buzzPost::createPost($object);
    $result = $buzz->updatePost($post);
    echo 'Added new post with ID: ' . $result->id;
  } catch (Exception $e) {
    echo 'ERROR:' . $e->getMessage();
  }
  ?>

  </body>
</html>

A listagem 14 contém o script delete.php, que recebe o ID do script a ser excluído e passa esse ID para o deletePost() . Esse método constrói uma solicitação DELETE e a entrega à API do Google Buzz para execução. Segue o código:

  <!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    <head>
      <title>Searching public activity feeds</title>
      <style>
        body {
        font-family: Verdana;      
        }
        li {
        border-bottom: solid black 1px;      
        margin: 10px; 
        padding: 2px; 
        width: auto;
        padding-bottom: 20px;
        }
      </style>    
    </head>
    <body>  
      <form method="post" 
        action="<?php echo $_SERVER['PHP_SELF']; ?>">
        Search for: <input type="text" name="q" />
        <input type="submit" name="submit" value="Search">
      </form>    
      <?php
        
        if (isset($_POST['submit'])) {
        // include PHP client library
        require_once 'buzz.php';
        
        try {
        // set up file store
        $storage = new buzzFileStorage('/tmp/cache');
        
        // get user ID
        $uid = 1;
        
        // perform authentication with Google 
        $auth = buzzOAuth::performOAuthLogin($storage, $uid);
        
        // initialize Buzz object  
        $buzz = new buzz($storage, $auth);
        
        // fetch authenticated user's public feed
        $result = $buzz->search($_POST['q']);
        
        // iterate through feed data
        echo '<h1>' . $result->title . '</h1>';
        echo count($result->posts) . ' post(s) found. <br/>';
        echo '<ol>';
        foreach ($result->posts as $post) {
        echo '<li>';
        echo isset($post->links['alternate'][0]->href) ? 
        '<a href="' . $post->links['alternate'][0]->href . 
        '">' . $post->title . '</a><br/>' : 
        $post->title . '<br/>';
        echo $post->person->name . ' (' . 
  date("d M Y h:i", strtotime($post->published)) . ')';  
        echo '</li>';
        }
        echo '</ol>';
        } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();  
        }
        }
      ?>
    </body>
  </html>

Figura 7 exibe a saída da Listagem 12:

Figura 7. Um formulário da Web para interação do Google Buzz
Screen capture of a Message web form for Google Buzz interaction; also shows three of 6 recent posts

Conclusão

Como esses exemplos ilustram, a API do Google Buzz e a PHP Client Library tornam possível integrar postagens Buzz e fluxos de atividade diretamente em um aplicativo PHP. Os exemplos neste artigo apenas demonstram as funções mais simples. É possível fazer muito mais com o Google Buzz, incluindo:

  • Criar atividades privadas
  • Silenciar, remover o silêncio e postagens like
  • Criar e editar comentários
  • Criar consultas de procura avançada

No momento da preparação deste artigo a API do Google Buzz ainda está em desenvolvimento, por isso aguarde mais vantagens futuramente!

Em resumo, a API do Google Buzz fornece um mecanismo sofisticado independente do formato para os desenvolvedores integrarem conteúdo Buzz público em qualquer aplicativo da Web. É excelente para mashups ou para construir sua própria interface customizada para o Google Buzz. Experimente e veja o que você consegue!

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=588409
ArticleTitle=Procurar e Integrar o Google Buzz Streams com PHP
publish-date=11232010