Classe Robot Java

Em 2008 descobri esta classe em Java. A classe ficou bem famosa depois de um advento interessante. Um funcionário de uma grande corporação utilizava esta ferramenta para bater o cartão que era feito computador do usuário. A ferramenta era programada em um determinado horário e assim ele poderia sair antes e deixar o computador ligado. A ferramenta funcionava de segunda a sexta. Porém, em um dia de feriado ele esqueceu de desativar. Os superiores o chamaram para saber como ele havia entrado na empresa em um dia de feriado. Ele contou a verdade e acabou sendo demitido por justa causa.

Alguns exemplos da classe para automatização de tarefas.



Eventos de Teclado:

void keyPress(int keycode) – utilizado para simular o pressionamento de uma tecla;
void keyRelease(int keycode) – remove o status de pressionada de uma tecla utilizada pelo método keyRelease;

Eventos de Mouse:

void mouseMove(int x, int y) – move o mouse para o posição x,y;
void mousePress(int buttons) – pressiona um dos botões do mouse;
void mouseRelease(int buttons) – remove a pressão efetuada pelo método mouseRelease(int buttons);
void mouseWheel(int wheelAmt) – Indica o número de vezes que o scroll será utilizado (aceita valores negativos).

Eventos de Vídeo:

BufferedImage createScreenCapture(Rectangle screenRect) – Captura a imagem existente na tela (na verdade no dispositivo padrão de saída);
Color getPixelColor(int x, int y) – captura a cor do pixel na posição x,y;

Métodos Acessórios:

void delay(int ms) – deixa o a instância de Robot parada (sleeping) por int milisegundos;
void setAutoDelay(int ms) – informa o tempo que a instância da classe Robot deve esperar depois de gerar um evento;
int getAutoDelay() – obtém o valor do autodeley da instância de Robot;
void waitForIdle() – Aguarda até que todos os eventos que estão na fila sejam processados;
void setAutoWaitForIdle(boolean isOn) – define se a instância sempre deve aguardar se todos os eventos da fila sejam processados;
boolean isAutoWaitForIdle() – verifica o estado do autoWaitForIdle;
String toString() – esse método dispensa comentários.






No exemplo abaixo deverá abrir uma calculadora com uma operação e um bloco de notas em seguida.

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.IOException;

public class Robo {
private Robot robot;

public Robo() throws AWTException {
robot = new Robot();
}

/**
* Executa um comando no SO..
*/
public void execute(String comando) throws IOException {
Runtime.getRuntime().exec(comando);
robot.delay(5000); // Tempo para o programa abrir
}

/**
* Copia os dados para a área de transferência.
*/
public void copiar() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_C);
robot.keyRelease(KeyEvent.VK_C);
robot.keyRelease(KeyEvent.VK_CONTROL);
robot.delay(2000);
}

/**
* Cola os dados que estão na área de transferência.
*/
public void colar() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);
robot.delay(2000);
}

/**
* Executa a digitação de uma sequência de caracteres.
*/
public void executeTeclas(int... keys) {
if (keys != null) {
for (int key : keys) {
robot.keyPress(key);
robot.keyRelease(key);
}
}
robot.delay(2000); // tempo para o usuário ver o que foi digitado
}

public static void main(String[] args) throws AWTException, IOException {
Robo robo = new Robo();

// Número 25 seguido do sinal +
int[] primeira = { KeyEvent.VK_2, KeyEvent.VK_5, KeyEvent.VK_ADD };
// Número 12 seguido do sinal =
int[] segunda = { KeyEvent.VK_1, KeyEvent.VK_2, KeyEvent.VK_EQUALS };
robo.execute("calc");
robo.executeTeclas(primeira);
robo.executeTeclas(segunda);
robo.copiar();
robo.execute("notepad");
robo.colar();
}
}

Relatório de Conexões Através de Netstat com Java

O objetivo deste código de programa é monitorar conexões que são feitas na máquina. O Netstat permite exibir as conexões e as portas utilizadas no computador exibindo o computador remoto que está conectado assim como a sua porta utilizada. O objetivo principal aqui é a segurança e monitoramento da maquina. Conforme a opção do Netsat também é possível verificar qual é o programa que está sendo utilizado naquela conexão, mas essa informação em nem todos os casos é exibida. No programa, o comando roda a cada 5 minutos (300 segundos). Caso exista algum programa indevido é necessário fazer o reconhecimento e o bloqueio através do firewall. Na classe CommandLine é executado o comando, onde o Java chama o comando em CMD.EXE do sistema operacional. Na classe MyRun3 criamos o arquivo no local determinado nomeado com a data e a hora da execução. Na classe Begginer temos a programação da chamada a cada 5 minutos e da chamada principal do inicio do programa. Os pacotes devem sex exportados pelo Eclipse através da opção JAR Executável e na combobox deve ser selecionada a classe da chamada principal que contém o método Main no nosso caso a classe Begginer.


package Cap2;

import java.io.*;

