Procure e investigue fluxos de atividade do Google+ com aplicativos PHP

Recupere posts e localize usuários no Google+ com a API do Google+ e PHP

Google+, a nova rede social do Google, permite que seus usuários postem mensagens de status e notícias. Desenvolvedores de aplicativos da web podem acessar e procurar essas mensagens através da API do Google+. Neste artigo, você aprenderá os aspectos básicos da API do Google+. Os exemplos mostram como usar a API do Google+ com PHP para criar aplicativos da web dinâmicos.

Vikram Vaswani, Founder, Melonfire

Photo of Vikram VaswaniVikram Vaswani é fundador e CEO da Melonfire, uma empresa de serviços de consultoria com conhecimento especial em tecnologias e ferramentas de software livre. Também é autor dos livros Zend Framework: A Beginners Guide e PHP: A Beginners Guide.



26/Jul/2012

Introdução

Google+, o novato no grupo das redes sociais, é a mais recente tentativa do Google de desenvolver uma rede social que permita aos usuários compartilhar facilmente notícias e arquivos e interagir com seus amigos. Parece estar conseguindo captar a atenção do público. Segundo relatos, em dezembro de 2011, o Google+ estava registrando 625.000 novos usuários por dia e tinha um total de 62 milhões de usuários (consulte Recursos).

Abreviações usadas frequentemente

  • API: Interface de Programação de Aplicativos
  • HTTP: Protocolo de Transporte de Hipertexto
  • JSON: JavaScript Object Notation
  • PHP: Hypertext preprocessor

Desenvolvedores da web têm motivos para se animar com Google+. Como muitos outros serviços do Google, Google+ inclui uma API de desenvolvedor que permite acessar conteúdo gerado pelos usuários através de aplicativos customizados. Como a API entrega sua saída em JSON, ela pode ser integrada facilmente com a maioria dos kits de ferramenta de programação.

Neste artigo, você aprenderá sobre a API de dados do Google+. Veja como usá-la para extrair conteúdo do Google+ e integrá-lo em um aplicativo PHP. (É algo divertido, portanto, esteja avisado de que você pode se viciar nisso.)


Aspectos básicos da API

Antes de começar a desenvolver aplicativos com Google+, é necessário entender como ele funciona. A API funciona sobre HTTP e espera uma solicitação de HTTP para um terminal designado. Ao receber essa solicitação, o servidor da API responde à consulta um feed JSON contendo os dados solicitados. Em seguida, é possível analisar esses dados usando uma linguagem de programação do lado do servidor (como PHP ou Perl) ou um kit de ferramentas do lado do cliente (como jQuery ou mooTools) e extrair conteúdo dos dados para integração em uma página da web.

Primeiro, é necessário fazer algumas coisas:

  1. Configure uma conta do Google+.
    1. Faça login na sua Conta do Google e use o link "+You" no menu principal para inscrever-se para uma conta Google+.
    2. Acesse sua página Google Account Settings para recuperar o URL de seu perfil do Google, que também contém seu ID Google, como na Figura 1.
    3. Lembre-se desse ID, pois você precisará dele para alguns dos exemplos neste artigo.
    Figura 1. URL Google Profile com ID do Google
    URL Google Profile com ID do Google
  2. Ative o acesso à API na sua conta do Google+.
    1. Navegue até o Google APIs Console (consulte Recursos para obter um link para o console) e crie um projeto.
    2. Ative a API do Google+ para seu novo projeto.
    3. Você receberá uma chave de API gerada automaticamente, que pode ser usada para acessar a API. O segredo está na guia API Access do Google APIs Console, como na Figura 2.
    4. Anote sua chave de API.
    Figura 2. Google API Console com chave de acesso à API
    Google API Console com chave de acesso à API

Também é possível acessar a API do Google+ usando OAuth. (Uma discussão sobre OAuth está fora do escopo deste artigo.)

Quando você tiver seu ID do Google+ e chave da API, tente solicitar o terminal de API https://www.googleapis.com/plus/v1/people/ID/activities/public?key=API-KEY no seu navegador. Lembre-se de substituir os valores temporários ID e API-KEY na solicitação com os valores que você obteve. A resposta à solicitação, que pode ser vista no código fonte da página resultante, contém uma lista dos posts mais recentes que você fez no Google+. Será semelhante à Listagem 1. Identificadores exclusivos foram ocultados.

