Se tinha uma coisa que me segurava quando estava começando a programar era subdividir meu programa. Sério. Até que isso se tornou insuportável quando tive que fazer um trabalho na facu, e escolhi usar OpenGL. DIgo, o usuário precisava digitar o que ele queria desenhar, entrar com os valores das medidas, e eu precisava desenhar. Oh Gosh! Minha saída foi usar threads, no que foi meu primeiro contado com Win32 API.

Sim, o trabalho ficou muito bom. Aliás, foi um puta trabalho em conjunto, meu, do Ports e do Baldim.

Tinha feito na época um .c todo comentado, tim-tim por tim-tim, até para futuras consultas. Pois bem, segue abaixo:

 /*
    só para constar:
        DWORD = double word;
    ora, WORD é um tipo do tamanho básico da sua máquina;
    assim sendo, se vc tá programando para uma máquina x86 (32 bits), uma WORD terá 32 bits [4 bytes]
    e adivinha? uma variável do tipo DWORD terá o dobro!! (nesse caso, 64 bits, ou 8bytes)

    Agora, se vc é fodão e tá programando para uma plataforma 64 bits, então vc pega tudo oq eu falei acima,
    e multiplica por 2 !
    =)

    ooooutra coisa
        LPVOID = void *

    simples assim.
    */

#include <cstdlib>
#include <iostream>
#define WIN32_LEAN_AND_MEAN //para deixar a importação da windows.h mais 'light'
#include <windows.h> //todas funções aqui listadas estão no windows.h.
using namespace std;

DWORD WINAPI Thread(LPVOID);
/*
    Defini a função que será minha thread. O nome Thread não é reservado, ou seja, se eu quisesse que minha
    thread chamasse pnc, faria:
        DWORD WINAPI pnc(LPVOID);
    sem problemas.

    Como vc pode ver, a API do Windows utiliza ponteiros para controlar uma Thread. Por isso que vc passa um ponteiro na
    chamada. Segue abaixo a definição oficial:

    DWORD (WINAPI *LPTHREAD_START_ROUTINE)(LPVOID)

*/

