Se você caiu de paraquedas nesse post eu sugiro a leitura do post anterior: Criando um cliente para Twitter – Parte 1.

Segunda parte do nosso tutorialzinho!
Agora iremos criar:

• Um formulário para realizar o login (sem utilizar o OAuth)
• Um formulário para:
  • mostrar os ultimos tweets da timeline
  • possibilitar o envio de um tweet

Vamos lá então, crie um novo projeto no NetBeans e adicione o twitter4j nas bibliotecas.
Adicione um JFrame e deixe parecido com este:

O campo para usuário é um JTextField com o nome jTF_Nome.
O campo para a senha é um JPasswordField com o nome jPF_Senha.
O JButton não tem nada de mais, só coloquei o passarinho ai pra ficar mais bonitinho. ^^

O JPasswordField é mais do que um JTextField que mascara as letras, existem todo um esquema de segurança por trás deste componente. Tanto que a recuperação do que foi digitado é um pouco mais chatinha: ao invés de uma String, é recuperado um objeto do tipo char[]. Como o login é exige duas strings (usuário e senha) como parâmetro, fiz um método para realizar a conversão.
Vamos ao código do botão responsável pelo login:

public String pegaSenha() {
	char[] senha = jPF_Senha.getPassword();
	String str = "";
	for (int i = 0; i < senha.length; i++) {
		str += senha[i];
	}
	return str;
}
 
public void EfetuarLogin() {
	String usu = jTF_Usuario.getText();
	String senha = pegaSenha();
 
	try {
		Twitter t = new TwitterFactory().getInstance(usu, senha);
		User u = t.verifyCredentials();
 
		Principal p = new Principal(t,u);
		p.setLocationRelativeTo(null);
		p.setVisible(true);
 
		this.dispose();
	} catch (TwitterException e) {
		if (e.getStatusCode() == 401) {
			JOptionPane.showMessageDialog(this, "Usuário e/ou senha inválidos!");
		}
	}
}

Nada muito novo em relação ao post anterior. É criado um novo objeto Twitter com os dados que foram digitados. Para garantir que os dados estão corretos existe o método verifyCredentials() que em caso de sucesso retorna um objeto User que referencia o usuário que acabou de se logar.  Se estiver tudo certo então chama o próximo JFrame (Principal) e retira o formulário de login da memória (uma vez que ele não será mais usado).

Em caso de falha, é jogada uma exceção do tipo TwitterException. Se o status code da exceção for 401 significa que o usuário e/ou senha estão errados, daí é só avisar o usuário.

O próximo formulário é um pouco mais complexo… Adicione um novo JFrame ao projeto e chame de Principal.java. Deixe ele parecido como este:

Segue a lista dos componentes:

JLabel jL_Foto –> tamanho 48×48

JTextArea jTA_Status –> pra digitar a mensagem

JLabel jL_Restantes –> vai indicar quantos caracteres ainda restam

JScrollPane jScrollPane2 –> a borda foi mudada para ficar mais legal como esta na figura (Ultimos Tweets)

JPanel jP_Tweets –> este panel vai receber os ultimos tweets, ele fica dentro do jScrollPane2. O layout desse panel é do tipo BoxLayout (layout de caixa)  com a propriedade eixo setada em Y.

Vamos lá então! Exibindo os últimos tweets:

public class Principal extends javax.swing.JFrame {
    private Twitter t;
    private User eu;
    Image foto;
 
    /** Creates new form Principal */
    public Principal(Twitter t, User eu) {
        this.t = t;
        this.eu = eu;
        initComponents();
        recuperarDados();
    }
 
    private void recuperarDados() {
        this.foto = this.getToolkit().getImage(eu.getProfileImageURL());
        jL_Foto.setIcon(new ImageIcon(foto));
        carregaTimeline();
    }
 
