O objetivo do Luminolaser foi, principalmente, estudar o uso de Servo Motores e o controle sob eles. Sempre tentando criar algo um pouco além do simples exemplo, procurei fazer uma espécie de scanner de ambiente que identifica o ponto mais luminoso (eu só tinha um sensor de luminosidade – LDR – a disposição) e marca esse ponto com um laser pointer.

Posteriormente incrementei um pouco mais de modo que fosse possível controlar o laser através de um controle analógico.

Bem, vamos aos materiais usados:

• Arduino “Brasileirino” (Duemilanove) ATMega328 [Arduino Uno];
• Bateria recarregável de 9V [Deal Extreme];
• Bateria de 4V de alta descarga para alimentar o módulo laser;
• Bateria de 7,4V de alta descarga para os servos;
• 2 Mini Servos Motores [Deal Extreme];
• Módulo de laser vermelhor 5mW [Deal Extreme];
• Botão de lanterna para mudar a função do protótipo [Deal Extreme];
• Muitos fios conectores para protoboard [Deal Extreme];
• Analógico do PSP [Deal Extreme];
• LDR (sensor de luminosidade) [Wiki].
• Transistor NPN Tip122 [Wiki];

Como pode-se notar, existem muitos componentes from China. Realmente acredito que valha a pena, principalmente quando não existe pressa para receber os produtos.

À esquemática:

Observem que, por não ter uma imagem do controle analógico para o Fritzing, acabei substituindo por 2 potenciômetros rotatórios… Até porque são equivalentes. Assim como o Led vermelho da imagem simboliza o módulo do laser.

E para simplificar a visualização, incluí apenas 1 servo motor na esquemática e separei os componente. Na versão final o laser e o LDR ficam juntos na ponta do segundo servo.

O botão incluí para alterar o modo de controle dos servos entre automático (busca o ponto mais luminoso do ambiente) e manual (permitindo o direcionamento do laser através do controle analógico).

Now it’s time to code!

#include <Servo.h> 
 
Servo servo_base;
Servo servo_upper;
 
//Posição dos servos inferior e superior
int servo_base_pos = 0;
int servo_upper_pos = 0;
 
//Posição para onde os servos devem se mover
//para apontar onde está a mais forte fonte de luz
int final_base_pos = 0;
int final_upper_pos = 0;
 
//Pinos dos servos, sensor ldr e sinal do laser
int servo_base_pin = 5;
int servo_upper_pin = 3;
int ldr_pin = 5;
int laser_pin = 13;
 
//Pinos do analógico e do botão
int dpad_x = 0;
int dpad_y = 1;
int button_pin = 8;
 
void setup() 
{ 
  servo_base.attach(servo_base_pin);
  servo_upper.attach(servo_upper_pin);
  pinMode(laser_pin, OUTPUT);
  pinMode(button_pin, INPUT);
} 
 
void loop() 
{ 
  if(verificaClick()) {
    //Função de direcionamento manual do laser
    ligarLaser();
    readAnalogPad();
    direcionaLaser();
  } else {
    //Busca automática pela maior luminosidade
    desligaLaser();
    buscaMaiorLuminosidade_1();
    direcionaLaser();
    ligarLaser();
    delay(10000);
  }
}
 
//Percorre todo o alcance dos servos buscando a maior luminosidade
//detectada pelo LDR e salva essa posição para mover depois
void buscaMaiorLuminosidade_1() {
  int maior_luminosidade = 0;
 
  for(servo_base_pos = 0; servo_base_pos < 180; servo_base_pos += 20) 
  {
    servo_base.write(servo_base_pos);
    delay(500);
    for(servo_upper_pos = 0; servo_upper_pos < 180; servo_upper_pos += 5) 
    {
      servo_upper.write(servo_upper_pos);
      delay(100);
      if(verificaClick()) {
        //Se o botão foi clicado, encerra a busca
        return;
      }
 
      int ldr = obtemLuminosidade();
      if(ldr > maior_luminosidade) {
        maior_luminosidade = ldr;
        final_base_pos = servo_base_pos;
        final_upper_pos = servo_upper_pos;
      }
    }
 
    servo_upper.write(0);
  }
 
  servo_base.write(0);
}
 
int obtemLuminosidade() {
  return analogRead(ldr_pin);
}
 
void direcionaLaser() {
  servo_upper.write(final_upper_pos);
  servo_base.write(final_base_pos);
}
 
void ligarLaser() {
  digitalWrite(laser_pin, HIGH);
}
 
void desligaLaser() {
  digitalWrite(laser_pin, LOW);
}
 
boolean verificaClick() {
  return digitalRead(button_pin) == HIGH;
}
 
//Obtem a leitura do controle analógico.
//Devido à baixa qualidade do mesmo, não foi possível fazer 
//simplesmente um mapeamento do sinal de entrada para a posição final.
void readAnalogPad() {
  int analog_x = analogRead(dpad_x);
  int analog_y = analogRead(dpad_y);
 
  int y = 0;
  int x = 0;
 
  if(analog_y > 620) {
    y = analog_y > 680 ? 5 : 1;
  } else if(analog_y < 540) {
    y = analog_y < 480 ? -5  : -1;
  } else {
    y = 0;
  }
 
  if(analog_x > 330) {
    x = analog_x > 380 ? 5 : 1;
  } else if(analog_x < 280) {
    x = analog_x < 190 ? -5 : -1;
  } else {
    x = 0;
  }
 
  final_upper_pos = final_upper_pos + y;
  final_base_pos = final_base_pos - x;
 
  final_upper_pos = final_upper_pos > 180 ? 180 : final_upper_pos;
  final_upper_pos = final_upper_pos < 0 ? 0 : final_upper_pos;
 
  final_base_pos = final_base_pos > 180 ? 180 : final_base_pos;
  final_base_pos = final_base_pos < 0 ? 0 : final_base_pos;
 
  delay(100);
}

Existem algumas melhorias para serem feitas no código, mas uma funcionalidade adicional que quero implementar é a capacidade de seguir. Imagino que seja possível fazer isso através de micro ajustes (ou micro buscas em uma área menor). Assim, teoricamente, seria possível seguir a fonte de luz mesmo se houver deslocamento da mesma. Além disso, pretendo trocar o sensor de luminosidade por um sensor de infra vermelho e, se funcionar como eu espero, poder detectar e seguir fontes de calor, como o corpo humano.

Bem, por fim vamos ao resultado final atual:

Click here to view the video on YouTube.

Por hora é só… Quando eu tiver tempo de dar um upgrade nesse protótipo, edito esse post para incluir as alterações.

Nos últimos meses estive consideravelmente ocupado (e preguiçoso) para voltar a escrever, principalmente devido ao padrão de post gigantes que habitam esse blog. Por isso, dessa vez, tentarei fazer algo mais resumido e, conseqüentemente, voltado a quem já possui o mínimo de conhecimento sobre o assunto.

Vou me ater a apresentar o protótipo que fiz, a esquemática e código fonte sem entrar em maiores explicações de funcionamento.

Bem, o Colorino, como foi nomeado pelo meu caro amigo @jopss, é um experimento que fiz com o Arduino para aprender sobre e testar um led RGB que comprei do Deal Extreme usando resistores variáveis, transistores e uma programação bastante simples. O objetivo era controlar a intensidade de cada cor do led (vermelho, verde e azul) através dos resistores deslizantes. Através do uso de transistores, pude controlar a intensidade da corrente através do sinal digital do Arduino.

Primeiramente vamos ao componentes usados:

• 1 Arduino Duemilanove ATMega328 (“Brasileirino”) [Arduino Uno];
• 1 Led RGB 5W 70 Lumen [Deal Extreme];
• 3 Potenciômetros deslizantes 20 kΩ [Google Images] [Wiki US];
• 3 Transistores NPN Tip122 [Wiki];
• 1 Bateria 4V de alta descarga (pode ser uma bateria de 3,7V de celular)*;
• 1 Bateria 9V convencional para alimentar o Arduino (opcional) [Google Images];
• Muitos fios.

* No caso da bateria de alta descarga, usei uma de 4V (de lítio) de um fone de ouvido bluetooth que eu tinha. Uma bateria de celular pode ser usada se retirado o limitador de descarga (fusível). Considerando uma fonte de 5V, o Led de 5W consumiria 1A (ampér), o que é bastante. Na prática, cheguei ao máximo de 0,5A.

Agora vamos à esquemática dos componentes.

Espero ter feito um bom trabalho ao desenhar esse esquema com o Fritzing.

Hora do código fonte feito na IDE do Arduino.

//Define as portas analógicas de entrada dos potenciômetros
const int pot_r = 2;
const int pot_g = 1;
const int pot_b = 0;
 