public class CommandLine {
// Needed to run commands in the command line
private Runtime runtime;
private Process process;

// Output of the executed command
private String stdinData;
private String stderrData;

// Constructor
public CommandLine() {
runtime = Runtime.getRuntime();
process = null;
stdinData = "";
stderrData = "";
}

// Return executed command output data
public String getStdinData() {
return stdinData;
}

public String getStderrData() {
return stderrData;
}

// Execute a single command with all its arguments
public void execute(String command) {
try {
process = runtime.exec(command);
} catch (Exception ex) {
System.err.println(ex);
}

pullProcessData();
}

// Execute a single command in cmdArray,
// define environment settings in envp and
// set working directory to dir
public void execute(String[] cmdArray, String[] envp, File dir) {
try {
process = runtime.exec(cmdArray, envp, dir);
} catch (Exception ex) {
System.err.println(ex);
}

pullProcessData();
}

// Obtain all data sent by the process to stdout and stderr
private void pullProcessData() {
try {
StringBuffer stdinBuffer = new StringBuffer();
StringBuffer stderrBuffer = new StringBuffer();

InputStream stdinStream = process.getInputStream();
InputStream stderrStream = process.getErrorStream();

new InputStreamHandler(stdinBuffer, stdinStream);
new InputStreamHandler(stderrBuffer, stderrStream);

process.waitFor();

stdinData = stdinBuffer.toString();
stderrData = stderrBuffer.toString();
} catch (Exception ex) {
System.err.println(ex);
}
}

// Private inner class used to handle input streams
private class InputStreamHandler extends Thread {
private InputStream m_stream;
private StringBuffer m_captureBuffer;

InputStreamHandler(StringBuffer captureBuffer, InputStream stream) {
m_stream = stream;
m_captureBuffer = captureBuffer;
start();
}

public void run() {
try {
int nextChar;
while ((nextChar = m_stream.read()) != -1)
m_captureBuffer.append((char) nextChar);
} catch (IOException ioex) {
System.err.println(ioex);
}
}
}
}

package Cap2;

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.GregorianCalendar;

public class MyRun3  {

public void executeCommand ( ) {
// TODO Auto-generated method stub

   String nomearquivo;
   StringBuilder sb = new StringBuilder();

   // cria um GregorianCalendar que vai conter a hora atual
   GregorianCalendar d = new GregorianCalendar();
   
   // anexa do StringBuilder os dados da hora
   sb.append( d.get( GregorianCalendar.YEAR) );
   sb.append( "_" );
   sb.append( d.get( GregorianCalendar.MONTH ) );
   sb.append( "_" );
   sb.append( d.get( GregorianCalendar.DAY_OF_MONTH ) );
   sb.append( "_" );
 
   sb.append( d.get( GregorianCalendar.HOUR_OF_DAY ) );
   sb.append( "h" );
   sb.append( d.get( GregorianCalendar.MINUTE ) );
   sb.append( "m" );
   sb.append( d.get( GregorianCalendar.SECOND ) );
   sb.append( "s" );

   // retorna a String do StringBuilder
   nomearquivo="d:\\filters\\logNetstat_";
   nomearquivo+=sb.toString();
   nomearquivo+=".txt";
 
 

CommandLine cl = new CommandLine();

cl.execute( "cmd /c netstat -an" );

System.out.print( cl.getStdinData() );
System.out.print( cl.getStderrData() );

OutputStream os = null;
try {
os = new FileOutputStream(nomearquivo);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
    OutputStreamWriter osw = new OutputStreamWriter(os);
    BufferedWriter bw = new BufferedWriter(osw);

    try {
    bw.write(cl.getStdinData() );
    bw.write(cl.getStderrData() );
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 
    try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}




}

}


package Cap2;

public class Begginer {

public static void main(String[] args) {
// TODO Auto-generated method stub

MyRun3 myrun3 = new MyRun3();

while (true) {
myrun3.executeCommand();


for (int i = 0; i < 300 ; i++) {


try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}



}
}
}

}

Socket em Java

Abaixo duas classes em Java para conexão de socket entre servidor e cliente. As classes são resultado das aulas de Sistemas Operacionais do prof Alessandro Brawerman. Na época em que pesquisei a respeito não encontrei nada tão simples e tão didático. Quando falamos em socket geralemente é acompanhado de estruturas complexas, mas abaixo as classes são simples. Deve ser configurada apenas a porta e o ip das máquinas.

import java.io.*;

import java.net.*;

import javax.swing.GroupLayout.ParallelGroup;

public class servidor {

public static void main(String args[]) throws IOException {

int porta = 10000;

Socket sock = null;

int porta2 = 10000;

String IP = "172.23.96.200";

BufferedReader teclado;

ServerSocket ss = new ServerSocket(porta2);

sock = ss.accept();

DataInputStream in = new DataInputStream(sock.getInputStream());

DataOutputStream out = new DataOutputStream(sock.getOutputStream());

//primeira msg do servidor

while (true) {

teclado = new BufferedReader(new InputStreamReader(System.in));

String texto = teclado.readLine();

out.writeUTF(texto);

System.out.println(in.readUTF());

if(texto.equals("terminar")){

break;

}

}

in.close();

out.close();

sock.close();

}

}

import java.io.*;

import java.net.*;

import java.util.Scanner;

public class cliente {

/**

 * @param args

 * @throws IOException

 */

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

int porta = 12345;

String IP="172.23.96.73";

BufferedReader teclado;

Socket sock = new Socket(IP,porta);

DataInputStream in = new DataInputStream(sock.getInputStream());

DataOutputStream out = new DataOutputStream(sock.getOutputStream());

System.out.println(in.readUTF());

teclado = new BufferedReader(new InputStreamReader(System.in));

String texto = teclado.readLine();

out.writeUTF(texto);

if (texto.equals("terminar")) {

in.close();

out.close();

sock.close();

}

}

}

Busca Recursiva no Linux

Na busca por uma palavra chave de forma recursiva tive algumas dificuldades em encontrar um arquivo. Procurando por soluções de grep encontrei uma variação com comando find que funciona bem. O grep simples não retornou o resultado que eu esperava por uma questão de case sensitive que não utilizei na primeira busca.




Comandos:


find . -type f -exec grep -l "string" {} +


find . -type f -exec grep -l "p_deleterole" {} +


Com ignore case:

find . -type f -exec grep -li "ComBOBOx" {} +



Mais tarde testando apenas o grep:

grep -ri "word" .


Com opção para exibir o número da linha:

grep -ri "word" . -n