    public void carregaTimeline() {
        try {
            JPanel pane;
            JLabel novaFoto;
            JTextArea msg;
            int i = 0;
 
            jP_Tweets.removeAll();
 
            for (Status s : t.getFriendsTimeline()) {
                i++;
                //cria o panel
                pane = new JPanel(new FlowLayout(FlowLayout.LEFT));
                pane.setBorder(new LineBorder(Color.black, 1));
                pane.setSize(370, 50);
 
                //cria o label com a foto
                novaFoto = new JLabel(new ImageIcon(this.getToolkit().getImage(s.getUser().getProfileImageURL())));
 
                //cria o textarea com o texto
                msg = new JTextArea(3, 27);
                msg.setEditable(false);
                msg.setText(s.getText());
                msg.setLineWrap(true);
 
                pane.add(novaFoto);
                pane.add(msg);
                jP_Tweets.add(pane);
            }
 
        } catch (TwitterException ex) {
            JOptionPane.showMessageDialog(this, "Erro recuperando a timeline: " + ex.getMessage());
        }
    }
 
    ...
}

A classe possui 3 atributos que eu considero completamente autoexplicativos mas vamos dar uma pequena passada por eles:

• Twitter t –> velho conhecido nosso não é…
• User eu –> para guardar as informações de quem está logado
• Image foto –> para guardar a imagem de perfil do usuário

Logo quando o formulário é criado, o método recuperarDados() é chamado, a foto do usuário é carregada e então o método carregaTimeline() é invocado.

O carregaTimeline() cria dinamicamente a lista com os ultimos tweets. O código está todo comentado e está bem fácil de entender.

Vale ressaltar que para a lista ficar certinha (um tweet por linha) o layout do panel jP_Tweets deve ser BoxLayout!

Vamos para a próxima parte então: Atualizando o status.

Mude a propriedade lineWrap do jTA_Status para true, com isso a linha não vai ultrapassar os limites do text area e o texto vai ficar dentro dela.

Para fazer a contagem dos caracteres restantes vamos utilizar de uma funcionalidade bem interessante do text area: O evento caretUpdate é chamado toda vez que uma tecla é adiciona ou deletada, sendo assim, adicione o seguinte código neste evento caretUpdate do jTA_Status:

private void jTA_StatusCaretUpdate(javax.swing.event.CaretEvent evt) {
    jL_Restantes.setText(String.valueOf(140 - jTA_Status.getText().length()));
}

Próximos passos: não deixar o usuário digitar mais do que 140 caracteres e postar a mensagem.

O que vamos fazer é o seguinte: se o usuário for digitar o 141º a gente simplesmente cancela ele. Podemos tratar as duas funções no evento keyTyped do jTA_Status.

Segue o código:

private void jTA_StatusKeyTyped(java.awt.event.KeyEvent evt) {
    if (jTA_Status.getText().length() == 140) {
	evt.setKeyChar((char) KeyEvent.VK_CLEAR);
    }
 
    if (evt.getKeyChar() == KeyEvent.VK_ENTER) {
	try {
	    t.updateStatus(jTA_Status.getText());
            jTA_Status.setText("");
	    carregaTimeline();
	} catch (TwitterException ex) {
	    JOptionPane.showMessageDialog(this, "Erro atualizando o status: " + ex.getMessage());
	}
    }
}

Muito tranquilo. Pouco código e muitas funcionalidades.

Agora nosso cliente já está com uma cara bem legal. Eu implementei mais algumas frescurinhas e ele ficou assim:

Ali embaixo da minha foto tem um label que mostra um pedacinho do ultimo post… embaixo da lista mostra quantos tweets foram carregados… enfim, um monte de frescura que eu nem mostrei aqui…

Quem quiser conferir o projeto completo pode pegar aqui.

Sugestões para quem quiser aperfeiçoar um pouco mais esse humilde cliente de Twitter:

• De 5 em 5 minutos recarregar a lista de tweets. Dica: utilizando Threads fica facinho.
• Ao clicar na foto da pessoa, uma janela abre com as informações da pessoa.
• Adicionar um botão para retwittar a mensagem.

Quem quiser tem como brincar bastante com isso ai…

Valew pessoal,

[]s e até a próxima.

Saab.

Vamos ao assunto de hoje: criando um cliente de Twitter.

Ah o Twitter… Quem não usa o twitter? Quem nunca ouviu falar do twitter? Acho que hoje em dia é bem difícil.
Mas aproveitar todas as funcionalidades do twitter no navegador é – na minha opinião – um saco! Toda hora fica recarregando, tem horas que aparece aquela PIIII daquela baleia dizendo que o servidor está congestionado…