//Define as portas PWM de saída analógica para os transistores
const int led_r = 3;
const int led_g = 5;
const int led_b = 6;
 
//Flag para ativar o debug pelo monitor da porta serial
const boolean debug = true;
 
void setup() {
  pinMode(led_r, OUTPUT);
  pinMode(led_g, OUTPUT);
  pinMode(led_b, OUTPUT);
 
  if(debug) { Serial.begin(9600); }
}
 
void loop() {
  //Obtem a leitura dos potenciômetros nas portas analógicas
  int pot_r_signal = analogRead(pot_r);
  int pot_g_signal = analogRead(pot_g);
  int pot_b_signal = analogRead(pot_b);
 
  //Converte os sinais dos potenciômetros para a escala de escrita das PWM
  //O led vermelho recebe menos energia por ser naturalmente mais forte
  int pot_r_digital = map(pot_r_signal, 0, 1023, 0, 150);
  int pot_g_digital = map(pot_g_signal, 0, 1023, 0, 255);
  int pot_b_digital = map(pot_b_signal, 0, 1023, 0, 255);
 
  //Escreve o sinal convertido para os transistores que deverão liberar
  //a quantia equivalente de corrente ao led
  analogWrite(led_r, pot_r_digital);
  analogWrite(led_g, pot_g_digital);
  analogWrite(led_b, pot_b_digital);
 
  if(debug) {
    Serial.print("RED: ");
    Serial.print(pot_r_signal);
    Serial.print(" => ");
    Serial.println(pot_r_digital);
 
    Serial.print("GREEN: ");
    Serial.print(pot_g_signal);
    Serial.print(" => ");
    Serial.println(pot_g_digital);
 
    Serial.print("BLUE: ");
    Serial.print(pot_b_signal);
    Serial.print(" => ");
    Serial.println(pot_b_digital);
 
    delay(1000);
  }
}

Finalmente o resultado.

Click here to view the video on YouTube.

Por hora é só. Espero voltar logo com outro pequeno projeto de Arduino voltado a estudo de componentes. Fui!

Com as novas regras vigentes no mercado e a necessidade de adaptação, tanto por parte das empresas quanto dos funcionários, informamos aos nossos colaboradores as novas regras aprovadas pelo RH de nossa empresa, e vigente a partir desta data:

AUSÊNCIA DEVIDO À ENFERMIDADE:
Não vamos mais aceitar uma carta do médico como prova de enfermidade.
Se o funcionário tem condições de ir até o consultório médico, pode vir trabalhar.

CIRURGIA:
As cirurgias são proibidas. Enquanto o funcionário trabalhar nesta empresa precisará de todos os seus órgãos, portanto, não deve pensar em remover nada. Nós o contratamos inteiro. Remover algo constitui quebra de contrato.

AUSÊNCIAS DEVIDO A MOTIVOS PESSOAIS:
Cada funcionário receberá 104 dias para assuntos pessoais a cada ano…
Chamam-se sábado e domingo.

AUSÊNCIA DEVIDO À SUA PRÓPRIA MORTE:
Isto será aceito como desculpa. Entretanto, exigimos pelo menos 15 dias de aviso prévio, visto que cabe ao funcionário treinar o seu substituto.

O USO DO WC:
Os funcionários estão passando tempo demais no toalete. No futuro, seguiremos o sistema de ordem alfabética. Por exemplo, todos os funcionários cujos nomes começam com a letra ‘A’  irão entre 8:00 e
8:20, aqueles com a letra ‘B’ entre 8:20 e 8:40, etc. Se não puder ir na hora designada, será preciso esperar a sua vez, no dia seguinte. Em caso de emergência, os funcionários poderão trocar o seu horário com um colega.
Os supervisores dos funcionários deverão aprovar essa troca, por escrito.
Adicionalmente: agora há um limite estritamente máximo de 3 minutos no banheiro.
Acabando esses 3 minutos, um alarme irá tocar, o rolo de papel higiênico será recolhido, a porta do banheiro abrirá e uma foto será tirada. Se for repetente, a foto será fixada no quadro de avisos da empresa sob o título: “Infrator Crônico”.

INDUMENTÁRIA:
Informamos que o funcionário deverá trabalhar vestido de acordo com o seu salário.
Se o percebermos calçando um tênis Nike de R$ 350,00 e carregando uma bolsa Gucci de R$ 600,00 presumiremos que vai bem de finanças e, portanto, não precisa de aumento.
Se ele se vestir de forma pobre, será um sinal de que precisa aprender a controlar melhor o seu dinheiro para que possa comprar roupas melhores e, portanto, não precisa de aumento.
E, se ele se vestir no meio termo, estará perfeito e, portanto, não precisa de aumento.

A HORA DO ALMOÇO:
Os magros têm 30 minutos para o almoço, porque precisam comer mais para parecerem saudáveis. As pessoas de tamanho normal têm 15 minutos para comer uma refeição balanceada que sustente o seu corpo mediano. Os gordos têm 5 minutos, porque é tudo que precisam para tomar um “Slim Fast” e um remédio de regime.

Muito obrigado pela sua fidelidade à nossa empresa. Estamos aqui para proporcionar uma experiência empregatícia positiva. Portanto, toda dúvida, comentário, preocupação, reclamação, frustração, irritação, agravo, insinuação, alegação, acusação, observação, consternação e “input” deverá ser dirigida para qualquer outro lugar.

Atenciosamente,

Setor de Recursos Humanos

Fonte: Vila Vilão Viola Violão

Diferentemente do post anterior, terei que me ater a um ambiente específico, mas informarei quais as aplicações envolvidas e suas versões quando for o caso. No geral, utilizei o CentOS 5.3 para a instalação e configuração do Munin e seus plugins.

Desde já, informo que, na maioria das vezes, ler a documentação de um determinado plugin com problemas me ajudou muito. Geralmente a documentação está junto ao código, no próprio plugin. Então basta abri-lo com algum editor de textos.

1. Conceitos Básicos:

Não é necessário saber desenvolver plugins para conseguir instalá-los corretamente, mas alguns conceitos ajudarão muito a entender a documentação e os requisitos.

Primeiramente, os plugins são desenvolvidos em Perl. Com isso em mente, muitas vezes a solução de algum problema é simplesmente a instalação do pacote apropriado, como o perl-DBD-Pg para conexões com o PostgreSQL. USE O ‘YUM SEARCH‘ (ou ‘apt-get‘ ou whatever)!

Em alguns casos, serão necessários “variáveis de ambiente” para a correta execução do plugin. Por exemplo, um plugin para banco de dados precisa do usuário e senha de acesso; um plugin para o Tomcat precisará da porta de acesso.

Essas variáveis deverão ser configuradas no arquivo ‘/etc/munin/plugin-conf.d/munin-node‘. Por padrão, algumas configurações e documentações já estão inclusas. E cada configuração relaciona-se ao plugin através do nome. Por exemplo:

[mysql*]
user root
group wheel
env.mysqladmin /usr/bin/mysqladmin
env.mysqlopts -u munin -pmunin1234

As configurações acima servirão para todos os plugins cujo nome comece com “mysql“. Esse plugin rodará como o usuário root e terá as permissões de super usuário. Além disso, fornecemos ao plugins alguns dados através de variáveis de ambiente (env.). No caso, o plugin usará o mysqladmin do local informado e usará o usuário ‘munin’ para obter as informações necessárias.

Na documentação dos plugins geralmente é informado quais variáveis de ambiente devem ou podem ser setadas.

Além de configurações, existem alguns comandos úteis no processo de configuração de plugins. Através do “munin-run” podemos executar o plugin na hora, obtendo um valor numérico, se bem configurado, ou ‘U‘ se ocorrer algum problema interno. Por exemplo:

# munin-run  tomcat_jvm
free.value 42133328
used.value 301537456
max.value 775487488

Adicione o argumento “autoconf” para receber uma resposta booleana:

# munin-run mysql_queries autoconf
yes

2. Plugin: MySQL

Tratarei aqui sobre as configurações dos plugins “mysql_queries” e “mysql_threads“. O primeiro apresenta a quantidade de requisições ao banco por tipo (selects, updates, deletes, etc); o segundo mostra a quantidade de threads criadas internamento no MySQL.

mysql_queries

mysql_threads

Essencialmente, precisamos apenas criar um usuário do MySQL sem permissão alguma e informar os dados de acesso ao plugin. Então criemos um usuário:

mysql -uroot -p -e 'CREATE USER munin IDENTIFIED BY "munin1234"'

Adicione as informações de acesso no arquivo ‘/etc/munin/plugin-conf.d/munin-node‘:

[mysql*]
user root
group wheel
env.mysqladmin /usr/bin/mysqladmin
env.mysqlopts -umunin -pmunin1234

Através desse usuário o plugin obterá os dados necessários para geração do gráfico. Utilize o comando “munin-run” para testar:

# munin-run mysql_queries
delete.value 35756
insert.value 231054
replace.value 20
select.value 10460090
update.value 5261807
cache_hits.value 52529748

# munin-run mysql_threads
threads.value 14

Simples, não? Muitas vezes a dificuldade não é configurar, mas sim descobrir o que configurar.

3. Plugin: PostgreSQL

Dessa vez falarei sobre um plugin para PostgreSQL, o “postgres_connections_db“. Ele gera um gráfico com os valores de conexões por banco de dados.

postgres_connections_db

Dessa vez, além de criar um novo usuário para o Munin, temos que liberar o acesso livre desse usuário a partir do servidor. Então, primeiramente, criamos o usuário com senha aleatória (segura):

psql -U postgres -c "CREATE ROLE munin NOSUPERUSER NOCREATEDB
NOCREATEROLE NOINHERIT LOGIN ENCRYPTED PASSWORD 'LjkJ9JUha2';"

Utilizamos uma senha segura porque não usaremos ela na configuração do plugin. Ao invés disso, liberaremos o acesso sem senha para o usuário “munin” a partir do servidor para uma determinada tabela. Então, abriremos para edição o arquivo “/var/lib/pgsql/data/pg_hba.conf” e adicionamos a linha:

local   template1   munin   trust

Com isso, todas as conexões para o usuário “munin” na tabela “template1″ a partir do servidor local serão aceitas sem a necessidade de senha. Basta dar um reload no postgre e podemos incluir as configurações do plugin no arquivo “/var/lib/pgsql/data/pg_hba.conf” :

[postgres*]
user munin
env.dbuser munin

Depois disso, basta testar:

# munin-run postgres_connections_db
postgres.value 0
template1.value 0
...

Bem. Acredito que seja o suficiente por hora… Espero voltar logo com a continuação apresentando outros Plugins para o Munin, incluindo um plugin não oficial para monitorar memória usada pelo Passenger (RoR).

Estou há alguns poucos meses trabalhando nessa área, mas aprendi muito. Perdi o medo que tinha do Linux e agora configuro e monitoro servidores utilizando ferramentas que, uma vez configuradas corretamente, tornam a vida muito mais simples.

Não irei me focar em ensinar a configurar cada uma visto que as configurações variam de OS para OS e  existem tutoriais no site oficial da respectiva ferramenta e no Google. Simplesmente darei um overview apresentando as principais características, prós, contras e outras observações pertinentes.

Dividirei os posts, apresentando uma aplicação de cada vez. E começarei com o Munin.

