Acessando dados do Orkut com Java server-side!

Em um país que acessa mais redes sociais do que email, as empresas saem correndo atrás do prejuizo, e todo mundo fica que nem louco pensando: "como diabos eu posso ganhar dinheiro com isso?". Pior ainda, é quando surgem algumas idéias para se ganhar dinheiro com isso, que é barrada com outra pergunta: "como diabos eu posso obter os dados das redes sociais e ganhar dinheiro com isso fora das redes sociais?"

Se a sua pergunta for a segunda, seus problemas acabaram!!

Comecei a pesquisar uma maneira de conectar obter os dados de um perfil do Orkut (como seu nome, fotos, amigos, etc) para ser tratado server-side em uma aplicação Java Web
(evitando a famigerada técnica POST/GET buscando por cada campo pelo nome, claro!).

Tentei descobrir como o power.com obtém os dados do Orkut, mas não tive muito sucesso. Li em alguns fóruns (não-oficiais, ou seja, não confiáveis), que os dados do Orkut são replicados e armazenados em um banco de dados local.. (argh!)

Bom, eu esperava uma maneira mais fácil para conectar e interagir com a rede social e continuei procurando..

..que tal um Social Aberto?

A principio, havia entendido que o OpenSocial possibilitava apenas a interação interna entre os mini-aplicativos (ou gadgets) e as redes sociais onde estavam instalados.

Porém, pesquisando na sua documentação, encontrei algumas informações sobre como conectar nas redes sociais que fazem parte do OpenSocial server-side via REST/RPC, com suporte a autenticação OAuth, e obter os seus dados no formato JSON. Há até um guiazinho prontinho com alguns exemplos bem legais!!

Fantástico!! Agora eu conseguia carregar os dados em JSON via REST para converter em objetos e.. e..

..ah, mas peraew!

..pois é! Eu vim da plataforma .NET e sou muuuuito preguiçoso e mal acostumado.. ok, eu já tinha a forma de me conectar, me autenticar, criar os parses do JSON na mão para objetos java.. mas eu gostaria de alguma coisa menos.. err.. menos "na unha", entende?

..e, depois de pesquisar um pouco mais, qual foi a minha surpresa quando eu descobri, escondidinho, sem muitos alardes, que existe algo fácil, server-side e muito mais!

O OpenSocial Library Client!!

O projeto OpenSocial Library Client, possibilita conectar-se server-side em algumas redes do Open Social usando Java, PHP, Phyton, Ruby, Objective C. Li hoje que já iniciaram um projeto para .NET. =)

Ainda estou estudando a library, mas parece ser beeem simples! Ela encapsula toda a complexidade da conexão via REST/RPC, da autenticação com o OAuth, do parse do JSON em objetos na sua linguagem preferida. Tudo de forma bem simples e padronizada! =D

(O pior é que, eu não sei se eu sou um péssimo googler, mas só encontrei uma única noticia tupiniquim comentando sobre esses caras.. fala sério..)

Só um gostinho..

Vc baixa o client da sua linguagem preferida (no meu caso, estou usando java) e basta vc seguir alguns dos exemplos da documentação, para já sair brincando..

Para demonstrar a simplicidade da API, segue abaixo um trecho código java, baseado nos exemplos disponíveis na documentação, que, em poucas linhas de código, carrega um perfil do Orkut e seus amigos.

Para não ficar uma cópia escarrada da documentação, fiz alguns ajustes para exemplificar a solicitação de 3 campos específicos de tipos diferentes e a técnica para exibição de cada um deles no método exibirAmigo():

- o campo "gender" é um campo texto simples e seu valor é acessado através do método field.getStringValue();

- o campo "name", é um campo que retorna um objeto complexo (ou seja, objetos encadeados); É necessário iterar os seus objetos filhos (acessados via field.getValues()) para, então, obter os seus valores (ou outros objetos..);

- já o campo "languagesSpoken" é um campo que pode ser multivalorado. No caso de ser multivalorado, seus valores podem ser iterados através do método field.getStringValues(). Caso não seja multivalorado, seu valor pode ser obtido da mesma forma que o campo "gender";

Segue o código completo com alguns comentários:

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.opensocial.client.OpenSocialClient;
import org.opensocial.client.OpenSocialProvider;
import org.opensocial.client.OpenSocialRequestParameter;
import org.opensocial.data.OpenSocialException;
import org.opensocial.data.OpenSocialObject;
import org.opensocial.data.OpenSocialPerson;

