Código J2ME para enviar um SMS

23 julho 2009 14 comentários
Olá! Mais um dos códigos fornecidos no forum da Nokia e testado pelo JavaMovel!
Este permite enviar um SMS para o número desejado. Pode ser útil para alguma aplicação. Além de ser muito interessante descobrir como fazer estas coisas.

A primeira parte só cria o form que vai ser utilizado para receber o número e o texto da mensagem. Os demais métodos são operações para o envio da mensagem. O código é simples e não é complicado de entender. Qualquer coisa é só deixar um comentário!

import java.io.IOException;
import java.io.InterruptedIOException;
import javax.microedition.io.Connector;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;
import javax.wireless.messaging.MessageConnection;
import javax.wireless.messaging.TextMessage;

public class SMSMIDlet extends MIDlet implements CommandListener {
private Command enviar;
private Command sair;
private Form form;
private TextField tfNumero;
private TextField tfTexto;
private MessageConnection connection;

public SMSMIDlet() {
//"desenha" o form, inserindo seus componentes
form = new Form("Examplo de envio de SMS");

tfNumero = new TextField("Numero:", null, 20,
TextField.PHONENUMBER);
form.append(tfNumero);

tfTexto = new TextField("Texto:", null, 160, TextField.PLAIN);
form.append(tfTexto);

enviar = new Command("Enviar", Command.ITEM, 0);
form.addCommand(enviar);

sair = new Command("Sair", Command.EXIT, 0);
form.addCommand(sair);

form.setCommandListener(this);
}

public void startApp() {
Display.getDisplay(this).setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
if (connection != null) {
try {
connection.close();
} catch (IOException ex) {
}
}
}

public void commandAction(Command command, Displayable displayable) {
if (command == sair) {
destroyApp(true);
notifyDestroyed();
} else if (command == enviar) {
enviarMensagem();
}
}

private void enviarMensagem() {
try {
connection = (MessageConnection)Connector.open("sms://:5000");
} catch (IOException ex) {
}

TextMessage mensagem = prepararSMS();
enviarSMS(mensagem);
}

private TextMessage prepararSMS() {
TextMessage mensagem = (TextMessage)connection.newMessage(
MessageConnection.TEXT_MESSAGE);

String number = "sms://" + tfNumero.getString();
mensagem.setAddress(number);

String texto = tfTexto.getString();
mensagem.setPayloadText(texto);

return mensagem;
}

private void enviarSMS(final TextMessage message) {
Thread smsThread = new Thread() {
public void run() {
try {
connection.send(message);
form.append("Mensagem enviada");
} catch (InterruptedIOException ex) {
} catch (IOException ex) {
} catch (IllegalArgumentException ex) {
} catch (SecurityException ex) {
}
}
};
smsThread.start();
}
}

Fazendo uma chamada Telefônica em J2ME

17 julho 2009 0 comentários
Aqui está um código de como fazer uma aplicação que realiza uma chamada telefônica. Eu testei no meu celular da Nokia e funcionou perfeitamente. Aproveitem e comentem se der qualquer problema!

O código todo com exceção do método chamar é para criar um form, com um textField e dois comandos: um para chamar e o outro para sair.

import javax.microedition.io.ConnectionNotFoundException;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.ImageItem;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

public class MIDletChamada extends MIDlet implements CommandListener {

private boolean midletPaused = false;

private Command exitCommand;
private Command cmdChamar;
private Form form;
private TextField textField;

public MIDletChamada() {
}

private void initialize() {
}

public void startMIDlet() {
switchDisplayable(null, getForm());
}

public void resumeMIDlet() {
}

public void switchDisplayable(Alert alert, Displayable nextDisplayable) {
Display display = getDisplay();
if (alert == null) {
display.setCurrent(nextDisplayable);
} else {
display.setCurrent(alert, nextDisplayable);
}
}

public void commandAction(Command command, Displayable displayable) {
if (displayable == form) {
if (command == cmdChamar) {
chamar(getTextField().getString());
} else if (command == exitCommand) {
exitMIDlet();
}
}
}

public Command getExitCommand() {
if (exitCommand == null) {
exitCommand = new Command("Sair", Command.EXIT, 0);
}
return exitCommand;
}

public Form getForm() {
if (form == null) {
form = new Form("", new Item[] { getTextField() });
form.addCommand(getExitCommand());
form.addCommand(getCmdChamar());
form.setCommandListener(this);
}
return form;
}

public Command getCmdChamar() {
if (cmdChamar == null) {
cmdChamar = new Command("Chamar", Command.OK, 0);
}
return cmdChamar;
}

public TextField getTextField() {
if (textField == null) {
textField = new TextField("Telefone", null, 32, TextField.PHONENUMBER);
textField.setLayout(ImageItem.LAYOUT_DEFAULT);
textField.setInitialInputMode("UCB_BASIC_LATIN");
}
return textField;
}

public Display getDisplay () {
return Display.getDisplay(this);
}


public void exitMIDlet() {
switchDisplayable (null, null);
destroyApp(true);
notifyDestroyed();
}

private void chamar(String numero) {
try {

platformRequest("tel:" + numero);

} catch (ConnectionNotFoundException ex) {
System.out.println(ex.getMessage());
}
}

public void startApp() {
if (midletPaused) {
resumeMIDlet ();
} else {
initialize ();
startMIDlet ();
}
midletPaused = false;
}

public void pauseApp() {
midletPaused = true;
}

public void destroyApp(boolean unconditional) {
}
}