1. Munin (http://munin.projects.linpro.no/)

É uma aplicação bastante simples de monitoramento de recursos de servidores. Permite a visualização via navegador de diversos gráficos referentes à uso de memória, espaço em disco, uso de CPU, tráfego de saída e entrada de dados, e outros. Sendo que cada fonte de dados, por padrão, é compilada em quatro gráficos (diário, semanal, mensal e anual). A coleta de dados é realizada através de um agendamento no cron do sistema, criado na instalação do Munin.

a. Instalação e configuração

No próprio site existe um guia abrangendo a instalação do Munin em diversas distribuições do Linux e até mesmo para o MacOS (no donuts for you, Windows users). Após esse processo, basta configurar o grupo e nome do servidor (como mostrado aqui) e configurar o Apache para permitir acesso ao “home” da aplicação (por padrão /var/www/munin/ ) através de algum URL.

O Munin é baseado em plugins, sendo que cada conjunto de gráficos é um plugin que pode ser instalado ou desinstalado fácil e independentemente. Basta criar ou excluir um link simbólico (atalho) na pasta /etc/munin/plugins do plugin desejado localizado em /usr/share/munin/plugins.

Além disso, é possível facilmente configurar o Munin para emitir alertas em certas condições como, por exemplo, quando o uso de CPU for maior que 80%. Isso pode ser feito integrando com o Nagios ou enviando e-mail através de do serviço sendmail ou um script externo.

b. Prós

• Simples, direto e rápido;
• Fácil configuração e permite a edição de plugins ou criação de novos;
• Possui opção de alertas em determinadas condições.

c. Contras

• A configuração do envio de alertas é muito básica, não permitindo controlar a quantidade ou a periodicidade dos envios. Se utilizado o Nagios, é possível configurá-lo para isso;
• Depende da disponibilidade do sistema para realizar o monitoramento. Se o servidor travar do nada, o Munin ficará travado também;
• Documentação online bagunçada e muitas vezes insuficiente para orientar novos usuários.

d. Observações adicionais

Por padrão, o Munin não apresenta um sistema de segurança para o acesso às suas informações. Uma forma bastante simples de fazer essa segurança é configurando o Apache para utilizar um arquivo de autenticação:

    <Directory /var/www/html/munin>
        Order deny,allow
        Deny from all
        Allow from 127.0.0.1
 
        AuthType Basic
        AuthName "My Server Munin"
        AuthUserFile /var/www/html/.htpasswd
        require valid-user
 
        Satisfy Any
    </Directory>

Então é isso. ^^

Espero em breve voltar com outro post sobre outra aplicação para o gerenciamento de servidores ou dando continuidade à série “Java para Web” =P

Neste post iremos ver como o Maven pode ajudar tanto na inclusão de dependências como em outras tarefas antes realizadas manualmente. Como o foco não será o projeto em si, utilizaremos o projeto do Teclado Virtual do post anterior.

Ao final do post existirão links para um pacote compactado com o projeto do tutorial e um exemplo (parcial) online do mesmo.

Ah… Quando criei esse blog alguns amigos de trabalho me disseram que logo logo eu pederia o ânimo pra postar… Pois é… >.<

1. Ambiente e Criação do Projeto

Primeiramente, utilizarei o NetBeans 6.5 com o plugin do Maven (basta buscar por “Maven” no filtro de plugin). E o Tomcat 6 (inclua-o no NetBeans). O código do teclado virtual será o mesmo do post anterior, com algumas pequenas alterações. Então vamos lá!

Tendo o plugin do Maven instalado, crie um novo projeto para o novo teclado virtual (Novo Projeto -> Maven -> Maven Project). Escolha o “Maven Quickstart Archetype” mesmo. Nomeei o meu projeto de “teclado-mvn” e coloquei o “Group Id” e o “Package” como “br.com.teclado.virtual.mvn”. Finalize.

Será criado um projeto java já nos moldes do Maven. Observe na pasta “Project Files” o arquivo “pom.xml”. Ele é o centro das configurações do Maven no seu projeto. Dentro da tag “dependency” haverá algumas entradas referentes ao “junit”. Isso quer dizer que o seu novo projeto é dependente do JUnit e tentará baixar o .jar referente do repositório padrão do Maven quando você for realizar algum teste (neste caso é em testes devido ao “scope” da dependência).

Agora vamos efetivamente “recriar” o teclado virtual. Apague as classes criadas automaticamente nos pacotes do projeto e copie a classe “TecladoVirtual.java” do projeto do post anterior para o pacote principal do novo projeto. Diversos erros deverão ser visíveis e, se você leu o post anterior, deverá saber o porquê.

No projeto original do teclado virtual, tínhamos que manualmente copiar o plugin.jar da pasta do JRE instalado para podermos utilizar a classe JSObject. Agora utilizaremos o Maven para fazer isso de uma maneira mais “elegante”.

2. Instalação e Utilização de Nova Dependência

Abra o “pom.xml” e vamos customizar a construção (build) do projeto. Em suma, o que faremos, é instalar o “plugin.jar” no repositório local e adicionar essa dependência ao teclado.

Para deixar mais claro, o que o Maven faz é, artravés do arquivo de configurações dele (pom.xml), identificar as dependências do projeto e baixar os seus jars do repositório remoto para uma pasta local na própria máquina (é chamado de “Repositório Local”). Então temos que incluir o “plugin.jar” no repositório local para podermos utilizá-lo.

No “pom.xml” adicione o seguinte treço dentro da tag <project>.

<build>
   <plugins>
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-install-plugin</artifactId>
         <version>2.3</version>
         <executions>
            <execution>
               <phase>generate-sources</phase>
               <id>generate-sources</id>
               <inherited>false</inherited>
               <configuration>
                  <groupId>java.plugin</groupId>
                  <artifactId>plugin</artifactId>
                  <version>1.6.0</version>
                  <packaging>jar</packaging>
                  <file>${env.JAVA_HOME}/jre/lib/plugin.jar</file>
               </configuration>
               <goals>
                  <goal>install-file</goal>
               </goals>
            </execution>
         </executions>
      </plugin>
      <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.0.2</version>
         <configuration>
            <source>1.5</source>
            <target>1.5</target>
         </configuration>
      </plugin>
      <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.0.2</version>
         <configuration>
            <encoding>ISO-8859-1</encoding>
         </configuration>
      </plugin>
      <plugin>
         <artifactId>maven-resources-plugin</artifactId>
         <version>2.2</version>
         <configuration>
            <encoding>ISO-8859-1</encoding>
         </configuration>
      </plugin>
   </plugins>
</build>

Observando apenas a primeira tag <plugin>, temos que durante a fase (<phase>) do clico de vida de construção do projeto “generate-sources” (antes da compilação), irá executar a tarefa (<goal>) “install-file” da entidade (<artifactId>) “maven-install-plugin”. O arquivo a ser instalado (<file>) será o “plugin.jar” da JRE instalada e referenciada pela variável de ambiente “JAVA_HOME”. Após instalado, o jar poderá ser encontrado no repositório local pelo grupo “java.plugin”, artefato “plugin” e versão “1.6.0″.

Os plugins restantes na tag “build” são necessário para a execução completa do ciclo de vida da compilação feita pelo Maven.

Agora dê um “Limpar e Construir” (Clean and Build) no projeto e verifique se os erros no TecladoVirtual.java permanecem. Se sim, então está correto! =P

O que nós fizemos foi incluir o “plugin.jar” no repositório local, mas ainda não o incluimos no projeto. Antes disso, vamos conhecer o repositório local. Abra no Windows a sua pasta do “Documents and Settings” (C:\Documents and Settings\Usuario) e verá uma pasta “.m2″. Nela está o seu repositório local do Maven. Todas as dependências de projeto são baixadas para esta pasta de modo que não seja necessário baixar tudo novamente caso um novo projeto seja criado. Se você tentou construir o nosso novo projeto do teclado virtual, então já deve exisitir a pasta “.m2\repository\java\plugin\plugin\1.6.0″ com o “plugin-1.6.0.jar”. Agora, adicione esta dependência ao projeto.

No “pom.xml”, dentro da tag <dependencies>:

    <dependency>
       <groupId>java.plugin</groupId>
       <artifactId>plugin</artifactId>
       <version>1.6.0</version>
    </dependency>

Salve, limpe, compile e veja os erros do TecladoVirtual.java sumirem. Caso algum erro tenha ocorrido até este ponto, verifique se a variável de ambiente “JAVA_HOME” está devidamente setada e o caminho no “pom.xml” até o “plugin.jar” está correto.

Uma pequena alteração deve ser feita em relação ao projeto anterior do teclado virtual. Através do Windows, crie a pasta “resources” (“teclado-mvn\src\main\resources”) no novo projeto e copie as imagens do teclado para esta pasta. No NetBeans deverá aparecer a pasta “Other Sources”. E no “TecladoVirtual.java” altere o caminho à imagem de “/resources/teclado1.JPG” para “/teclado1.JPG”.

Veja a imagem de como ficou:

(abrir em nova janela)

3. Codificação da Senha do Teclado

O que faremos agora é uma alteração no código do teclado virtual para que a senha copiada ao campo oculto do formulário HTML seja previamente codificada com MD5 impossibilitando a obtenção da senha original mesmo que o valor do campo oculto seja lido.

Mas antes precisamos incluir uma dependência ao projeto; é o “commons-codec”. Se você está utilizando o NetBeans e ainda não descobriu a grande vantagem da IDE sobre a edição de XMLs, tente usar agora o auto-completar (CTRL+espaço) para encontrar o <groupId> e o <artifactId> desta nova dependência. Assim que o projeto foi criado, o plugin do Maven deve ter baixado (ou tentado baixar) um índice de dependências do repositório remoto contendo os grupos e artefatos disponíveis. A única demora deverá ser para encontrar as versões (<version>) disponíveis, pois ele precisará procurar em tempo real no repositório remoto.

Então adicione dentro da tag <dependencies>:

    <dependency>
       <groupId>commons-codec</groupId>
       <artifactId>commons-codec</artifactId>
       <version>1.3</version>
    </dependency>

Com isso, podemoremos usar o pacote “java.security.MessageDigest” para codificar a senha. Sem maiores explicações (para não fugir do foco e para não me estender demais), o métodos para codigicação de Strings em MD5 deverá ficar assim:

   /**
    * Encripta um texto em MD5
    *
    * @param texto
    * @return String
    */
    private String md5Encrypt(String texto)
    {
       String encripted = null;
       try{
          MessageDigest md = MessageDigest.getInstance( "MD5" );
          md.update( texto.getBytes() );
          BigInteger hash = new BigInteger( 1, md.digest() );
          encripted = hash.toString( 16 );
       }
       catch(NoSuchAlgorithmException ns)  {
          ns.printStackTrace();
       }
       return encripted;
    }

Agora basta utilizar este método codificar a senha no momento de enviar ao HTML:

    win.eval("recebeSenha('" + md5Encrypt(senha) + "'," + senha.length() + ")");

4. Criação do Projeto Web para Utilização do Teclado Virtual

Vamos criar outro projeto Maven seguindo os mesmos passos do projeto anterior, mas escolheremos “Maven Webapp Archetype” depois de Arquivo -> Novo Projeto -> Maven -> Maven Project. Os nomes que utilizei foram “teste-teclado-mvn” no nome e “br.com.teclado.virtual.mvn” como nome de grupo e empacotamento.

Alguém notou alguma semelhança dos dados que incluímos na criação de um projeto Maven com os dados utilizados para a adição de uma dependência? Pois é, quando compilamos um projeto, uma das fases executada é a instalação desse projeto no repositório local, sob o Grupo e Artefato utilizados na criação do mesmo. Assim, outros projetos podem ser dependentes do projeto instalado. Mas não é exatamente este o caso da relação Teclado Virtual – Projeto Web.

O projeto web não é exatamente dependente do Teclado Virtual para realizar alguma tarefa ou utilizar algum método. O jar do teclado deve apenas estar presente para que o navegador do usuário possa baixar e executá-lo. Então, ao invés de simplesmente adicioná-lo como um dependência, iremos copiar o jar que se encontra no repositório local para uma pasta do projeto web, tornando-o diponível ao usuário.

Sem mais enrolação, insira o trecho a seguir dentro da tag <project> do “pom.xml” do projeto web.

 <build>
    <finalName>teste-teclado-mvn</finalName>
    <plugins>
       <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-dependency-plugin</artifactId>
          <version>2.1</version>
          <executions>
             <execution>
                <phase>compile</phase>
                <id>copy-teclado</id>
                <inherited>false</inherited>
                <configuration>
                   <artifactItems>
                      <artifactItem>
                         <groupId>br.com.teclado.virtual.mvn</groupId>
                         <artifactId>teclado-mvn</artifactId>
                         <version>1.0-SNAPSHOT</version>
                         <destFileName>teclado-mvn.jar</destFileName>
                      </artifactItem>
                      <artifactItem>
                         <groupId>commons-codec</groupId>
                         <artifactId>commons-codec</artifactId>
                         <version>1.3</version>
                         <destFileName>commons-codec.jar</destFileName>
                      </artifactItem>
                   </artifactItems>
                   <overWriteIfNewer>true</overWriteIfNewer>
                   <overWriteSnapshots>true</overWriteSnapshots>
                   <overWriteReleases>true</overWriteReleases>
                   <outputDirectory>/src/main/webapp/applet</outputDirectory>
                </configuration>
                <goals>
                   <goal>copy</goal>
                </goals>
             </execution>
          </executions>
      </plugin>
   </plugins>
</build>

Em suma, durante a fase (<phase>) de compilação o Maven irá copiar (<goal>) as dependências (<artifactItems>) referentes ao projeto do Teclado Virtual e ao pacote do “commons-codec”, renomeando-os para “teclado-mvn.jar” e “commons-codec.jar”, para a pasta (<outputDirectory>) “/src/main/webapp/applet”. Esta pasta estará no mesmo nível do “index.jsp” do projeto.

O “commons-codec” teve que ser copiado também pois onde o jar do teclado executará (no navegador do usuário) nem sempre existe esta biblioteca. Se quiser testar sem a instrução para copiar este pacote, não tem problema, a princípio.

Por último, podemos alterar o “index.jsp” para utilizar o Teclado Virtual. Vamos simplesmente copiar o código do HTML de teste do post sobre o Teclado Virtual, lembrando de alterar os valores da variáveis “clazz” e “jar” para “br.com.teclado.virtual.mvn.TecladoVirtual.class” (ou como você nomeou sua classe/pacote) e “applet/teclado-mvn.jar”, respectivamente.

Se deu tudo certo, ao executar o projeto web, deverá aparecer o teclado virtual e, ao submeter a página, no endereço da mesma deverão estar o nome do usuário e a senha codificada.

Então é isso! Finalmente consegui publicar um post depois de tanto tempo! \o/

Para encontrar outras operações disponíveis pelo Maven, tente o Oráculo ou tente explorar os artefatos do Grupo “org.apache.maven.plugins” (incluso em ambas operações descritas anteriormente).

cya.

Projeto do Teclado Virtual com Maven compactado e configurado no NetBeans: teclado-mvn

Exemplo Online do teclado com a codificação da senha: teclado-mvn-online

Vai ter palestras com gente que manja do assunto como Luli Radfahrer, Interney e Marcelo Tas.

Você pode Conferir uma das palestras do Luli aqui no blog do focezar mesmo, enjoy!

O Evento:

Workshop de Mídias Sociais

A programação do Evento está aqui!

E as inscrições para as palestras gratuitas podem ser feitas por aqui! (Tem que fazer inscrição para cada uma das palestras desejadas)

A palestra do Marcelo Tas custa 30 reais, 15 reais para estudantes, e os ingressos podem ser adquiridos direto no Sebrae.

Além das palestras, vão ocorrer oficinas de diversos temas.

É isso, até lá!

PS: Post kibado do focezar ^^

O teclado virtual representa uma forma de inserir a senha para uma autenticação de usuário sem correr o risco de ter a senha capturada pelos comuns keyloggers. Entretanto, realmente existem complicações na utilização de um teclado virtual e tem gente que realmente abomina esse tipo de recurso. Mas como todo bom programador, muitas vezes a decisão de usar ou não um teclado virtual não é sua.

Então vamos ao que interessa! Implementaremos uma applet de um teclado virtual para ser adicionada em um HTML qualquer com um campo para senha. Ao final do post, existem os links para download do projeto e para visualização online do teclado.

Vou utilizar o NetBeans 6.5 e JDK6 apenas. Neste caso, o cliente que deverá visualizar o teclado deverá ter o JRE6 instalado, já que a applet é client side. Mas o JDK5 também pode ser usado. Sobre o 1.4 eu não tenho muita certeza. =P

Crie um novo projeto java (no Netbeans é Arquivo -> Novo Projeto -> Java -> Aplicativo Java). Nomeie como preferir (no meu caso ficou “teclado” mesmo) e crie uma nova classe java na pasta de códigos-fontes para o teclado virtual (a minha classe ficou br.com.teclado.virtual.TecladoVirtual).

Visualizando o Teclado Virtual

Acredito que o primeiro passo seja a construção visual do teclado. E para isto deverá ser criada a imagem base do dele. Então abra o seu PainBrush e mãos à obra! ^^

Ah. Tenha em mente que a disposição e dimensão das teclas é muito importante, pois você deverá ser capaz de dizer qual a tecla pressionada através das coordenadas de um clique. O ideal é fazer um teclado com as teclas de mesmo tamanho e dispostas em um grid, onde uma tecla está sempre exatamente alinhada verticalmente e horizontalmente com outras. Mas isso fica a cargo de cada um. Vejam o teclado que fiz para este tutorial:

Cada tecla possui tamanho 30×30 pixels, exceto o backspace e o enter que possuem 30×60. Assim, considerando o canto superior esquerdo a origem do sistema de coordenadas (0,0), podemos obter a tecla pressionada dividindo por 30 o valor da posição x e  y. Se y < 1 a tecla pressionada é backspace. Se y > 5, é enter. Caso contrário, faça x+(y*5)-1 para descobrir qual tecla foi pressionada. (Se quiser, pode conferir as contas… =P)

Depois adicione esta imagem em seu projeto. Eu criei uma pasta “resources” no pacote de códigos fontes mesmo.

Bem, chega de brincar de designer e voltemos ao java! Vou listar as operações que devem ser feitas e depois mostrar o código resultante:

1. Na nossa classe do teclado virtual, vamos extender a classe Applet (java.applet.Applet) e implementar a interface MouseListener (java.awt.event.MouseListener). Inclua a implementação dos métodos da interface MouseListener mas sem conteúdo algum, por enquanto (se quiser, altere o cursor do mouse, como fiz a seguir);
2. Vamos criar dois atributos privados na classe do teclado virtual; um vetor de caracteres (char[]) que possuirá os valores das teclas numéricas, e uma imagem (java.awt.Image) que carregará a imagem que fizemos anteriormente;
3. Vamos sobre-escrever o método init() da classe Applet, e nele vamos inicializar o vetor com os valores das teclas, setar o tamanho da applet, inicializar a imagem do teclado com o arquivo de imagem que incluimos no projeto, e adicionar um MouseListener à classe;
4. Por fim, sobre-escreva o método paint(Graphics g) fazendo com que a imagem do teclado seja pintada na tela.

A classe fica mais ou menos assim:

public class teste extends Applet implements MouseListener {
 
    /**
     * Vetor com os valores das teclas
     */
    private char[] teclas;
 
    /**
     * Imagem do teclado
     */
    private Image teclado;
 
    @Override
    public void init() {
        iniciaTeclado();
        setLocation(0, 0);
        setSize(211, 61);
        teclado = getImage(this.getClass().getResource("/resources/teclado1.JPG"));
        addMouseListener(this);
        setLayout(null);
    }
 
    /**
     * Inicializa os atributos do teclado
     */
    private void iniciaTeclado() {
        teclas = new char[10];
        int i = 0;
        teclas[i++] = '0';
        teclas[i++] = '1';
        teclas[i++] = '2';
        teclas[i++] = '3';
        teclas[i++] = '4';
        teclas[i++] = '5';
        teclas[i++] = '6';
        teclas[i++] = '7';
        teclas[i++] = '8';
        teclas[i++] = '9';
    }
 
    @Override
    public void paint(Graphics g) {
        g.drawImage(teclado, 0, 0, this);
    }
 
    public void mouseClicked(MouseEvent e) {
    }
 
    public void mousePressed(MouseEvent e) {
    }
 
    public void mouseReleased(MouseEvent e) {
    }
 
    public void mouseEntered(MouseEvent e) {
        this.setCursor(new Cursor(Cursor.HAND_CURSOR));
    }
 
    public void mouseExited(MouseEvent e) {
        this.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
    }
 
}

Lembrando que o tamanho do applet deverá ser o mesmo da imagem adicionada.

Feito isto, tente rodar o arquivo. Deverá aparecer uma pequena tela com o teclado que desenhamos.

Capturando a Senha

Com o teclado aparecendo, podemos implementar a construção da senha a partir da detecção do clique nas teclas.

Basicamente, no método MousePressed(), faremos a verificação das coordenadas do clique assim como foi mostrado anteriormente. Por agora, cada tecla obtida afetará uma String “senha” e será impressa no console do java.

    @Override
    public void init() {
        iniciaTeclado();
        setLocation(0, 0);
        setSize(211, 61);
        teclado = getImage(this.getClass().getResource("/resources/teclado1.JPG"));
        addMouseListener(this);
        setLayout(null);
        senha = "";
    }
 
    public void mousePressed(MouseEvent e) {
        int x = e.getX() / 30;
        int y = e.getY() / 30;
        if(x < 1) {
            System.out.println("BACKSPACE");
            if(!senha.isEmpty()) {
                senha = senha.substring(0, senha.length()-1);
            }
        } else if(x > 5) {
            System.out.println("ENTER");
        } else {
            System.out.println(teclas[x+(y*5)-1]);
            senha += String.valueOf(teclas[x+(y*5)-1]);
        }
    }

Bem simples… Agora execute o arquivo e verifique se para cada tecla clicada o valor impresso está correto.

Comunicação com o HTML

Agora vem a parte mais chatinha. Não é por ser complicada, mas se há de ocorrer algum problema no teclado virtual, provavelmente será a seguir.

Para que o teclado virtual  seja realmente funcional, este deve, de alguma forma, se comunicar com o HTML no qual o applet está incluso. A maneira mais direta e sem muita complicação, é realizar a comunicação através de javascript. E para isso, utilizaremos uma biblioteca que você deverá incluir em seu projeto. É a netscape.javascript que pode ser encontrada no plugin.jar dentro da pasta do JDK que você está usando (%JAVA_HOME%/jre/lib/plugin.jar). Basta clicar com o direito sobre a pasta “bibliotecas” de seu projeto e então escolher “Adicionar JAR/Pasta”.

Tendo adicionado esta biblioteca, é hora de criarmos um HTML para os testes. No pacote de testes mesmo eu criei um “testeTecladoVistual.html”.

Basicamente, a comunicação entre a applet e o HTML será feito por chamadas javascript. Dessa forma, se quisermos passar a senha para um campo do HTML, usaremos uma chamada em javascript para isso. Para facilitar, criarei um método para essa operação, de modo que basta a applet chamar esse método para passar a senha.

<html>
<head>
<script type="text/javascript">
var clazz = "br.com.teclado.virtual.TecladoVirtual.class";
var jar =  "../dist/teclado.jar";
var width = "282";
var height = "97";
function escreveTecladoGeral() {
    var applet = "";
    applet += "<object classid=\"clsid:8AD9C840-044E-11D1-B3E9-00805F499D93\" width=\"" + width + "\" height=\"" + height + "\">";
    applet += "<param name=\"archive\" value=\"" + jar + "\">";
    applet += "<param name=\"codebase\" value=\".\">";
    applet += "<param name=\"code\" value=\"" + clazz + "\">";
    applet += "<param name=\"cache_option\" value=\"no\">";
    applet += "<!--[if gte IE 7]> <!-->";
    applet += "<object type=\"application/x-java-applet\" classid=\"java:" + clazz + "\"";
    applet += "archive=\"" + jar + "\" codebase=\".\" width=\"" + width + "\" height=\"" + height + "\">";
    applet += "<!-- Konqueror browser needs the following param -->";
    applet += "<param name=\"archive\" value=\"" + jar + "\">";
    applet += "<param name=\"code\" value=\"" + clazz + "\">";
    applet += "<!-- Safari browser needs the following param -->";
    applet += "<param name=\"JAVA_CODEBASE\" value=\".\">";
    applet += "<param name=\"cache_option\" value=\"no\">";
    applet += "Você necessita de um navegador que suporte Java<br/>Baixe o plugin java <a href='http://www.java.com/pt_BR/download/' target='_blank'>aqui</a>.";
    applet += "</object>";
    applet += "<!--<![endif]-->";
    applet += "<!--[if lt IE 7]>";
    applet += "Você necessita de um navegador que suporte Java<br/>Baixe o plugin java <a href='http://www.java.com/pt_BR/download/' target='_blank'>aqui</a>.";
    applet += "<![endif]-->";
    applet += "</object>";
    return applet;
}
function escreveApplet() {
	if(navigator.appName.indexOf('Internet Explorer') > 0) {
		document.write(escreveTecladoGeral());
	} else {
		document.write(escreveTecladoGeral());
	}
}
function recebeSenha(senha,tamanho) {
    document.getElementById('pass').value = senha;
    var str = '';
    for(i=0;i<tamanho;i++){str += '*';}
    document.getElementById('fakePass').value = str;
}
</script>
</head>
<body>
<script type="text/javascript">escreveApplet();</script>
<form>
    Login: <input type="text" name="login"><br/>
    Senha: <input type="text" readonly id="fakePass"><br/>
    <input name="pass" type="hidden" id="pass">
</form>
</body>
</html>

Primeiramente observem a escrita do applet no HTML através de javascript. Realizei muitos testes em diversos navegadores e cheguei no método acima (escreveTecladoGeral()) que, até onde testei, funciona perfeitamente. Existem alternativas utilizando as tags applet ou embed, caso tenha interesse em utilizá-las.

E temos o método recebeSenha(senha, tamanho) que será utilizado pela applet. Esta função javascript simplesmente repassa a senha para um campo oculto (hidden) e preenche o campo senha a mostra com ‘*‘ conforme a quantidade repassada. Não utilizei a quantidade de caracteres da senha para o preenchimento dos ‘*’ porque o correto seria que a senha seja encriptada.

Agora voltemos ao java e façamos a comunicação efetiva com o HTML.

Temos que criar um novo atributo da classe TecladoVirtual; um netscape.javascript.JSObject que servirá para executar as chamadas em javascript a partir do applet. Fazendo uso da função em javascript recebeSenha, os métodos init() e mousePressed(MouseEvent e) deverão ficar assim:

    @Override
    public void init() {
        iniciaTeclado();
        setLocation(0, 0);
        setSize(211, 61);
        teclado = getImage(this.getClass().getResource("/resources/teclado1.JPG"));
        addMouseListener(this);
        setLayout(null);
        try {
            win = JSObject.getWindow(this);
        } catch(JSException jse) {
            win = null;
            jse.printStackTrace();
        }
        senha = "";
    }
 
    public void mousePressed(MouseEvent e) {
        int x = e.getX() / 30;
        int y = e.getY() / 30;
        if(x < 1) {
            System.out.println("BACKSPACE");
            if(!senha.isEmpty()) {
                senha = senha.substring(0, senha.length()-1);
            }
            if(win != null) {
                win.eval("recebeSenha('" + senha + "'," + senha.length() + ")");
            }
        } else if(x > 5) {
            System.out.println("ENTER");
            if(win != null) {
                win.eval("document.forms[0].submit()");
            }
        } else {
            System.out.println(teclas[x+(y*5)-1]);
            senha += String.valueOf(teclas[x+(y*5)-1]);
            if(win != null) {
                win.eval("recebeSenha('" + senha + "'," + senha.length() + ")");
            }
        }
    }

Observe que no caso da tecla enter, o applet repassa ao navegador uma instrução para submeter o fomulário do HTML que fizemos. Como no form não está definido nenhum action ou method, o formulário submeterá para si próprio por GET e poderemos ver os dados (login e senha) como parâmetros na barra de endereço do navegador.

Se tudo der certo, podemos testar. Como o JSObject opera sobre o navegador, não adianta mais tentarmos executar o arquivo do teclado virtual. Até por isso incluí os testes if(win != null) ao fazer as chamadas javascript. Então temos que testar rodando o HTML que fizemos.

Mande compilar (build) o projeto para criar o JAR na pasta “dist” ou “target”. Feito isso, abra o testeTecladoVirtual.html para avaliar o funcionamento do applet. Caso não tenha aparecido, primeiramente verifique se o caminho para o jar e a classe do teclado (ambos no javascript do HTML) estão corretos. Se mesmo assim não funcionar, verifique o console java (qualquer exceção aparecerá lá, e não na IDE de desenvolvimento).

O java console deverá ser acessível através do ícone que aparecerá na barra de sistema do Windows (próximo ao relógio). Se não aparecer, talvez seja necessário habilitá-lo (Painel de Controle -> Java -> Advanced -> Java Console -> Show Console).

Considerações Finais

Apesar de evitar a captura da senha por um keylogger, o teclado virtual não garante 100% da segurança. Por exemplo, ainda é possível obter a senha através de uma variação de keylogger que, ao invés de capturar o valor das teclas pressionadas, fotografa cada clique do mouse. Ou então ainda é possível “escutar” as requisições de modo que o re-envio de uma requisição de login pode conceder uma autorização indevida ao sistema.

Por isso, o teclado virtual, num caso ideal, não deve ser o único meio de segurança. A utilização de uma autenticação SSL ou de um teclado virtual com um sistema de alternância das teclas (vide bb.com.br, necessário ter conta (O Banco do Brasil retirou o teclado virtual da tela de login)) é altamente recomendado.

Na verdade, acredito que um teclado virtual sirva mais para passar a sensação de segurança do que para realmente assegurar.

Bem, este tutorial abrangeu uma abordagem à implementação de um teclado virtual. Mas existem outras alternativas (inclusive em outras linguagens). É possível, ainda utilizando java, incluir no próprio applet os campos de login e senha e enviá-los como parâmetros de um request à página de login.

    AppletContext ac = this.getAppletContext();
    try {
        ac.showDocument(new URL("http://localhost:8080/login.jsp?user=" + user + "&pass=" + pass), "_self");
    } catch (MalformedURLException ex) {
        Logger.getLogger(TecladoVirtual.class.getName()).log(Level.SEVERE, null, ex);
    }

Realizando a autenticação desse modo, requer que o processo de login altere o response para que a requisição não retorne para o cliente e os parâmetros fiquem visíveis (o Spring Security é um exemplo). Não é um bom jeito de fazer as coisas, mas é uma alternativa.

E caso o teclado não seja visível em algum navegador em alguma máquina de alguma pessoa (não todos), antes de pensar em mexer no teclado, verifique as versões do JRE e do navegador no cliente. Atualizar o JRE consertou as coisas algumas vezes para mim.

Estão é isso! ^^

No mais, nada mais.

Projeto Teclado-Virtual compactado e configurado para NetBeans: teclado-virtual compactado

Exemplo online do resultado final do tutorial: teclado-virtual online

Nesta parte, criaremos uma busca de models pelo id e implementaremos uma idéia bastante legal e “preguiçosa” usada em JPA ou Hibernate.

Vejam também a parte 1 e a parte 2 do tutorial, caso ainda não o tenham feito.No final da parte anterior concluimos a persistência de um novo model com retorno do id gerado e implementamos a atualização de um model já persistido. Entretanto, não pudemos testar propriamente sem uma busca de model pelo seu id. Podemos começar por este ponto.

Find by Private Key

Caso você tenha lido as partes anteriores, provavelmente deve estar imaginando (ou já ter implementado =P) como poderia ser este método. Se pensou em construir um SQL para a busca como “SELECT * FROM Pessoa WHERE id = 1“, pensou certo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

    /**
     * Retorna um BasicModel persistido através do seu id
     *
     * @param id
     * @return {@link BasicModel}
     */
    public BasicModel findByPk(Class clazz, Integer id) throws Exception {
        String select = "SELECT id, ";
        String from = " FROM " + clazz.getSimpleName();
        String where = " WHERE id = " + id.toString();
        boolean primeiro = true;
        for (Field field : clazz.getDeclaredFields()) {
 
            //Se o campo for uma coleção de objetos ou um basic model
            if (Collection.class.isAssignableFrom(field.getType()) ||
                    BasicModel.class.isAssignableFrom(field.getType())) {
                //DO NOTHING
                continue;
            }
            else {
                if (primeiro) {
                    primeiro = false;
                } else {
                    select += ", ";
                }
            }
            select += field.getName();
        }
 
        ResultSet keys = null;
 
        try {
            Connection conn = getConnection();
            PreparedStatement pstmt = conn.prepareStatement(select + from + where);
            pstmt.execute();
 
            keys = pstmt.getResultSet();
            if (keys.next()) {
                return ResultSet2BasicModel(keys, clazz);
            }
 
        } catch (Exception ex) {
            System.err.println("Erro na operação de busca por id. A operação foi abortada.");
            throw ex;
        }
 
        return null;
    }

Após construirmos o SQL e realizarmos a consulta, convertemos o ResultSet obtido para um BasicModel da seguinte forma:

    /**
     * Monta uma nova instância de um model a partir das informações contidas no resultSet passado
     *
     * @param keys
     * @param clazz
     * @return {@link BasicModel}
     */
    private BasicModel ResultSet2BasicModel(ResultSet keys, Class clazz) throws Exception {
        if(keys != null) {
            BasicModel model = (BasicModel)clazz.newInstance();
 
            for (Field field : clazz.getDeclaredFields()) {
                //Se o campo for uma coleção de objetos ou um basic model
                if (Collection.class.isAssignableFrom(field.getType()) ||
                        BasicModel.class.isAssignableFrom(field.getType())) {
                    //DO NOTHING
                    continue;
                }
                //Se o campo for uma string
                else if(String.class.isAssignableFrom(field.getType())) {
                    Method method = model.getClass().getDeclaredMethod(getFieldSetterName(field.getName()), new Class[]{String.class});
                    method.invoke(model,keys.getString(field.getName()));
                }
                //Se o campo for um date
                else if(Date.class.isAssignableFrom(field.getType())) {
                    Method method = model.getClass().getDeclaredMethod(getFieldSetterName(field.getName()), new Class[]{Date.class});
                    method.invoke(model,keys.getDate(field.getName()));
                }
                //Se é outra coisa
                else {
                    Method method = model.getClass().getDeclaredMethod(getFieldSetterName(field.getName()), new Class[]{Object.class});
                    method.invoke(model,keys.getObject(field.getName()));
                }
            }
            model.setId(keys.getInt("id"));
            return model;
        }
        return null;
    }
 
    /**
     * Gera o nome do setter para o dado atributo
     * @param fieldName
     * @return String
     */
    private String getFieldSetterName(String fieldName) {
        return "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
    }

Então temos o model buscado pelo seu id. =)