Enfim, para não passar por esses probleminhas normalmente a gente apela para os clientes de twitter, que nada mais são do que softwares que acessam o twitter com a nossa conta e mostram as atualizações de um jeito bem bonitinho e cheio de frescuras - vide TweetDeck, ÜberTwitter, entre outros.

Contudo, esses clientes não foram feitos especificamente para nós, ou seja, podem existir funções que não sejam do nosso gosto e pode também faltar algumas funções que sejam essenciais para nós. Então por que não criar o seu próprio cliente de Twitter? É muito simples e personalizável, podemos criá-lo do jeito que quisermos. Vamos a algumas informações essenciais:

Para conseguir mostrar as informações da nossa conta do Twitter em uma telinha de um software desktop, eles fazem chamadas para a API do Twitter. A equipe do Twitter já deixou tudo pronto pra nós não termos muito trabalho recuperando as informações. Basta fazer uma requisição HTTP e será retornado um XML com as informações requisitadas.

Para a sorte do desenvolvedor Java, um tal de Yusuke Yamamoto desenvolveu uma biblioteca chamada Twitter4J onde ele já encapsula todas as requisições HTTP, tratamentos da resposta, enfim, é responsável por todo o trabalho duro necessário para interagir com o Twitter, sendo assim, nós podemos nos concentrar mais na aplicação em si.

Nessa primeira parte do tutorial vou mostrar apenas como conectar, atualizar o status e recuperar a timeline. Nas próximas partes a gente vai modelando e dando vida ao nosso cliente.

Mãos a obra então: baixe o twitter4j-core e crie uma nova aplicação no NetBeans (não precisa ser aplicação desktop por enquanto). Adicione a biblioteca que você acabou de baixar às bibliotecas do projeto como na figura:

O código da aplicação é muito simples, como segue abaixo:

public static void main(String[] args) {
    try {
        String usuario = "seu nome de usuario";
        String senha = "sua senha";
        //conectando
        Twitter twitter = new TwitterFactory().getInstance(usuario, senha);
 
        //recuperando a timeline
        List<status> timeline = twitter.getFriendsTimeline();
        System.out.println("Exibindo a timeline");
        System.out.println("----------------------------------------");
        for (Status s : timeline) {
            System.out.println(s.getUser().getScreenName() + " - " + s.getText());
        }
        System.out.println("----------------------------------------");
 
        //atualizando o status
        String novoStatus = "#JavaSimples - testando o twitter4j!";
        twitter.updateStatus(novoStatus);
        System.out.println("Status atualizado com sucesso!");
    } catch (TwitterException ex) {
        System.out.println("Erro: " + ex.toString());
    }
}

Para conectar no Twitter é criado um objeto da classe Twitter que é um intermediário entre a nossa aplicação e a API do Twitter, ou seja, tudo o que nós quisermos fazer deve ser através de um método desse objeto. Ele é criado seguindo um padrão de projeto (olha a engenharia de software marcando presença…) chamado Abstract Factory – que provê a padronização na criação de um objeto, mas como a engenharia não é o foco aqui, vamos em frente.

Logo em seguida, é criada uma lista chamada timeline que é do tipo List<Status> e que recebe todas as atualizações das pessoas que você segue através do método getFriendsTimeLine() do nosso objeto da classe Twitter.
Cada update/status/post de um usuário no twitter é representado pela classe Status, através da qual pode-se obter qualquer tipo de informação do update/status/post. No exemplo nós recuperamos o usuário (recuperamos um objeto da classe User que contém as informações do usuário) e a partir dele, o seu screenName (sigla que te identifica no twitter. ex: fesaab) e também o texto do update/status/post.

Por fim, eu atualizo o status com uma simples mensagem e se não ocorrer nenhum erro mostra uma mensagem de sucesso.

Tudo muito prático e simples!

Ficamos por aqui nessa primeira parte do nosso tutorial sobre Java + Twitter. Quem quiser o projeto completo pode pegar aqui.

[]s,
Saab.