Este código foi disponibilizado pela Nokia, em seu forum.
Att, javamovel

Gráficos em Java ME com MECHART

09 julho 2009 0 comentários

MECHART é uma API que fornece uma biblioteca para construção de gráficos de linhas, pizza e barras. Registrada sobre a GPL, encontra-se como um projeto no java.net. Neste link pode-se encontrar o .jar da API, as classes .java, a documentação e os códigos fonte.

A intenção deste post é apresentar esta API para aqueles que ainda não conhecem. A MECHART pode ajudar de forma significativa os desenvolvedores de aplicativos móveis com a plataforma Java ME, visto que a dificuldade para gerar gráficos nessa plataforma é considerável, pois é necessário a utilização de classes de baixo nível, como Canvas.

Para utilizar a API basta realizar o download do .jar ou se preferir vá nas propriedades do seu projeto e crie um novo diretório "com.mechart.chart" e insera todas as classes dispostas no arquivo que você baixou.

No código fonte basta importar as classes para usá-las:

import com.mechart.chart.*;

Nos atributos da classe basta declarar os objetos para acessá-las:

private PieChart pieChart;
private BarChart barChart;
private LineChart lineChart;

Classe LineChart

O construtor da classe LineChart recebe nove parâmetros no total, sendo eles: a largura total do gráfico, a altura total do gráfico, os valores que formam a linha do gráfico, legenda dos dados, identificação dos dados, tamanho da fonte, cor da linha, cor do fundo do gráfico e o valor máximo para o gráfico. Para as cores, a LineChart já traz alguns valores definidos como constantes para você usar, sem a necessidade de conhecer os códigos RGB das cores desejadas.

Classe PieChart

O gráfico de pizza é criado com a classe PieChart, que possui um construtor que recebe cinco parâmetros, sendo eles: a largura total do gráfico, a altura total do gráfico, dados que formam a pizza, altura da fonte e as cores de cada fatia da pizza. O último parâmetro é passado em um vetor de byte, sendo que os bytes que definem as principais cores, estão disponíveis como constantes estáticas na PieChart.

Classe BarChart

O Gráfico de Barras é construído com a utilização da classe BarChart da mechart, seu construtor é semelhante aos demais gráficos da API, os parâmetros passados são: a largura total do gráfico, a altura total do gráfico, dados que formam o gráfico (detalhe, os dados são passados em um Vector, e cada elemento do vetor é uma das "barras" do gráfico), tamanho da fonte, vetor de bytes representando as cores usadas (mesma lógica do PieChart), um byte que representa a cor de fundo do gráfico, e o valor máximo que o gráfico irá receber. Assim como as outras classes da API, a BarChart também tem valores constantes e estáticos para definir algumas das principais cores. O método fullChart(boolean fullChart), chamado por barChart.fullChart(false), especifica se as barras que compõe o gráfico ocuparão um espaço uniforme ou não, de acordo com o argumento booleano.

Na versão 2.0 da API foi criado um novo tipo de gráfico, o gráfico combinado.

Este, por sua vez, combina barras e linhas. Além disso, nesta nova versão, é possível criar gráficos passando cores no formato RGB, tirando a limitação de uso das cores pré-definidas na API. Também, existe um método createImage para todos os tipos de gráficos, que retorna um objeto Image , permitindo seu uso em uma tela Canvas . Por fim, a criação de gráficos em Canvas, e não somente como CustomItem, também foi adicionada a esta versão mais recente da MECHART.