Podemos atualizar o teste e criar um novo teste apenas para esta operação. E falando em testes, eu alterei um pouquinho a classe BasicDaoTest para ficar melhor apresentada. Antes de cada teste o banco é limpo, melhorando o isolamento dos testes.

public class BasicDaoTest extends TestCase {
 
    /**
     * {@link BasicDao}
     */
    private BasicDao basicDao;
 
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        basicDao = new BasicDao();
        basicDao.limparTabela("Pessoa");
    }
 
    public void testBasic() throws Exception {
        basicDao.testConnection();
        assertTrue(true);
    }
 
    public void testPersistNew() throws Exception {
        Pessoa pessoa = new Pessoa();
        pessoa.setDataNascimento(new Date());
        pessoa.setNome("Pessoa Qualquer 1");
 
        basicDao.persist(pessoa);
        assertNotNull(pessoa.getId());
    }
 
    public void testFindByPk() throws Exception {
        Pessoa pessoa = new Pessoa();
        pessoa.setDataNascimento(new Date());
        pessoa.setNome("Pessoa Qualquer");
        basicDao.persist(pessoa);
 
        Pessoa pessoaTest = (Pessoa)basicDao.findByPk(Pessoa.class, pessoa.getId());
        assertNotNull(pessoaTest.getId());
        assertEquals(pessoa.getNome(), pessoaTest.getNome());
    }
 
    public void testPersistUpdate() throws Exception {
        Pessoa pessoa = new Pessoa();
        pessoa.setDataNascimento(new Date());
        pessoa.setNome("Pessoa Qualquer 2");
        basicDao.persist(pessoa);
 
        Pessoa pessoa2 = new Pessoa();
        pessoa2.setId(pessoa.getId());
        pessoa2.setDataNascimento(new Date());
        pessoa2.setNome("Pessoa Qualquer 3");
        basicDao.persist(pessoa2);
 
        Pessoa pessoaTest = (Pessoa)basicDao.findByPk(Pessoa.class, pessoa.getId());
        assertEquals(pessoa2.getNome(), pessoaTest.getNome());
    }
}

