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/