Veja o Resultado:
Segue um código exemplificando o uso da API.

import com.mechart.chart.*;
import java.util.Vector;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class Midlet extends MIDlet implements CommandListener{
private Display display;

private Form fmMain;
private StringItem siTabela;
private PieChart pieChart;
private BarChart barChart;
private LineChart lineChart;

private Command cmSair;

public void startApp() {
display = Display.getDisplay(this);

fmMain = new Form("Teste CustomItem");
siTabela = new StringItem("Tabela", "Titulos");

ClCanvas cv = new ClCanvas();

Vector dados = new Vector();
dados.addElement(new String[]{"Brasil", "50"});
dados.addElement(new String[]{"Alemanha", "88"});
dados.addElement(new String[]{"Itália", "71"});
dados.addElement(new String[]{"Argentina", "45"});
dados.addElement(new String[]{"Uruguai", "22"});

short[] posicoes = new short[]{50, 43, 19, 47, 32, 90};
String[] legenda = new String[]{"Jan", "Fev", "Mar", "Abr", "Mai", "Jun"};
pieChart = new PieChart(cv.getWidth(), 70, dados, 1, new byte[]{PieChart.BLACK, PieChart.FUCHSIA, PieChart.GREEN, PieChart.YELLOW, PieChart.LIME});
barChart = new BarChart(cv.getWidth(), 80, dados, 1, new byte[]{BarChart.RED, BarChart.NAVY,
BarChart.PURPLE, BarChart.LIME, BarChart.TEAL}, BarChart.SILVER, (short)90);
lineChart = new LineChart(cv.getWidth(), 110, posicoes, legenda, "Produção", 1, LineChart.MAROON, LineChart.GRAY, (short)90);
fmMain.append(siTabela);
barChart.fullChart(false);
barChart.sizeBar(20);
fmMain.append(lineChart);
fmMain.append(pieChart);
fmMain.append(barChart);

cmSair = new Command("Sair", Command.EXIT, 1);

fmMain.addCommand(cmSair);
fmMain.setCommandListener(this);

display.setCurrent(fmMain);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command c, Displayable d) {
destroyApp(true);
notifyDestroyed();
}
}

class ClCanvas extends Canvas
{
protected void paint(Graphics graphics) {
}

}

Caso prefira faça o download do projeto deste exemplo.

Para mais informações veja:

Referências

MECHART. Página oficial da API mechart. Disponível em https://mechart.dev.java.net/
Artigo MECHART 1.0. http://www.javafree.org/artigo/871434/Graficos-em-Java-ME-com-MECHART.html
Artigo MECHART 2.0. http://www.javafree.org/artigo/871435/Graficos-em-Java-ME-com-MECHART-20.html
MOBILIDADETUDO. Blog do idealizador da mechart. Disponível em http://mobilidadetudo.blogspot.com/

Por que Java ME?

06 julho 2009 0 comentários

Java Plataform, Micro Edition, Java ME, ou ainda J2ME, é uma tecnologia que possibilita o desenvolvimento de software para sistemas e aplicações embarcadas, ou seja, toda aquela que roda em um dispositivo de propósito específico, desempenhando alguma tarefa que seja útil para o dispositivo.

Das opções tecnológicas disponíveis no mercado, desde sistemas embarcados aos inúmeros jogos e aplicações de celulares, a plataforma Java ME destaca-se como sendo mais atrativa devido a sua portabilidade e acessibilidade, pois além de suas aplicações rodarem nas plataformas de várias empresas de telemóveis, com o Java ME é mais simples construir aplicações que não exigem alto custo, visto que muitos dispositivos de baixo custo suportam aplicativos desta plataforma, o que não acontece com as demais plataformas, como Symbian, Brew, Android, Iphone OS, que requerem implementações específicas utilizando APIs proprietárias.

Mesmo sendo mais limitada que a plataforma Java SE, a Java Micro Edition possui recursos essenciais para o desenvolvimento de qualquer aplicação móvel e provê um ambiente robusto e flexível para aplicativos portados para dispositivos móveis. Possui uma gama de APIs e frameworks para otimização do desenvolvimento das aplicações, juntamente com ferramentas, emuladores e plug-ins que enriquecem o arsenal do desenvolvedor. A plataforma não para de evoluir desde sua criação e através do Java Community Process, onde diversos fabricantes formam uma comunidade para aprimoramento e definição de novas funcionalidades de forma padronizada, a linguagem se tornou um instrumento importante tanto para desenvolvedores quanto para os fabricantes.