E no BasicDao, implementei um método simples para limpeza de tabelas.

    /**
     * Deleta todas as entradas da tabela cujo nome foi passado.
     *
     * @param nome
     */
    public void limparTabela(String nome) throws Exception {
        String delete = "DELETE FROM " + nome;
        Connection conn;
        try {
            conn = getConnection();
            PreparedStatement ps = conn.prepareStatement(delete);
            ps.execute();
        } catch (Exception ex) {
            System.err.println("Erro ao deletar os dados da tabela '" + nome + "'");
            throw ex;
        }
    }

Lazy Connection

Bem, será que alguém notou que, ao buscar um BasicModel, nenhum outro model ou collection relacionados são obtidos?  Na linha 15 do findByPK nada é feito quando o atributo do model é do tipo model ou collection.

Isso é feito visando a questão de performace, apesar de se tratar de um exemplo meramente didático.

Para visualizar o problema, imagine que tenhamos muitos dados (pessoas) no banco. Se na busca por id incluíssemos todos os atributos, acabaria gerando uma busca recursiva (busca uma pessoa, e os pais dessa pessoa, e os pais dos pais…), passando por todas as pessoas com alguma ligação à pessoa buscada. Se necessitarmos apenas dos dados de uma pessoa, todas as outras muitas buscas realizadas foram um desperdício de processamento, conexão com o banco e tempo.