Listagem 1. Exemplo de feed de atividade do Google+ em formato JSON
{
 "kind": "plus#activityFeed",
 "etag": "ab49djslas22",
 "nextPageToken": "eJxtbiSnOTUova1kyV5Z7y",
 "selfLink": "https://www.googleapis.com/plus/v1/people/ID/activities/public?",
 "nextLink": "https://www.googleapis.com/plus/v1/people/ID/activities/
    public?maxResults=20&pageToken=",
 "title": "Plus Public Activity Feed for John Doe",
 "updated": "2012-01-17T06:05:03.277Z",
 "id": "tag:google.com,2010:/plus/people/ID/activities/public",
 "items": [
  {
   "kind": "plus#activity",
   "etag": "abc",
   "title": "Sleepy at work",
   "published": "2012-01-17T06:05:03.000Z",
   "updated": "2012-01-17T06:05:03.277Z",
   "id": "zab",
   "url": "https://plus.google.com/ID/posts/XgGBBbn",
   "actor": {
    "id": "ID",
    "displayName": "John Doe",
    "familyName": "Doe",
    "givenName": "John",
    "url": "https://plus.google.com/ID",
    "image": {
     "url": "https://lh5.googleusercontent.com/9HzARk/Cxo/photo.jpg?sz=0"
    }
   },
   "verb": "post",
   "object": {
    "objectType": "note",
    "content": "Sleepy at work",
    "originalContent": "",
    "url": "https://plus.google.com/ID/posts/XgGBBbn",
    "replies": {
     "totalItems": 0,
     "selfLink": "https://www.googleapis.com/plus/v1/activities/xys/comments"
    },
    "plusoners": {
     "totalItems": 0,
     "selfLink": "https://www.googleapis.com/plus/v1/activities/xys/people/plusoners"
    },
    "resharers": {
     "totalItems": 0,
     "selfLink": "https://www.googleapis.com/plus/v1/activities/xys/people/resharers"
    }
   },
   "provider": {
    "title": "Google+"
   },
   "access": {
    "kind": "plus#acl",
    "items": [
     {
      "type": "public"
     }
    ]
   }
  },
  {
  ...
  }
 ]
}

A API do Google+ responde a solicitações com um feed JSON contendo os dados solicitados. Google+ oferece vários feeds interessantes, incluindo:

  • Feed de atividade, que contém todos os posts públicos feitos por um usuário em particular.
  • Feed de comentários por atividade, que contém uma lista de comentários de usuários sobre uma atividade em particular.
  • Feed de pessoa, que contém uma lista de usuários que correspondem a certas palavras-chave ou atividades especificadas.

Os feeds listados acima requerem autenticação com uma chave de API ou token do OAuth.

O feed em si é formatado como um documento JSON, com as chaves externas contendo o título do feed e URLs da página atual (e, quando for o caso, próxima página e página anterior) do conjunto de resultados. Um array items contém uma coleção de recursos. Os recursos podem ser atividades, perfis ou comentários, dependendo do feed solicitado. Cada entrada na coleção contém mais detalhes sobre o recurso, incluindo:

  • URL pública do recurso
  • Tipo e ID do recurso
  • Autor
  • Data de publicação

Dependendo do tipo de recurso, mais informações podem ser incluídas, como: conteúdo da atividade, descrição do perfil, imagem do autor, número de respostas, compartilhamentos e +1s ou anexos e seu conteúdo. Você verá exemplos de todos esses mais adiante neste artigo.

Atualmente, a API do Google+ é somente leitura. É possível recuperar informações dela, mas operações de gravação (como postar novas atividades ou comentários, atualizar perfis ou fotos do autor ou excluir atividades) não são atualmente suportados pela API.

O uso de conteúdo do Google+ em aplicativos de terceiros é regulado pelos Termos de Serviço do Google+. Seus aplicativos devem estar de acordo com as Políticas do Desenvolvedor do Google+. É recomendável ler esses documentos antes de passar para o desenvolvimento, para garantir que você está de acordo com todas as regras necessárias (consulte Recursos).