Referências:
Artigo Java Magazine 60 - M-Stocks App, por Ernandes Mourão Júnior.
http://pt.wikipedia.org/wiki/Java_ME

iPhones com Microprojetores

0 comentários

O Terra tecnologia divulgou hoje (06/07) que a empresa taiwanesa Foxlink estaria desenvolvendo microprojetores de vídeo para serem integrados a aparelhos como iPhones e iPods, segundo informações do DigiTimes. As fontes citadas pelo site afirmam que fabricantes como Apple, Nokia e Samsung devem lançar ainda este ano dispositivos com a tecnologia, que permitiria projetar vídeos armazenados nestes aparelhos em praticamente qualquer lugar.

Os microprojetores são uma tecnologia recente para aparelhos pequenos, como celulares, que usam hardware minimizado e software específico para projetar imagens digitais sobre superfícies como uma parede, por exemplo.

Algumas empresas já estão trabalhando independentemente em microprojetores para aparelhos portáteis - o Apple Insider cita o projetor PicoP, da Microvision, como exemplo.

E essa onda de projetores vai desde tecnologias XingLing a tecnologias mais sofisticadas como da Honlai Technology e o projetor MiLi Pro.


Fonte:
http://tecnologia.terra.com.br

Programação em par & eXtreme Programming

03 julho 2009 1 comentários

Uma visão geral de XP

Programação extrema (do inglês eXtreme Programming), ou simplesmente XP, é uma metodologia ágil para equipes pequenas e médias e que irão desenvolver software com requisitos vagos e em constante mudança. Para isso, adota a estratégia de constante acompanhamento e realização de vários pequenos ajustes durante o desenvolvimento de software.

Os quatro valores fundamentais da metodologia XP são: comunicação, simplicidade, feedback e coragem. A partir desses valores, possui como princípios básicos: feedback rápido, presumir simplicidade, mudanças incrementais, abraçar mudanças e trabalho de qualidade.
Extreme Programming usa times integrados de programadores, clientes, e gerentes para desenvolver software de alta qualidade em velocidade alta.

Reúne também um conjunto de práticas de desenvolvimento de software já testadas, que estimuladas a sinergia entre elas gerarão vastas melhorias em produtividade global e satisfação do cliente.

Programação em par

Programação em par é uma das práticas mais conhecidas e mais polêmicas utilizadas pelos que adotam o Extreme Programming. Ela sugere que todo e qualquer código produzido no projeto seja sempre implementado por duas pessoas juntas, diante do mesmo computador, revezando-se no teclado.

À primeira vista, a programação em par parece ser uma prática fadada ao fracasso e ao desperdício. Afinal, embora possa haver benefícios, temos a impressão de que ela irá consumir mais recursos ou irá elevar o tempo do desenvolvimento. Entretanto, não é exatamente isso o que ocorre.

Resumindo: Duas pessoas trabalhando juntas num mesmo computador, compartilhando código, idéias e soluções.

Infelizmente o pensamento predominante no meio corporativo é que é um desperdício ter duas pessoas trabalhando num mesmo computador.
Segundo Jay Fields , em um artigo escrito para desenvolvedores ou equipes que estão procurando adotar a programação em par, o sucesso é alcançado quando a equipe gosta do trabalho em par e torna-se mais produtiva por causa disso. Se você abordar a adoção desse ponto de vista, terá uma chance maior de sucesso.

"Porque alguém utilizaria duas pessoas para fazer o trabalho de uma? "

Esta é uma reação comum quando as pessoas são apresentadas a ideia da programação em par. Na essência, eles concluem programação em par como duplicar o custo de escrever um segmento de código. Dave Nicollete demonstra algumas ideias quantitativas para ajudar a mostrar como a programação em par pode salvar dinheiro, ao invés de desperdiça-lo.

A questão econômica da programação em par é confundida como um resultado de uma percepção equivocada de que programação é, em sua maioria, digitação. Na realidade, na sua maioria, é sobre pensar e, como resultado, provê infinitas oportunidades para tomar decisões erradas e criar erros - erros que irão no fim custar aos desenvolvedores (e no caso a organização) tempo no futuro.