Para resolver isso, o Java Persistence API (JPA) possui o conceito de Lazy Connection (ou conexão preguiçosa ^^). Utilizando essa especificação, podemos mapear modelos de dados utilizando relacionamentos “preguiçosos”. No nosso exemplo, poderíamos mapear o relacionamento pai-filho como lazy de modo que, ao obter uma pessoa, o seu pai não é imediatamente consultado no banco. Ao invéz disso, um proxy fica no lugar do pai até que este seja requerido através, por exemplo, de um getPai().

Como não utilizaremos nenhum framework, teremos que implementar esse conceito no braço! =D

Mas não será nada muito complexo… A idéia é basicamente implementar uma busca por pai, mãe e filhos partindo de uma pessoa e, então, alterar os getters do model Pessoa para realizar a busca se necessário.

Lazy getMae() / getPai()

Como pai e mãe de uma pessoa obtida através de uma consulta ao banco estarão nulos, não temos informação para realizar uma busca por essas pessoas. Por isso, antes de fazer um findByPK para pai e mãe, temos que obter os seus id consultando o próprio filho.

    /**
     * Obtem o model pai de um model filho já instanciado.
     *
     * @param child
     * @param parentClazz
     * @param fieldName
     * @return BasicModel
     */
    public BasicModel getLazyBasicModel(BasicModel child, Class parentClazz, String fieldName) throws Exception {
        String select = "SELECT " + fieldName + " FROM " + child.getClass().getSimpleName() + " WHERE id = " + child.getId();
        try {
            Connection conn = getConnection();
            PreparedStatement ps = conn.prepareStatement(select);
            ResultSet keys = ps.executeQuery();
 
            if(keys.next() && keys.getObject(1) != null) {
                return findByPk(parentClazz, keys.getInt(1));
            }
        } catch (Exception ex) {
            System.err.println("Erro ao obter o model pai por conexão lazy. A operação foi abortada.");
            throw ex;
        }
        return null;
    }