public class CarregarPerfilEAmigosDoOrkut {

private static final String SOCIAL_NETWORK = "ORKUT";
private static final String CONSUMER_KEY = "orkut.com:623061448914";
private static final String CONSUMER_SECRET = "uynAeXiWTisflWX99KU1D2q5";
private static final String VIEWER_ID = "03067092798963641994";

/**
* Busca um perfil utilizando a API do OpenSocial e exibe os seus amigos
*
* @param args
*/
public static void main(String[] args) {

// aki é configurado o acesso a rede social
// pelo que eu entendi, ao menos até a escrita desse POST,
// é possivel acessar o Orkut, MySpace, Google (tipo o iGoogle) e PLAXO
OpenSocialClient client = new OpenSocialClient(OpenSocialProvider
 .valueOf(SOCIAL_NETWORK));

// determina as credenciais fornecidas por uma aplicação (gadget)
// instalada em um perfil na rede social
client.setProperty(OpenSocialClient.Properties.CONSUMER_KEY,
 CONSUMER_KEY);
client.setProperty(OpenSocialClient.Properties.CONSUMER_SECRET,
 CONSUMER_SECRET);

// o id do usuário que será autenticado (deve possuir o gadget
// instalado)
// e que será recuperado no metodo client.fetchPerson()
client.setProperty(OpenSocialClient.Properties.VIEWER_ID, VIEWER_ID);

try {

// carrega o perfil
OpenSocialPerson perfil = client.fetchPerson();

//parametros da consulta
Map parameters =
 new HashMap();

// determina os campos que retornarão na busca por amigos
parameters.put("fields", new OpenSocialRequestParameter(
  new String[] { "gender", "name", "languagesSpoken" }));

// configura 100 amigos como retorno
parameters.put("count", new OpenSocialRequestParameter("100"));

// carrega os 100 primeiros amigos do perfil, trazendo os campos solicitados
Collection amigos = client.fetchFriends(perfil
  .getId(), parameters);

// exibe o id do perfil
System.out.println("Perfil: " + perfil.getId());

// exibe os amigos do perfil
for (OpenSocialPerson amigo : amigos) {

 exibirAmigo(amigo);
}

} catch (Exception e) {

e.printStackTrace();
}
}

/***
* Exibe os dados de um amigo
*
* @param amigo
*            Amigo que será exibido
*
* @throws OpenSocialException
*/
private static void exibirAmigo(OpenSocialPerson amigo)
throws OpenSocialException {

StringBuilder amigoStrinBuilder = new StringBuilder("Amigo: "
 .concat(amigo.getId()));

// se o amigo tiver o campo "gender"
if (amigo.hasField("gender")) {

// valor de um campo texto simples
amigoStrinBuilder.append(", gender: ".concat(amigo.getField(
  "gender").getStringValue()));
}

// se o amigo tiver o campo "name"
if (amigo.hasField("name")) {

// itera o valor de um campo de objetos complexo (objetos
// encadeados)
for (OpenSocialObject objeto : amigo.getField("name").getValues()) {

 amigoStrinBuilder.append(", givenName: ".concat(objeto
   .getField("givenName").getStringValue()));
 amigoStrinBuilder.append(", familyName: ".concat(objeto
   .getField("familyName").getStringValue()));
}
}

// se o amigo tiver o campo "languagesSpoken"
if (amigo.hasField("languagesSpoken")) {

amigoStrinBuilder.append(", lingua: ");

// se for um campo multivalorado
if (amigo.getField("languagesSpoken").isMultivalued()) {

 // itera os valores do campo
 amigoStrinBuilder.append("{");
 for (String lingua : amigo.getField("languagesSpoken")
   .getStringValues()) {

  amigoStrinBuilder.append(lingua.concat(","));
 }
 amigoStrinBuilder.append("}");

} else {

 // é valor de um campo texto simples
 amigoStrinBuilder.append(amigo.getField("languagesSpoken")
   .getStringValue());
}
}

// exibe as informações do amigo
System.out.println(amigoStrinBuilder.toString());
}
}

Se vc souber de mais detalhes e quiser compartilhar, ou fazer alguma observação, por favor, sinta-se a vontade para comentar.

É isso!