É aqui aonde a proposta econômica da programação em par esta fundamentada, e também porque é tão difícil de quantificar. O valor dos pares vem na forma de economia de tempo que seria despendido no futuro e, como todos sabem, "Tempo é dinheiro".

Durante uma recente sessão de programação em par foi registrando a frequência que um par ajudava o outro indicando enganos, bem como as discussões sobre assuntos relacionados com design que foram ocorrendo.

Agora vem a prova:

Em um de seus mais recentes livros, Alistar Cockburn computou que o custo de um profissional de TI gira em torno de US$2.10 por minuto... Na nossa sessão de programação em par, nós tivemos duas mini-discussões sobre design que levaram a pequenos refatoramentos. De acordo com nosso cálculo, foram economizadas quatro horas de esforço de manutenção futuro. Isto vale algo como 2.1 x 120 = $252.00. Tivemos 12 momentos em que um de nós notou um pequeno equivoco. Se estas ocorrências economizaram uma média de 30 segundos de esforço de depuração, então custou 0.5 x 2.1 x 12 = $12.60. No Total, nós economizamos para a companhia $274.60 em 90 minutos ou, dividindo em horas, em torno de $180.00 por hora.

A empresa tem um pequeno departamento de TI com um total de aproximadamente 40 desenvolvedores trabalhando em diversos times XP. Se nós assumimos que as sessões de par ocorrem 5 horas por dia, então serão 20 pares x 5 horas x 5 dias por semana = 500 horas de programação em par por semana. Assumindo que foram economizados $180.00 por hora por par, isso faz com a média de economia seja de $90.000,00 por semana. Se esta taxa de trabalho for mais ou menos constante durante o ano, e os times trabalharem 50 semana por ano (este exemplo é de uma fabrica americana, em que as férias são curtas), a empresa vai desfrutar de uma economia de $4.5milhoes por ano, especificamente porque a prática da programação em par é a padrão dos times de desenvolvimento.

$4.5 milhões para esta empresa de apenas 40 desenvolvedores. Mas Dave admite, que estes são apenas cálculos não precisos derivados de uma simples sessão de programação em par, assim não tem nada de científico, no entanto não tem porque não ser levado em consideração.

E você, desenvolvedor de aplicações móveis, o que acha?

O Java Móvel adota essa prática!

Veja neste link a visão de André Faria Gomes, arquiteto de software, sobre Programação em par.

Referências:
http://www.improveit.com.br/xp
http://www.infoq.com/br/news/2009/07/dollar-value-of-pair-programming
http://xp.edugraf.ufsc.br/bin/view/XP/WebHome
http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_extrema

Ganhe dinheiro na AppStore

02 julho 2009 0 comentários

Segundo a notícia "GANHE DINHEIRO NA AppStore" da olhar digital o número de desenvolvedores de aplicativos vem crescendo, e você também pode fazer parte do time. Qualquer interessado em tecnologia pode desenvolver um aplicativo para iPhone e disponibilizar na AppStore. Até um garoto americano de 9 anos criou um desses aplicativos. Se você quer ganhar uma grana e leva jeito com tecnologia, vale a pena se arriscar nesse mundo, uma vez que a Apple repassa 70% do valor de cada download para os desenvolvedores.

Clique aqui para baixar as ferramentas disponibilizadas gratuitamente pela Apple para você desenvolver seu próprio aplicativo. Confira o vídeo da matéria neste link.

O que todo mundo já está careca de saber, é que é possível com pouco dinheiro e uma boa idéia, ganhar uma boa grana vendendo softwares para Iphone. São diversos os casos em que um único desenvolvedor criou um jogo simples, uma aplicação de utilidade duvidosa e em poucas semanas milhares de downloads foram realizados.

É claro que isso não é uma regra, é preciso competência e um pouco de sorte também, porém é um caminho possível para ganhar uma grana suficiente para transformar isso em meio de vida por alguns anos.

De acordo com a INFO a Apple liberou na terça-feira (30/07) uma nova versão do kit de desenvolvimento de software (SDK) do iPhone. Junto com o SDK 3.1, a empresa também liberou a versão 3.1 do sistema operacional do iPhone para os desenvolvedores, segundo relatos espalhados pela web.

Agora cabe aos desenvolvedores corajosos e persistentes obedecerem os 10 mandamentos para obter a liçenca da Apple, sátira do Mobits, e se arriscar a estudar e desenvolver em Objective C.

Boa sorte e bom estudo a todos... Mas o Java Móvel continua com o querido Java ME!