Bastante simples. Agora alteramos os getters em questão de Pessoa para verificar a nulabilidade dos pais e buscar por eles caso afirmativo.

    public Pessoa getMae() throws Exception {
        if(mae == null && this.id != null) {
            BasicDao basicDao = new BasicDao();
            mae = (Pessoa) basicDao.getLazyBasicModel(this, Pessoa.class, "mae");
        }
        return mae;
    }
 
    public Pessoa getPai() throws Exception {
        if(pai == null && this.id != null) {
            BasicDao basicDao = new BasicDao();
            pai = (Pessoa) basicDao.getLazyBasicModel(this, Pessoa.class, "pai");
        }
        return pai;
    }

Temos, é claro, que testar! Então adicionemos o seguinte teste ao BasicDaoTest:

    public void testGetLazyModel() throws Exception {
        Pessoa pai = new Pessoa();
        pai.setDataNascimento(new Date());
        pai.setNome("Pessoa Pai");
        basicDao.persist(pai);
 
        Pessoa filho = new Pessoa();
        filho.setNome("Pessoa Filho");
        filho.setDataNascimento(new Date());
        filho.setPai(pai);
        basicDao.persist(filho);
 
        Pessoa filhoTest = (Pessoa) basicDao.findByPk(Pessoa.class, filho.getId());
        assertNotNull(filhoTest.getPai());
        assertEquals(pai.getId(), filhoTest.getPai().getId());
        assertNull(filhoTest.getMae());
    }

Se tudo ocorrer bem, podemos avançar para a próxima e um pouco mais complexa parte.

Lazy getFilhos()

Antes de mais de nada, existe uma observação que deve ser feita com relação ao modelo de dados utilizado aqui.

Como esse projeto tem uma função apenas didática e como estamos construindo cada um dos SQLs de interação com o banco, podemos nos dar a liberdade de realizar escolhas visando a facilidade de implementação. Mas nem sempre essas escolhas poderão ser feitas.

Por exemplo, no BasicModel implementado, cada pessoa possui pai, mae e filhos de maneira direta. Entretando, se fôssemos utilizar um framework de persistência como o Hibernate, teríamos que estudar um pouco melhor esses relacionamentos.

No momento de mapear a coleção de filhos, precisamos informar qual o atributo do outro lado que comanda o relacionamento. Por exemplo, num relacionamento Estado-Cidade, um Estado possui um conjunto de cidades, e o atributo que comanda esse relacionamento é Cidade.estado. Entretanto, no relacionamento de Pai-Filho, temos mais de um atributo que pode comandar (pai e mae). Por isso, utilizando o Hibernate teríamos que alterar o modelo, talvez criando uma tabela intermediária com o tipo de relacionamento.

Mas voltando à nossa realidade, podemos criar um SQL como “SELECT * FROM Pessoa WHERE pai = 1 OR mae = 1“. Então mãos à obra!

    /**
     * Obtem uma lista de filhos a partir de um model pai
     *
     * @param parent
     * @param childClazz
     * @param fieldNames
     * @return {@link List} de {@link BasicModel}
     */
    public Set<BasicModel> getLazyBasicModelCollection(BasicModel parent, Class childClazz, String[] fieldNames) throws Exception {
        String select = "SELECT id, ";
        String from = " FROM " + childClazz.getSimpleName();
        String where = " WHERE ";
        boolean primeiro = true;
        for (Field field : childClazz.getDeclaredFields()) {
 
            //Se o campo for uma coleção de objetos ou um basic model
            if (Collection.class.isAssignableFrom(field.getType()) ||
                    BasicModel.class.isAssignableFrom(field.getType())) {
                //DO NOTHING
                continue;
            }
            else {
                if (primeiro) {
                    primeiro = false;
                } else {
                    select += ", ";
                }
            }
            select += field.getName();
        }
 
        primeiro = true;
        for(String fieldName : fieldNames) {
            if (primeiro) {
                primeiro = false;
            } else {
                where += " OR ";
            }
            where += fieldName + " = " + parent.getId().toString();
        }
 
        try {
            Connection conn = getConnection();
            PreparedStatement pstmt = conn.prepareStatement(select + from + where);
            pstmt.execute();
 
            Set<BasicModel> filhos = new HashSet<BasicModel>();
            ResultSet keys = pstmt.getResultSet();
            while (keys.next()) {
                filhos.add(ResultSet2BasicModel(keys, childClazz));
            }
            return filhos;
        } catch (Exception ex) {
            System.err.println("Erro ao obter uma coleção de models por conexão lazy. A operação foi abortada.");
            throw ex;
        }
    }

A implementação não ficou muito complicada. Apenas obtemos todas as pessoas cujo pai ou mãe é a pessoa base (atenção… nós não restringimos que uma pessoa pode ser apenas pai ou mãe!) e retornamos uma lista com essas pessoas.

Em Pessoa temos que alterar o getFilhos():

    public Set getFilhos() throws Exception {
        if(filhos == null && this.id != null) {
            BasicDao basicDao = new BasicDao();
            Set set = basicDao.getLazyBasicModelCollection(this, Pessoa.class, new String[]{"pai","mae"});
            filhos = set;
        }
        return filhos;
    }

E então, podemos testar!

    public void testGetLazyCollection() throws Exception {
        Pessoa pai = new Pessoa();
        pai.setDataNascimento(new Date());
        pai.setNome("Pessoa Pai");
        basicDao.persist(pai);
 
        Pessoa filho = new Pessoa();
        filho.setNome("Pessoa Filho");
        filho.setDataNascimento(new Date());
        filho.setPai(pai);
        basicDao.persist(filho);
 
        Pessoa paiTest = (Pessoa) basicDao.findByPk(Pessoa.class, pai.getId());
        assertNotNull(paiTest.getFilhos());
        assertEquals(1, paiTest.getFilhos().size());
    }
 
    public void testGetLazyCollection2() throws Exception {
        Pessoa pai = new Pessoa();
        pai.setDataNascimento(new Date());
        pai.setNome("Pessoa Pai");
        basicDao.persist(pai);
 
        Pessoa filho1 = new Pessoa();
        filho1.setNome("Pessoa Filho 1");
        filho1.setDataNascimento(new Date());
        filho1.setPai(pai);
        basicDao.persist(filho1);
 
        Pessoa filho2 = new Pessoa();
        filho2.setNome("Pessoa Filho 2");
        filho2.setDataNascimento(new Date());
        filho2.setMae(pai);
        basicDao.persist(filho2);
 
        Pessoa paiTest = (Pessoa) basicDao.findByPk(Pessoa.class, pai.getId());
        assertNotNull(paiTest.getFilhos());
        assertEquals(2, paiTest.getFilhos().size());
    }

Se tudo deu certo os testes deverão estar 100% e estamos prontos para começar, efetivamente, a camada web!… Outro dia, claro…

(Bruno! Agora é com você!)

Baixe aqui o código fonte do core com o que foi visto até agora: arvore-ginecologica. (Obs: necessita o driver do pgsql e não notem o nome “zuado” do projeto ^^)

WARNING! POST EXTENSO DETECTADO! o_O

A partir da versão 6.5 o NetBeans define o idioma padrão automaticamente de acordo com as configurações regionais do sistema em questão. E, até onde sei, não existe uma forma elegante para alterar isso (imagino que não seja complicado adicionar um menu para esta função).

Por isso, segue uma forma mais bruta:

Localize o arquivo “netbeans.conf”, na pasta onde a IDE está instalada. Provavelmente em um caminho como:

• “/Applications/NetBeans/NetBeans\ 6.5.app/Contents/Resources/NetBeans/etc/netbeans.conf“ para MacOS;
• “C:\Arquivos de programas\NetBeans 6.5.1\etc\netbeans.conf“ para Windows.

Abra-o com o bloco de notas e no final da string referente ao atributo “netbeans_default_options“, adicione as opções “-J-Duser.language=en -J-Duser.region=US“.

O arquivo deverá ficar como netbeans.conf.

Salve, abra ou reinicie o NetBeans e verifique a alteração do idioma.

Fonte: Algumas Idéias