int main(int argc, char *argv[])
{
    DWORD id_da_thread;
    HANDLE manipulador_thread = CreateThread(0,0,Thread,0,CREATE_SUSPENDED,&id_da_thread); //retorna 0 se não criou, e o handle se criou
    int estado;
/*

    HANDLE WINAPI CreateThread(
    LPSECURITY_ATTRIBUTES ThreadAtt,
    SIZE_T Tamanho_da_Stack,
    LPTHREAD_START_ROUTINE sua_thread,
    LPVOID argumento,
    DWORD flags,
    LPDWORD id_da_sua_thread
    );  

    ThreadAtt:
    ponteiro para uma estrutura do tipo LPSECURITY_ATTRIBUTES que contém atributos de segurança da Thread.
    Se passado como ZERO, a Thread é criada com atributos padrões.

    Tamanho_da_Stack:
    tamanho que vc precisarah inicialmente da stack em bytes. Se ZERO, o sistema 'define' um tamanho padrão.
    Só é bom vc mexer nisso se vc souber oq vc tá fazendo...

    Argumento:
    um argumento opcional para a sua thread.

    Flags:
    Esse é importante: define o comportamento da Thread logo após ser criada.
    Vc pergunta: 'Mas como assim??'
    Eu digo:
        Se vc coloca um zero nisso, sua thread será 'executada automaticamente' ao ser criada...
        Ou seja, vai começar a executar o código que vc colocou lá, 'sozinha'.
        Agora, se vc colocar "CREATE_SUSPENDED" (sem as aspas, por favor), acontecerá o seguinte: a thread será criada,
        mas ela estará no 'pause', ou seja, ele existirá lá, bonitinha, e esperará vc dizer: 'rode filha, rode".
        Vc diz: "Meu Deus, como eu faço pra dizer 'rode filha, rode' ???
        Fácil. Graças a Deus tem uma função chamada ResumeThread(HANDLE manipulador_thread) que faz isso pra vc!
        Ficou com dúvidas sobre o ResumeThread()? Tem a sintaxe lá embaixo..!!

    ThreadId:
    ponteiro (sim, ponteiro.. por isso que usei o '&') para uma variável do tipo DWORD que irá armazenar a identificação
    da Thread. Se ZERO, o argumento é ignorado. 

    A função CreateThread() retorna um Handle para a thread criada, do contrário, é retornado um Handle Nulo, ou seja, ZERO.
*/

    if ( manipulador_thread == 0 ){ // não criou, manipulador é zero
        cout << "Não pude criar a thread" << endl;
        return 0;
    }

    cout << "Legal, criei a thread, vou exibir uma janela da sua main.." << endl;
    system("pause");
    MessageBox(0,"MENSAGEM DA MAIN","Minha primeira Thread",0);

    cout << "Ok, agora vou \"resumir\" a thread..." << endl ;
    cout << "Fica esperto que assim que eu resumir, abrira um messagebox... " << endl;
    system("pause");

    if ( (ResumeThread(manipulador_thread)) == 0 ){
        cout << "Não consegui resumir a thread!!" << endl;
        exit(-1);
    }
    cout << "Thread resumida com sucesso..." << endl;

    cout << "Bye!" << endl;

    WaitForSingleObject(manipulador_thread, INFINITE);
/*
    DWORD WINAPI WaitForSingleObject(HANDLE manipulador_thread,DWORD tempo);

    manipulador_thread:
    manipulador da Thread;

    tempo:
    tempo em milisegundos que o programa deve aguardar.
    Caso a constante "INFINITE" seja especificada, o programa aguarda o tempo necessário até que a Thread seja finalizada,
    retornando um valor.

    é como se fosse um timer..
    ele vê: "Hum, já se passaram XXX milisegundos.. hora de 'matar' a thread..!"
*/

/*

    Então temos algumas funções importantes:

    *********************************
    BOOL  TerminateThread ( HANDLE seu_manipulador_thread, DWORD codigo_saida );

    OK, aqui é fácil, certo?
    vc vai terminar a Thread cuja seu manipulador manipula (foda-se a redundância), e vc também saberá
    se vc obteve sucesso no que vc tava rodando nela.. (basicamente é o return que vc implementou nela.)

    foda né?
    mas não é só isso...
    se vc reparou, essa função tem um retorno booleano! Se vc receber 0 é pq vc NÃO conseguiu 'matar' a thread.
    Bom, isso significa que vc se fodeu? Provavelmente sim, mas não necessariamente.
    MAS, se vc receber um 0 (false) é pq deu tudo certo (torça por isso...+) ).
    *********************************

    ****************
    CloseHandle(th);

    Esse acho que não precisa dizer mais nada, a não ser que é um pseudo-free().
    Lembre-se: chame-a por último... seja esperto.
    ****************
    */

    system("pause");
    TerminateThread(manipulador_thread,0);
    CloseHandle(manipulador_thread);
    return 0;

}
/* FUNCOES IMPORTANTES:

**************
    DWORD WINAPI SuspendThread(HANDLE manipulador_thread);

     maipulador_handle:
            manipulador da thread que se deseja pausar;

        A função retorna 1 se a thread especificada for interrompida corretamente,
        ou retorna 0, se o processo falhar.
*************

*************
DWORD WINAPI ResumeThread(HANDLE manipulador_thread);

     manipulador_thread:
            manipulador da thread que se deseja resumir;

    A função retorna o valor 1 se a thread for resumida corretamente,
    ou retorna 0, se falhar.
**************

*/

//aqui começa minha thread

DWORD WINAPI Thread(LPVOID valor)
{
    MessageBox(0,"Mensagem da Thread","Aprendendo a mexer com Thread",0);
    return 0;
}

Espero que isso te ajude. É realmente muito simples… você cria, cria uma thread – mandando como parâmetro sua função, e então só controla seu funcionamento – pausa, suspende, continua, mata, etc…