Recuperando feeds de atividade

Nesta seção, veja como integrar os dados retornados pela API do Google+ em um aplicativo PHP. A maneira mais fácil é usar o componente Zend_Http_Client de Zend Framework, que simplifica o processo de criar, transmitir e processar solicitações HTTP. A Listagem 2 mostra como é possível usar Zend_Http_Client para transmitir uma solicitação à API do Google+ e processar o resultado.

Listagem 2. Processando um feed de atividade do Google+
<?php
// load Zend classes
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Http_Client');

// define user ID
$uid = 'YOUR-ID-HERE';

// define API key
$key = 'YOUR-API-KEY-HERE';

try {
  // get feed of user public activities
  // decode JSON response
  $client = new Zend_Http_Client(
    "https://www.googleapis.com/plus/v1/people/$uid/activities/public?key=$key"
  );
  $response = $client->request('GET'); 
  $result = json_decode($response->getBody());

  // iterate through response  
  echo '<h1>' . $result->title . '</h1>';
  echo count($result->items) . ' post(s) found. <br/>';
  echo '<ol>';
  foreach ($result->items as $entry) {
    echo '<li>';
    echo '<a href="' . $entry->url . '">' . $entry->title . '</a>';
            echo ' (' . date("d M Y h:i", strtotime($entry->published)) . ')';
    echo '</li>';
  }
  echo "</ol>";

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

A Listagem 2 primeiro carrega as bibliotecas da classe Zend e inicializa uma instância da classe Zend_Http_Client. Esse cliente é usado para criar e transmitir uma solicitação GET do feed de atividade pública do usuário para o terminal da API https://www.googleapis.com/plus/v1/people/[ID]/activities/public (como na Listagem 1). Observe que, nesse caso, a URL do terminal deve conter o ID do Google do usuário e a chave da API gerada pelo Google API's console.

Em seguida, a resposta JSON à solicitação é analisada e convertida em um objeto PHP usando a função json_decode() de PHP, como na Figura 3.

Figura 3. Objeto de PHP contendo conteúdo de atividade do Google+
Objeto de PHP contendo conteúdo de atividade do Google+

Ao comparar as propriedades de objeto na Figura 3 com os pares de chave e valor do documento JSON na Listagem 1, você deve ver a correspondência entre eles. Agora é fácil iterar pelo array itens no objeto, recuperar dados das atividades individuais (como título de atividade, URL do post e data de publicação) e formatar isso para exibição em uma página da web.

A figura 4 mostra um exemplo da saída provável.

Figura 4. Página da web exibindo posts de atividade do Google+
Página da web exibindo posts de atividade do Google+

Recuperando conteúdo de atividade e anexos

O feed bruto de atividades na Listagem 1 inclui informações adicionais para cada post, incluindo metadados sobre recursos integrados como vídeos ou fotos. Com isso em mente, é possível refinar a Listagem 2 para extrair e exibir essas informações adicionais, como na Listagem 3.

Listagem 3. Exibindo dados adicionais e recursos integrados de um feed de atividade do Google+
<!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>Extracting data from a public activity feed</title>
    <style>
    table {
      border-collapse: yes;      
    }
    .photo {
      vertical-align: top;
    }
    td.divider {
      border-bottom: dashed silver 1px;
    }
    </style>
  </head>
		 <body>  
<?php
// load Zend classes
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Http_Client');

// define user ID
$uid = 'YOUR-ID-HERE';

// define API key
$key = 'YOUR-API-KEY-HERE';

try {
  // get feed of user public activities
  // decode JSON response
  $client = new Zend_Http_Client(
    "https://www.googleapis.com/plus/v1/people/$uid/activities/public?key=$key"
  );
  $response = $client->request('GET'); 
  $result = json_decode($response->getBody());

  // iterate through response  
  echo '<h1>' . $result->title . ' - ' . count($result->items) . 
    ' post(s) found</h1>';
  echo '<table>';
  foreach ($result->items as $entry) {
    echo '<tr>';
    echo '<td class="photo"><img src="' . $entry->actor->image->url . 
      '" /><br/>';  
    echo '<a href="' . $entry->actor->url . '">'. 
      $entry->actor->displayName . '</a></td><td>';
    if (!empty($entry->title)) {
      echo '<a href="' . $entry->url . '">' . $entry->title . 
        '</a> <br/>';
    }
    if (count($entry->object->attachments)) {
      foreach ($entry->object->attachments as $a) {
        switch ($a->objectType) {
          case 'article':
            echo '<a href="' . $a->url . '">Article: ' . 
              $a->displayName . '</a><br/>';
            break;
          case 'photo':
            echo '<a href="'.$a->fullImage->url.'"><img src="' . 
              $a->image->url . '" /> </a><br/>';
            break;
          case 'video':
            echo '<a href="' . $a->url . '">Video: ' . $a->displayName . 
              '</a><br/><img src="' . $a->image->url . 
              '" /><br/>';
            break;
        }
      }
    }
    echo 'Posted on ' . date("d M Y h:i", strtotime($entry->published));      
    echo '</td></tr><tr><td class=divider colspan=2>
      </td></tr>';
  }
  echo '</table>';  


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

A Listagem 3 vai mais longe que a Listagem 2. Para cada post, o código recupera o nome e foto do autor e os exibe junto com o seu conteúdo. Para posts que contém anexos integrados adicionais, como imagens, vídeos ou links externos, ele itera pelo array attachments incluindo em cada item e exibe o recurso correspondente abaixo do conteúdo do post. A Figura 5 mostra um exemplo de saída.

Figura 5. Página da web exibindo posts do Google+ com anexos
Página da web exibindo posts do Google+ com anexos

A Listagem 4 abaixo cria uma versão mais interativa da Listagem 3 ao permitir que o usuário insira um ID de atividade para visualizar os seus detalhes. A Listagem 4 usa um terminal de API diferente, https://www.googleapis.com/plus/v1/activities/[ID], que deve receber um ID de atividade e retorna detalhes completos dessa atividade como um único registro JSON.

Listagem 4. Forma interativa para exibir o conteúdo do feed de atividade do Google+
<!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>Retrieving activity details</title>
    <style>
    table {
      border-collapse: yes;      
    }
    .photo {
      vertical-align: top;
    }
    td.divider {
      border-bottom: dashed silver 1px;
    }
    .meta {
      font-style: italic;
    }    
    </style>
  </head>
  <body>  
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for activity by ID: <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_Http_Client');

      // define API key
      $key = 'YOUR-API-KEY-HERE';

      $aid = $_POST['q']; 
      
      try {
        // get user public feed
        // decode JSON response
        $client = new Zend_Http_Client(
          "https://www.googleapis.com/plus/v1/activities/$aid?key=$key"
        );
        $response = $client->request('GET'); 
        $entry = json_decode($response->getBody());
        
        // iterate through response  
        // print fields
        echo '<h1>' . $entry->title . '</h1>';
        echo '<table>';
        echo '<tr>';
        echo '<td class="photo"><img src="' . 
          $entry->actor->image->url . '" /></td><td>';  
        if (!empty($entry->title)) {
          echo '<a href="' . $entry->url . '">' . $entry->title . 
            '</a> <br/>';
        }
        if (count($entry->object->attachments)) {
          foreach ($entry->object->attachments as $a) {
            switch ($a->objectType) {
              case 'article':
                echo '<a href="' . $a->url . '">Article: ' . 
                  $a->displayName . '</a><br/>';
                break;
              case 'photo':
                echo '<a href="'.$a->fullImage->url.'"><img src="' . 
                  $a->image->url . '" /> </a><br/>';
                break;
              case 'video':
                echo '<a href="' . $a->url . '">Video: ' . 
                  $a->displayName . '</a><br/><img src="' . 
                  $a->image->url . '" /><br/>';
                break;
            }
          }
        }
        echo '<div class="meta">Posted on ' . 
          date("d M Y h:i", strtotime($entry->published)) . ' by <a href="' . 
          $entry->actor->url . '">'. $entry->actor->displayName . 
          '</a> <br/>';
        echo 'Replies: ' . (int)$entry->replies->totalItems . 
          ' | +1s: ' . (int)$entry->plusoners->totalItems . 
          ' | Reshares: ' . (int)$entry->resharers->totalItems . 
          '</div>';
        echo '</td></tr></table>';
        
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

A Listagem 4 inclui um formulário de entrada que permite que o usuário insira um ID de atividade. Em seguida, o programa conecta-se ao terminal da API do Google+ e recupera o registro completo dessa atividade como um documento JSON. Este último é convertido em um objeto PHP e formatado para exibição, de forma semelhante ao que foi mostrado na Listagem 3. A Listagem 4 usa metadados adicionais vinculados a cada post, como o número de respostas, compartilhamentos e +1s que o post atraiu. Caso você esteja se perguntando como obter o ID de atividade, é necessário extraí-lo do documento JSON de atividades.

A Figura 6 mostra um exemplo de saída.

Figura 6. Página da web exibindo posts do Google+ com anexos
Página da web exibindo posts do Google+ com anexos

Recuperando perfis de usuário

É possível recuperar perfis de usuário da mesma maneira que se recuperam listagens de atividade do usuário. Primeiro, é necessário obter o ID do Google do usuário de destino e incluí-lo em uma chamada para o terminal da API em https://www.googleapis.com/plus/v1/people/[ID]. A resposta em JSON resultante contém informações biográficas sobre o usuário, incluindo nome completo, foto, biografia curta e URLs (quando disponível).

A Listagem 5 ilustra o processo.

Listagem 5. Formulário interativo para recuperar um perfil de usuário do Google+
<!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>Retrieving user profiles</title>
    <style>
    table {
      border-collapse: yes;      
    }
    .photo {
      vertical-align: top;
    }
    td.divider {
      border-bottom: dashed silver 1px;
    }
    </style>
  </head>
  <body>  
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for user by ID: <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_Http_Client');

      // define API key
      $key = 'YOUR-API-KEY-HERE';
      
      $uid = $_POST['q'];

      try {
        // get user public feed
        // decode JSON response
        $client = new Zend_Http_Client(
          "https://www.googleapis.com/plus/v1/people/$uid?key=$key"
        );
        $response = $client->request('GET'); 
        $result = json_decode($response->getBody());
        
        // iterate through response  
        // print fields
        echo '<h1><img src="' . $result->image->url. '" />' . 
          $result->displayName . '</h1>';
        echo isset($result->tagline) ? '<h2>' . $result->tagline . 
          '</h1>' : '';
        echo isset($result->aboutMe) ? $result->aboutMe . '<br/>' : '';
        if (isset($result->urls) && count($result->urls)) {
        echo '<h3>Links</h3> <ul>';
        foreach ($result->urls as $u) {
          $label = '';
          if ($u->type == 'json') continue;
          if ($u->type == 'profile') $label = 'Google+ Profile: ';
          echo '<li><a href="'. $u->value . '">' . $label . 
            $u->value . '</a></li>';
        }
        echo '</ul>';
        }  
          
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

A Listagem 5 é semelhante à Listagem 4 no sentido em que pede o ID do Google de um usuário e conecta-se à API para recuperar informações sobre esse usuário. A resposta geralmente inclui, no mínimo, o nome do usuário e a URL da foto (ou uma foto padrão, se nenhuma estiver disponível). Se os usuários tiverem inserido dados adicionais sobre si mesmos, essas informações também serão incluídas na resposta em JSON. Como antes, a resposta pode ser convertida em um objeto PHP e formatada para exibição em um navegador.

A Figura 7 mostra um exemplo da saída da Listagem 5.

Figura 7. Página da web exibindo um perfil do usuário de Google+
Página da web exibindo um perfil do usuário de Google+

Procurando em fluxos de atividade

Além de recuperar um único feed público ou perfil do usuário, também é possível usar a API do Google+ para procurar em feeds de atividade usando palavras-chave. Esse método da API, disponível no terminal https://www.googleapis.com/plus/v1/activities, aceita um parâmetro query contendo uma ou mais palavras-chave para procura. A Listagem 6 demonstra a API no contexto de um aplicativo PHP.

Listagem 6. Procurando atividades por palavra-chave
<!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>
    table {
      border-collapse: yes;      
    }
    .photo {
      vertical-align: top;
    }
    td.divider {
      border-bottom: dashed silver 1px;
    }
    </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_Http_Client');

      // define API key
      $key = 'YOUR-API-KEY-HERE';
      
      try {
        if (empty($_POST['q'])) {
          throw new Exception('No search term provided');  
        }
        
        // search all feeds
        $url = "https://www.googleapis.com/plus/v1/activities?key=$key&query=" . 
          urlencode($_POST['q']);
        $client = new Zend_Http_Client($url);
        $response = $client->request('GET'); 
        $result = json_decode($response->getBody());

        // iterate through returned feed
        // display results
        echo '<h1>' . $result->title . ' - ' . 
          count($result->items) . ' post(s) found</h1>';
        echo '<table>';
        foreach ($result->items as $entry) {
          echo '<tr>';
          echo '<td class="photo"><img src="' . 
            $entry->actor->image->url . '" /><br/>';  
          echo '<a href="' . $entry->actor->url . '">'. 
            $entry->actor->displayName . '</a></td><td>';
          if (!empty($entry->title)) {
            echo '<a href="' . $entry->url . '">' . $entry->title . 
              '</a> <br/>';
          }
          if (count($entry->object->attachments)) {
            foreach ($entry->object->attachments as $a) {
              switch ($a->objectType) {
                case 'article':
                  echo '<a href="' . $a->url . '">Article: ' . 
                    $a->displayName . '</a><br/>';
                  break;
                case 'photo':
                  echo '<a href="'.$a->fullImage->url.'"><img src="' . 
                    $a->image->url . '" /> </a><br/>';
                  break;
                case 'video':
                  echo '<a href="' . $a->url . '">Video: ' . $a->displayName . 
                    '</a><br/><img src="' . $a->image->url . 
                    '" /><br/>';
                  break;
              }
            }
          }
          echo 'Posted on ' . date("d M Y h:i", strtotime($entry->published));      
          echo '</td></tr><tr>
            <td class=divider colspan=2></td></tr>';
        }
        echo '</table>';  
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

A Listagem 6 gera um formulário da web contendo um campo de entrada, no qual o usuário pode inserir uma ou mais palavras-chave. Quando o formulário é enviado, uma nova instância Zend_Http_Client é criada e a entrada do usuário é dobrada em uma solicitação GET ao terminal da API. Em seguida, a resposta JSON é convertida em um objeto PHP para maior processamento.

A figura 8 mostra um exemplo da saída gerada pela Listagem 6.

Figura 8. Formulário da web para procurar atividades do Google+ por palavra-chave
Formulário da web para procurar atividades do Google+ por palavra-chave

Por padrão, cada conjunto de resultados retornado pela API do Google+ contém 10 itens. Para forçar a API a retornar um número diferente de resultados, basta incluir o parâmetro maxResults à solicitação da API e especificar um valor entre 1 e 20. Cada documento JSON retornado pela API também inclui uma propriedade nextPageToken, que pode ser incluída na cadeia de caracteres de consulta para recuperar a próxima página do conjunto de resultados e assim permitir paginação do conjunto de dados.


Procurando perfis do usuário

A API do Google+ pode ser usada para procurar pessoas por palavra-chave. O terminal da API para esse método é https://www.googleapis.com/plus/v1/people. Assim como a API de procura de atividade, o terminal da API aceita um parâmetro query contendo palavras-chave e procura palavras-chave no parâmetro.

A Listagem 7 revisa a Listagem 6 para procurar pessoas em vez de atividades.

Listagem 7. Procurando atividades por perfil de 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>
    <title>Searching for people</title>
    <style>
    table {
      border-collapse: yes;      
      width: 100%;
    }
    .photo {
      vertical-align: top;
    }
    .posts td:not(:last-child) {
      border-bottom: dashed silver 1px;
    }
    td.divider {
      border-bottom: solid green 2px;    
    }
    td.post {
      padding-bottom: 20px;
    }
    .meta {
      font-style: italic;
    }
    </style>     
  </head>
  <body>  
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for people by name: <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_Http_Client');

      // define API key
      $key = 'YOUR-API-KEY-HERE';
      
      try {
        if (empty($_POST['q'])) {
          throw new Exception('No search term provided');  
        }
        
        // search all feeds
        $url = "https://www.googleapis.com/plus/v1/people?key=$key&query=" . 
          urlencode($_POST['q']);
        $client = new Zend_Http_Client($url);
        $response = $client->request('GET'); 
        $result = json_decode($response->getBody());

        // iterate through returned feed
        // display results
        echo '<h1>' . $result->title . ' - ' . count($result->items) . 
          ' user(s) found</h1>';
        echo '<table>';
        foreach ($result->items as $entry) {
          echo '<tr>';
          echo '<td class="photo"><img src="' . $entry->image->url . 
            '" /><br/>';  
          echo '<a href="' . $entry->url . '">'. $entry->displayName . 
            '</a></td><td>';
          
          // get user's three most recent public posts
          $client->setUri("https://www.googleapis.com/plus/v1/people/" . 
            $entry->id . "/activities/public?key=$key&maxResults=3");
          $response = $client->request('GET'); 
          $result2 = json_decode($response->getBody()); 
          echo '<table class="posts">';
          foreach ($result2->items as $entry2) {
            echo '<tr><td class="post">';
            if (!empty($entry2->title)) {
              echo '<a href="' . $entry2->url . '">' . 
                $entry2->title . '</a> <br/>';
            }
            if (count($entry2->object->attachments)) {
              foreach ($entry2->object->attachments as $a) {
                switch ($a->objectType) {
                  case 'article':
                    echo '<a href="' . $a->url . '">Article: ' . 
                      $a->displayName . '</a><br/>';
                    break;
                  case 'photo':
                    echo '<a href="'.$a->fullImage->url.'"><img src="' . 
                      $a->image->url . '" /> </a><br/>';
                    break;
                  case 'video':
                    echo '<a href="' . $a->url . '">Video: ' . 
                      $a->displayName . '</a><br/><img src="' . 
                      $a->image->url . '" /><br/>';
                    break;
                }
              }
            }
            echo '<span class="meta">Posted on ' . 
              date("d M Y h:i", strtotime($entry2->published)) . '</span>';      
            echo '</td></tr>';
          }
          echo '</table>';
          echo '</td></tr><tr>
            <td class=divider colspan=2></td></tr>';
        }
        echo '</table>';
      } catch (Exception $e) {
        echo 'ERROR:' . $e->getMessage();
      }
    }
    ?>
  </body>
</html>

A Listagem 7 é interessante, pois usa duas chamadas de método da API. Primeiro, consulta o terminal de API em https://www.googleapis.com/plus/v1/people para ver se há perfis de usuário que correspondam a palavras-chave específicas. Em seguida, faz uma iteração pela coleção resultante. Para cada perfil correspondente, recupera o ID do Google e incorpora o ID do usuário em uma segunda solicitação ao terminal da API em https://www.googleapis.com/plus/v1/people/[ID]/activities/public para recuperar os três posts mais recentes do usuário. Como mostra a Listagem 6, cada post é acompanhado por links para recursos integrados associados, como imagens, vídeos ou artigos externos.

O resultado da Listagem 7 é algo como a Figura 9.

Figura 9. Formulário da web para procurar perfis de usuário do Google+ por palavra-chave
Formulário da web para procurar perfis de usuário do Google+ por palavra-chave

Recuperando comentários de atividades

Google+ permite que os usuários postem atividades contendo mensagens, fotos, vídeos e links, e permite que outros usuários comentem sobre essas atividades. O conteúdo dos comentários está disponível através do feed de comentários de cada atividade, que pode ser acessado através do terminal da API https://www.googleapis.com/plus/v1/activities/[ID]/comments. A Listagem 8, que amplia código que você viu anteriormente, mostra como exibir uma atividade e seus comentários.

Listagem 8. Exibindo comentários de atividade
<!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>Retrieving comments</title>
    <style>
    table {
      border-collapse: yes;      
    }
    .photo {
      vertical-align: top;
    }
    td.divider {
      border-bottom: dashed silver 1px;
    }
    .meta {
      font-style: italic;
    }
    </style>
  </head>
  <body>  
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    Search for comments on activity (enter activity ID): 
      <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_Http_Client');

      // define API key
      $key = 'YOUR-API-KEY-HERE ';

      $aid = $_POST['q']; 
      
      try {
        // get activity feed
        // decode JSON response
        $client = new Zend_Http_Client(
          "https://www.googleapis.com/plus/v1/activities/$aid?key=$key"
        );
        $response = $client->request('GET'); 
        $entry = json_decode($response->getBody());
        
        // iterate through response  
        // print fields
        echo '<h1>' . $entry->title . '</h1>';
        echo '<table>';
        echo '<tr>';
        echo '<td class="photo"><img src="' . 
          $entry->actor->image->url . '" /></td><td>';  
        if (!empty($entry->title)) {
          echo '<a href="' . $entry->url . '">' . $entry->title . 
            '</a> <br/>';
        }
        if (count($entry->object->attachments)) {
          foreach ($entry->object->attachments as $a) {
            switch ($a->objectType) {
              case 'article':
                echo '<a href="' . $a->url . '">Article: ' . 
                  $a->displayName . '</a><br/>';
                break;
              case 'photo':
                echo '<a href="'.$a->fullImage->url.'"><img src="' . 
                  $a->image->url . '" /> </a><br/>';
                break;
              case 'video':
                echo '<a href="' . $a->url . '">Video: ' . $a->displayName . 
                  '</a><br/><img src="' . $a->image->url . '" /><br/>';
                break;
            }
          }
        }
        echo '<div class="meta">Posted on ' . 
          date("d M Y h:i", strtotime($entry->published)) . ' by <a href="' . 
          $entry->actor->url . '">'. $entry->actor->displayName . 
          '</a> <br/>';
        echo 'Replies: ' . (int)$entry->replies->totalItems . 
          ' | +1s: ' . (int)$entry->plusoners->totalItems . 
          ' | Reshares: ' . (int)$entry->resharers->totalItems . 
          '</div>';
        echo '</td></tr></table>';
        
        // get comments feed for activity
        $client->setUri(
          "https://www.googleapis.com/plus/v1/activities/$aid/comments?key=$key"
        );
        $response = $client->request('GET'); 
        $result = json_decode($response->getBody());
        
        // iterate through response  
        // print fields
        if (count($result->items)) {
          echo '<h3>' . $result->title . '</h3>';
          echo '<ul>';
          foreach ($result->items as $comment) {        
            echo '<li>' . $comment->object->content . 
              '<br/>';
            echo '<span class="meta">Posted on ' . 
              date("d M Y h:i", strtotime($comment->published)) . 
              ' by <a href="' . $comment->actor->url . '">'. 
              $comment->actor->displayName . '</a> </span>';
            echo '</li>';
          }
          echo '</ul>';
        }

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

A primeira parte da Listagem 8 é semelhante à Listagem 4. Seu objetivo é aceitar um ID de atividade inserido pelo usuário em um formulário da web e conectar-se à API para recuperar e exibir os detalhes dessa atividade. Em seguida, o script faz uma segunda chamada de API para o feed de comentários da atividade, que retorna um documento JSON contendo todos os comentários postados por outros usuários para essa atividade. Esse documento JSON é analisado, e o conteúdo de cada comentário, junto com a hora de publicação e nome do autor, é adicionado à página da web.

A figura 10 mostra a saída.

Figura 10. Página da web para exibir atividades e comentários do Google+
Página da web para exibir atividades e comentários do Google+

Resumo

A API do Google+ é relativamente jovem e suporta apenas operações somente leitura no momento. No entanto, como você aprendeu com os exemplos deste artigo, ela ainda oferece várias opções para integrar conteúdo público do Google+ em qualquer aplicativo da web. A API do Google+ provavelmente irá amadurecer e oferecer muito mais recursos à medida que o serviço Google+ expande seu escopo. Até lá, ela é ótima para criar mashups ou desenvolver interfaces customizadas para o Google+. Divirta-se!

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=827405
ArticleTitle=Procure e investigue fluxos de atividade do Google+ com aplicativos PHP
publish-date=07262012