Esse post é para aqueles que acham que foi o “Java que inventou as threads”. Tsc tsc…

After a long time ago, estou de volta. O post não é inédito, mas é legal até, por isso está sendo postado aqui. Vou apenas dar uma limpada, porque é pertinente do ser humano sempre mudar, evoluir.
“Como esse é meu post inicial, a boa conduta manda que seja postado algo legal. Então assim o farei (ignorando que algo “legal” seja relativo). Hoje perdi duas horas e meia da minha vida para tentar usar minha banda larga (mero Speedy® de 1 Mb – pra não dizer outra coisa…) no meu notebook, usando uma rede bluetooth® . Levando em conta que hoje em dia, literalmente, o tempo é escasso, pode-se dizer que apanhei (ah sim, a palavra escasso se torna ainda mais impactante se você considerar que nessa próxima semana terei prova de Análise Numérica II e trabalho de Engenharia de Software – trabalho esse que faço nesse exato momento, em Alttab), mas valeu a pena. Vejamos o domínio do problema:

Preciso compartilhar meu Speedy® (ahh, chega, não vou usar mais o marca registrada) – que de speedy não tem nada – para também poder acessar a rede-mãe (vulva Internet) no meu note. Ahh, claro, mas não tenho roteador wifi. O meu Speedy está diretamente ligado ao meu PC, que também está equipado com um nobre adaptador bluetooth do gray market (lê-se Santa Ifigênia) – de vinte e cinco pilas. Meu note tem um bluetooth integrado da Dell (é divulgado como masterblaster, mas whatever, ainda é só um bluetooth).

OS note: Vista Basic – não me xinguem, tá no dual boot.

OS PC: WinXP SP2

Vou fazer um shortcut, porque se eu for contar tudo o que fiz, vou fazer você também perder 2,5h.

O primeiro que se tem a fazer é parear os dois dispositivos.. Easy easy, but ele não queria parear fácil. Descobri que se eu parear do Vista para o XP é mais sussa – de primeira.

Depois tem-se que listar e selecionar os serviços que o bluetooth do PC dispõe. Seleciona todos, evite trabalho futuro

Vai no PC, compartilha seu Speedy (sabe aquela conexão de Banda Larga, que você conectava como internet@speedy.com.br, e que agora não mais [deve ter feito sua continha no Terra-like] ?). Botão direito, última aba, todos checkbox. Importante: Resete a merda do modem. Perdi 40 minutos para descobrir que sem isso, as alterações não vingam. Ótimo, já deu um grande avanço.

Agora faltam duas coisas importantes:

i. Configurar seu serviço bluetooth de Rede no WinXP (vamos chamá-lo de Host, já que a Banda Larga está nele). Isso pode variar da versão do Software usado para seu bluetooth adapter. Usa-se comumente WIDCOM. Ok, liste seus serviços disponíveis, escolha PAN Bluetooth, diga que outros dispositivos se conectarão a Internet utilizando essa rede, e só aplicarok.

Depois disso, conecte (a+a) sua Banda Larga.

ii. Client side (Vista, no meu caso): “Configurar uma conexão ou uma rede” , “Conectar a uma PAN Bluetooth”. Ele vai te listar os Pontos de Acesso (deverá aparecer sua PAN configurada no WinXP). Conecte-se a ela (

i. Seu host dirá que alguém está tentando se conectar a sua rede, permita.

ii. Sua rede será efetivamente criada. [Definirá um IP address, etc]. Estará pronta quando, obviamente, aparecer: Conectado a .. , velocidade 700kbps [sim, estamos limitados a essa velocidade...].

iii. Finalmente seu client se mostrará conectado. Inicialmente, dirá ter disponível apenas “Acesso Local”, mas não demorará nada para ele reconhecer que tem acesso a Internet nesse rede!!

Pronto, cá estamos…

Usando meu laptop no quarto, enquanto minha irmã baixa o Dr. House dela na sala. Lembre-se:

i. Um dispositivo bluetooth pode conectar-se a outros sete. Pode parecer pouco. Mas só parece. Pesquise por piconet.

ii. Ainda tenho minha rede limitada a 700 kbps. Isso porque meu adaptador que uso no PC é da versão 1.2. Mas tudo bem, já que meu Speedy é de 1 Mb. Se você mora em São Paulo, e fora da “área de cobertura” do Vírtua, deve me entender que, em medidas speedyanas, Banda Larga de 1 Mb == 2 Mb == 4 Mb. Isso porque a QoS da Telefônica é péssimo, vergonhoso. Então, embora você ganhe alguns kbps de down, ainda assim é patético.

Fazer o quê? Não tem cão, caça com o gato. Não tem roteador wifi, navega com NAP Bluetooth + Shared Broadband.”

Estava tentando dominar o mundo exercitando minhas habilidades em SQL injection, té que me intriguei com uma tentativa de [pífia] evitar esse atentado-violento-ao-pudor-sem-pudor. Enfim, algo que developers WEB deveriam estar skinhead de saber (ou não),  existe algo chamado magic quotes, que de tão ineficiente, foi retirado do PHP 6.0 or newer.

Se trata de adicionar uma barra [\] antes do ['] (vulgo apóstrofe).

Exemplo

'banana nanic%'
ficaria
\'banana nanic%\'

Bom, isso é um problema. Não podemos mais personalizar nossa query! (Notem o eufenismo sapeca).

Pois é, mas se pode rodar query também utilizando o valor decimal ascii do(s) caractere(s) (sim, pode-se também utilizar hexa :B ).

Isso significa que algo do gênero:

select * from cadastro LIMIT 1,1

ficaria:

concat(
char(115),char(101),char(108),char(101),char(99),char(116),char(32),
char(42),char(32),char(102),char(114),char(111),char(109),char(32),
char(99),char(97),char(100),char(97),char(115),char(116),char(114),
char(111),char(32),char(108),char(105),char(109),char(105),char(116),
char(32),char(49),char(44),char(49))

Pegou?

Assim sendo, segue código em C que te faz essa conversão:

/* 
TODO: backspace treatment
*/
#define MAX 100 //define tamanho máximo de caracteres de entrada

int main (void){
    char c;
    int i, *vetor;
    int efetivo=0; //tamanho real da query

    vetor = (int *) malloc (sizeof(int) * MAX);
    for (i=0; i<MAX; ++i){
         *(vetor+i) = getch();
         //pra debug
         printf("%c",vetor[i]);
         if ( *(vetor+i) == 13 ) //vai lendo até [ENTER]
            break;
         efetivo++;
    }
    printf("concat(");
    for (i=0; i<efetivo; ++i){
        if (i+1 == efetivo){
            printf("char(%d))",vetor[i]);
            break;
        }
        printf("char(%d),",vetor[i]);
    }
    getchar();     
    return 0;
}

Entenda sobre essa e outras técnicas mais efetivas aqui.

Por hoje é só, fiquem com Deus, e até amanhã.

Todos sabemos o que é o Twitter, e sim, gostamos pra caramba dele! Não tem a poluição gentalha gente feia inconveniência costumeira do Orkut, e só por esse fato já deveria ser adorado. Enfim, isso é opinião, e a minha – e como você está no meu blog, por favor, respeite.

Senta que lá vem a história: Há tempos que queria fazer uma integração C com Java. Bom, então surgiu uma grande oportunidade, uma vez que a biblioteca mais digna que acessa a biblioteca do Twitter que achei foi a JTwitter, que realmente é muito boa e fácil de usar. Enfim, já tinha feito, há algum tempo (em tempos remotos de Infra na Amdocs), um código em C++ que listava os processos que estavam rodando. (De certo modo, acho que é meio redundante a última frase, mas whatever)

Lá vai um resumo: Tranformei meu código em C++ numa dll e, utilizando um negócio bem porco (como Java, em geral), chamado JNI (Java Native Interface), fiz a integração do meu código em Java – que também utilizava a biblioteca JTwitter. Fiz um enhancement tolo para que reconhecesse mensagens enviadas diretamente para mim no Twitter, assim minha gororoba auto interagia com o meu suposto amigo, respondendo-o se eu estava ou não rodando tal processo  no momento. Sabe, falando agora, parece-me uma idéia tão ridícula… Mas foda-se.

Ingredientes:

- Saber como se acessa a API do WindowsX para listar processos. Tão ridículo que me dá comichões. Mas isso é assunto para outra hora.
- Saber como criar uma dll  – basicamente:

gcc -shared -o minhadll.dll meuobjeto.o

- Saber como fazer a integração de C com Java.

Acho que o que vale explorar é esse último tópico. É facil – verdade – mas precisa de atenção. Vou descrever, depois mostro na prática.

Basicamente, você cria um código em Java que carrega uma dll – ignore o fato de ela não existir; pelo menos por enquanto. Ao tentar rodá-lo, obviamente você terá um erro de linkagem. Mas não queremos que funcione! Queremos só ver como seria feita a chamada dessa dll em C. Rápido demais? Certo. Repare que, mesmo dando erro, seu javac gerou um .class! Amazing. Mas isso não justifica minha fala agorinha. Não? Claro que sim!

Existe um utiliário que a Sun bota na JDK dela, se não me engano desde a 1.1, chamado Javah (esse nome definitivamente me lembra os trocadilhos com Java, em tempos de técnico), que basicamente te gera headers e códigos em C a partir de uma .class.

Agora sim! Tudo se encaixa. Pseudo-criamos um código em Java com linkagem para nossa futura dll, vemos como fica a chamada em C/C++ usando o javah, fazemos um merge com nosso código na dll, compilamos-a, e enfim recompilamos nossa classe em Java que terá acesso ao Twitter!

Boralah, mãos a obra!

Código da DLL:

nomeei carinhosamente de TesteTwitter.cpp

#include <jni.h>
#include "TesteTwitter.h"
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include
<psapi.h>
#define     SIZE    1024

//some prototypes
int update_processes_array( DWORD *processes_array,
                            DWORD array_size,
                            DWORD *hm_processes,
                            DWORD bytes_returned);
int imprime_processo(DWORD pid);                            

/*
Procura o processo $nome. Se estiver rodando retorna seu PID, senão retorna 0
*/
int procura_processo(char * nome_processo){
    DWORD  * processes_array ; //array de processos, contem PIDs, e é do tamanho de SIZE
    DWORD  bytes_returned; //quantos processos tem no processes_array
    DWORD  array_size; //double word que armazenará o SIZE definido
    DWORD  hm_processes; //how many processes ;)
    HANDLE handle_processo;
    int i; //contador
    char nome[1024]; //armazenará o nome do módulo, null se der pau
    char *nome_upper; //diferencas de case
    //char * nome_processo_upper;
    nome_upper = (char *) malloc(sizeof(char)*1024);
    //nome_processo_upper = (char *) malloc(sizeof(char)*1024);

    if (nome_processo == NULL || strlen(nome_processo) < 4 )
    // evita burrice, lembre-se: vc tá no windows, o strlen(processo) mínimo que vc tem é 4,
    // ou seja, .xxx  - extensão, meu fillho!
    {
        return 0; //fala que não achou
    }
    strcpy(nome,"null");//como dito ;)
    array_size = SIZE; //blah
    //alloc memory for processes' array
    processes_array = ( DWORD * ) malloc( sizeof(DWORD) * SIZE );
    //atualiza o array de processos ;)
    if ( hm_processes = update_processes_array(processes_array, array_size, &hm_processes, bytes_returned) ){
        printf("Array de Processos atualizado com sucesso");
    }else{
        printf("Erro ao atualizar lista de processos");
        return 0;
    }

    printf("\nNo momento, temos %d processos.", hm_processes);
    for (i=0; i<hm_processes; i++){
        //tenta pegar um handle pro processo, but retorna null se der pau
         handle_processo = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processes_array[i]);
         //consegui? então pega o moduleBaseName!
         if( handle_processo != NULL){
             HMODULE vetor_handle_modulo;
             DWORD tamanho;
             if(EnumProcessModules(handle_processo, &vetor_handle_modulo, sizeof(vetor_handle_modulo), &tamanho)){
                 GetModuleBaseName( handle_processo, vetor_handle_modulo, nome, sizeof(nome)/sizeof(char));
             }
        }

        nome_upper = strupr(strdup(nome));
        nome_processo = strupr(strdup(nome_processo));
        if(! strcmp(nome_processo,nome_upper) ){  //ve se o processo atual (processes_array[i]) é o processo que estamos looking for.
            printf("\nAchei o %s", nome);
            CloseHandle(handle_processo);
            return (int)processes_array[i];
        }
    }
    printf("\nProcess %s not found!",nome_processo);
}

bool get_Processes( DWORD * processes_array,
                    DWORD size_processes_array,
                    DWORD *bytes_returned)
{

    if ( EnumProcesses( processes_array , size_processes_array , bytes_returned ) )
        return true;
    else
        return false;

}

/*
Recebe um PID e imprime (ou pelo menos tenta imprimir) seu module name
*/
int imprime_processo( DWORD pid ){
     //armazenará o nome do módulo, null se der pau
     char nome[1024];
     strcpy(nome,"null");
     //tenta pegar um handle pro processo, but retorna null se der pau
     HANDLE handle_processo = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
     //consegui? então pega o moduleBaseName!
     if( handle_processo != NULL){
         HMODULE vetor_handle_modulo;
         DWORD tamanho;
         if(EnumProcessModules(handle_processo, &vetor_handle_modulo, sizeof(vetor_handle_modulo), &tamanho)){
             GetModuleBaseName( handle_processo, vetor_handle_modulo, nome, sizeof(nome)/sizeof(char));
         }
    }
    printf("%u  -  %s", pid, nome);
    CloseHandle(handle_processo);
    if(pid)
        return pid;
    return 0;
}

/*
returns:
    < -1  >     -    if fails on get_processes function
    < >= 0 >    -    how many processes are running at this moment
*/
int update_processes_array( DWORD *processes_array,
                            DWORD array_size,
                            DWORD *hm_processes,
                            DWORD bytes_returned){
    if (! get_Processes( processes_array , array_size , &bytes_returned) )
            return -1;
        else
            return *hm_processes = bytes_returned / sizeof(DWORD) ;

}

JNIEXPORT jint JNICALL Java_TesteTwitter_escreve(JNIEnv *env , jobject obj, jstring processo)
{
//Meu Deus, que palavras feias são essas! Pois é, também acho. Isso vem do .h gerado ao vc rodar o javah
//que, aliás, não disse comofas:
// javah classe_java
//ele vai te gerar um .h. A partir dele, vc se vira.
        int resultado = 0;
        jboolean iscopy; //boolean do java
        const char  *nome_processo = (env) -> GetStringUTFChars(processo,&iscopy);
        if (nome_processo == NULL){
            return 0; // erro em alocação de memória
        }
        printf("\n%s\n",nome_processo);
        resultado = procura_processo((char *)nome_processo);
        return resultado;
}

Seria legal se você tirasse, depois de entender o código e vê-lo rodar, todos os printf()’s da DLL. Isso não se faz.

Você também vai precisar de um arquivo .def, contendo informações básicas, tipo:

Java_Programa_método-a-ser-exportado

EXPORTS
Java_TesteTwitter_escreve

Agora, bora compilar isso. Pay attention here!!

Primeiro você vai gerar um .o, nos moldes simples:

gcc -c -I"path que vc quiser incluir (onde estiverem libraries que vc botou no include, por exemplo)" -o nome_do_objeto.o sourcecode.cpp

Importante você saber que, como você está usando a JNI.h, você precisa colocar o Path de seu header e implementação (JDK_folder\include e JDK_folder\include\win32). Ficaria algo do gênero:

gcc -c -I"C:\Arquivos de programas\java\jdk1.6.0_11\include" -I"C:\Arquivos de programas\java\jdk1.6.0_11\include\win32" -o TesteTwitter.o TesteTwitter.cpp

Agora que você já tem seu nome_do_objeto.o, mande bala:

gcc -shared -o"meu_path\minhadll.dll" "meu_path\nome_do_objeto.o" "meu_path\meu_file_de_definicao.def" -lpsapi

//ou, pegando na sua mão,

gcc -shared -o"C:\Users\Cael\TesteTwitter.dll"  "C:\users\Cael\TesteTwitter.o" "C:\Users\cael\TesteTwitter.def" -lpsapi

//coisa que vc precisa saber: -lpsapi diz ao gcc que vc está usando rotinas da biblioteca PSAPI. Óbvio.

Se tudo der certo, você tem sua DLL!

Agora vamos a parte do Java (eu sei, eu sei, fazer o quê.. )

import java.util.List;
import winterwell.jtwitter.*; //dando import na library JTwitter
import winterwell.jtwitter.Twitter.Message;

public class TesteTwitter {
    static long ultimo=45871821; //ID da mensagem que, a partir dela, o código irá responder
    public native int escreve(String processo);   
    static{
    System.load("C:/Users/Cael/TesteTwitter.dll");
    System.out.println("Loaded");
    }
    public static void main(String[] args) {
        int PID;
        List<Message> lista;
        Message mensagem;
        Twitter cael = new Twitter("meu_login","minha_senha"); //preciso te lembrar de alterar?
        while (1==1){
            try {
                Thread.currentThread().sleep(60000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(cael.getRateLimitStatus());
            lista=cael.getDirectMessages();
            if (lista.size() > 0){
                mensagem = lista.get(0);
                System.out.println(mensagem.getText());
                if (mensagem.getId() != ultimo){

                    /*DEBUGGER*/

                    System.out.println("Mensagem nova!");
                    System.out.println("DE: " + mensagem.getSender());
                    System.out.println("TEXTO: " + mensagem.getText());

                    /*END*/

                    PID = new TesteTwitter().escreve(mensagem.getText());
                    if (PID !=0){
                        cael.setStatus("@" + mensagem.getSender().screenName +  " Sim, estou rodando o " + mensagem.getText() + ". PID " + PID);
                    }else{
                        cael.setStatus("@" + mensagem.getSender().screenName +  " Não estou rodando o " + mensagem.getText() + ". Retorno da API (PID) " + PID );

                    }
                    ultimo = mensagem.getId();
                    System.out.println("Twitter respondido!");
                    System.out.println("Para " + mensagem.getSender());
                    System.out.println("ULTIMO = " + ultimo);
                }           
            }
        }
    }
}

Warnings:

- O Twitter tem uma política de acesso aos seus dados via API. Sugiro que você dê uma pesquisada, antes que tenha sua conta bloqueada (como eu) por algumas horas. Isso te explica o Sleep() no código.

- Sim, o código tá muito verbose. Portanto, altere-o do jeito que você quiser.

- A variável estática ultimo está sendo atualizada durante a execução. E somente durante. Você pode alterá-la, salvá-la, armazená-la do jeito que você quiser após rodar o código. Senão, toda vez que você rodar, ele vai responder tudo de novo. Eu ainda estou no CTRL+C/V, pois não quero gastar muito tempo com esse assunto, e porque, principalmente, odeio Java.

Fiz uns updates para criar e matar processos remotamente, coisa fácil. Vá na pagina do msdn que te passei o link, comece a fuçar por lá. Mas cuidado com isso, não deixe ninguém rodar processo remotamente na sua máquina. Ou deixe.

Dúvidas, sugestões, declarações de amor ou xingamentos, comente.

Abraços,

Cael