Android: “Hello World”

A plataforma Android desenvolvida pela google, é uma das grandes novidades hoje no mercado. É considerada a primeira plataforma para dispositivos móvel aberta, com uma grande variedade de recursos. Mantida pelo Open Handset Aliance, que contém um grupo de 30 empresas: Entre fabricantes, empresas de tecnologia e etc.

Android foi desenvolvido e baseado no Kernel 2.6 Linux, responsável por gerenciar a memória, threads os processos, segurança, redes e drivers. Com esse gerenciamento é permitido executar varias aplicações ao mesmo tempo, tanto aplicativos em segundo plano onde o usuário não visualiza (Services) e aplicativos acessados pelo usuário.

Para o desenvolvimento de aplicações, é utilizada a linguagem Java, permitindo usufruir de todos os recursos.

Para desenvolvimento a google disponibiliza: Emulador, Ferramenta de analise e performance, Plugin(ADT) para a IDE Eclipse. Atualmente o android esta na versão 1.5 esta versão veio com várias novidades.

A estrutura para desenvolvimento é muito organizada: Diretórios, criação de layout, arquivos de internacionalização, imagens e etc. Além de permitir que suas aplicações possam integrar-se com aplicações nativas ou criar. Novidades também são as “widgets” que estão fortes nessa nova versão. Resumindo Android é Robusto e Completo, disponibilizando de inúmeras variedades de inovações.

Para informações acesse: http://developer.android.com

A seguir vou mostrar uma pequena aplicação “Hello World” dando uma idéia inicial da plataforma.

Ambiente para desenvolvimento:

• SDK:  Neste artigo utilizei a SDK 1.5, onde pode ser baixada em: http://developer.android.com/sdk/1.5_r1/index.html .
  • Ao baixar a SDK, descompacte e coloque no diretório “C:\” por padrão, pois esta pasta pode esta localizada em qualquer parte do sistema operacional.
  • Com a SDK decompactada e supondo que esteja em “C:\android-sdk-windows-1.5_r1″ adicione no seu PATH (Variavel de Ambiente do Windows) “C:\android-sdk-windows-1.5_r1\tools”. Nessa primeira release da versão 1.5, esta com erro na execução do emulador, a seguir vou explicarei como corrigir o erro.
  • Acesse o diretório pelo prompt do DOS “C:\android-sdk-windows-1.5_r1\tools”.
  • Execute os seguintes comandos somente para a versão 1.5, isso fará com que funcione corretamente, assim como para a versão 1.1 embutida nesta nova versão:
    • android create avd –target 1 –name NormalVM01
    • android create avd –target 2 –name CupcakeVM01
  • Com a SDK configurada você agora pode executar o emulador localizado na pasta “C:\android-sdk-windows-1.5_r1\tools”.
• Plugin para o eclipse ADT (Android Development Tools). Para instalação do ADT foi utilizado a versão 3.4 do eclipse:
  • Com o eclipse aberto acesse o menu Help / Software Updates.
  • Na janela software updates, acesse a aba Available Software e clique no botão Add Site, insira a URL
    • http://dl-ssl.google.com/android/eclipse/site.xml
    • http://dl-ssl.google.com/android/eclipse/site.xml , caso tenha algum problema no primeiro link.
  • Com a URL adicionada selecione a mesma e clique no botão install. Quando finalizar a instalação será pedido para reiniciar o eclipse.
  • Após instalado e reiniciado, acesso o menu Window / Preferences e seleciona a opção Android. No campo SDK Location informe o diretório que esta localizada a SDK.

Criando a primeira aplicação Android:

Para criar um novo projeto android no eclipse acesse o menu File / New / Project, acesse o diretório Android e seleciona Android Project, clique em Next.

Configuração do projeto:

Build Target: Seleciona a versão 1.5.

Project Name: Neste campo é informado o nome do projeto criado no eclipse. Daremos o nome de ProjectHelloWorld.

Application Name: Este campo representa o titulo da nossa apresentação que será exibida para o usuário. Daremos o nome de HelloWorld.

Package Name: É informado o nome do pacote onde estará a Activity principal. Daremos o nome de br.com.helloworld.

Create Activity: Nome da Activity principal do projeto. Activity representa uma tela, e esta vai ser a Activity pricipal do projeto.  Daremos o nome de ActHelloWorld.

Com o projeto criado é possível visualizar a sua estrutura:

• src: Pasta que contém pacotes de classes Java. Nesta pasta esta contido a classe ActHelloWorld definida na criação do projeto.
• gen: Como o nome já diz , contém arquivos Javas gerados automaticamente, são arquivos padrão. A classe R é a classe padrão de android e não deve ser modificada.
• assets: Pode ser incluídos arquivos opcionais para o projeto.
• res: Esta pasta contém as pastas de recursos da nossa aplicação:
  • drawable: Pasta padrão para imagens da aplicação.
  • layout: Contém arquivos XML de layout, responsáveis por construir as telas da aplicação.
  • values: Contém arquivos de internacionalização XML para a aplicação e outras configurações.

Para cada arquivo localizado na pasta res, contém uma referencia na classe R. A cada alteração ,remoção ou inclusão no diretório res, a classe R é atualizada automaticamente.

Abaixo temos o código fonte da classe ActHelloWorl:

package br.com.helloworld;

import android.app.Activity;

import android.os.Bundle;

public class ActHelloWorld extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

}

}

Observe que a classe R é invocada no método setContentView, passando no parâmetro a referencia do arquivo de layout main. Já da pra ter uma idéia da importância dessa classe, com essa estrutura você pode montar seus layouts em arquivos XML e chamados nos eu código Java, sem precisar misturar designer e lógica.

Para executar seu projeto, basta clicar com o botão direito no projeto e selecionar a opção Run / Android Application.

Este foi o primeiro exemplo da configuração e construção de uma aplicação Android. Nas cenas do próximo capitulo estarei mostrando mais exemplo e detalhando mais. Espero que todos os leitores tenham gostado, qualquer duvida postem!!!.

J2ME: RMS – Básico

Galera, vou postar aqui um exemplo básico de manipulação de dados em J2ME (RMS), utilizando seu repositório de dados o RecordStore. Para aqueles que não conhecem o RecordSotore, ele é muito mas ao mesmo tempo complexo em relação a manipulação de dados, muita coisa tem que ser feita na mão e bem configurada. Neste exemplo terá métodos de criação de um RecordSotore, métodos para inserir e consultar dados. Coisa muito simples, somente para dar uma idéia de como funciona este recurso.  No futuro vou inserir um novo post já com uma visão mais avançada. A Midlet tem dois formulários um Main e outro de Cadastro, o FormMain exibirá os dados cadastrados, e o FormCadastro fará a inclusão de uma string. Uma Midlet realmente muito simples somente para mostrar o básico. Espero que ajude e qualquer duvida é só postar!!!

package com.RMS;

import java.util.Vector;

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.microedition.midlet.MIDletStateChangeException;
import javax.microedition.rms.RecordStore;
/***
*
* @author Marcelo Alves
* MIdlet Básica para Criar um RecordStore, Deletar, Salvar dados e Ler dados.
*/
public class RMSBasic extends MIDlet implements CommandListener {

private RecordStore rs = null;
private final String REC_STORE = “db_1″;
private Form frmMain = null;
private Form frmCadastro = null;
private TextField txtNome = null;
private Command cmdSair = null;
private Command cmdNovo = null;
private Command cmdGravar = null;

public RMSBasic() {

txtNome = new TextField(“Nome: “,”",20,TextField.ANY);
cmdGravar = new Command(“Salvar”,Command.OK,0);
cmdSair = new Command(“Sair”,Command.EXIT,1);
cmdNovo = new Command(“Novo Registro”, Command.SCREEN,1);

frmCadastro = new Form(“Cadastro”);
frmCadastro.append(txtNome);
frmCadastro.addCommand(cmdGravar);
frmCadastro.addCommand(cmdSair);
frmCadastro.setCommandListener(this);

frmMain = new Form(“Principal”);
frmMain.addCommand(cmdSair);
frmMain.addCommand(cmdNovo);
frmMain.setCommandListener(this);

//Inicio com RS zerado
this.deleteRecodStore();
this.openRecordStore();
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
notifyDestroyed();
}

protected void pauseApp() {}

protected void startApp() throws MIDletStateChangeException {
Display.getDisplay(this).setCurrent(frmMain);
}
//Método responsável por abrir um Record Store desejado
public void openRecordStore(){
try {
/**
* O Segundo parâmetro indica que o registro
* deve ser criado, se ele não existir
*/
rs = RecordStore.openRecordStore(REC_STORE, true);
} catch (Exception e) {
e.printStackTrace();
}

}

/**
* @param cmd – Captura o comando do Display
* @param dsp – Captura o display corrent
*/
public void commandAction(Command command, Displayable display) {
//Caso o display corrente seja frmMain verifica qual comando esta sendo solicitado
if(display == frmMain){
if(command == cmdNovo){
txtNome.setString(“”);
Display.getDisplay(this).setCurrent(frmCadastro);
}else if(command == cmdSair){
try {
destroyApp(true);
} catch (Exception e) {
e.printStackTrace();
}

}

}else if(display == frmCadastro){
if(command == cmdGravar){
//Recupera o texto digitado e envia para o método que grava no repositório
this.writeRecord(txtNome.getString());
this.popularFormMain(readRecords());
Display.getDisplay(this).setCurrent(frmMain);

}else if(command == cmdSair){
Display.getDisplay(this).setCurrent(frmMain);
}
}

}
//Exibe dados contidos no repositório
public void popularFormMain(Vector dados){
frmMain.deleteAll();
for (int i = 0; i < dados.size(); i++) {
frmMain.append(dados.elementAt(i).toString());
}
}

//Fecha a “conexão” com o RecordStore
public void closeRecordStore(){
try {
rs.closeRecordStore();
} catch (Exception e) {
e.printStackTrace();
}
}
//Delete um RecordStore criado.
public void deleteRecodStore(){
// Verifica se o exite algum RecordSotore criado
if(RecordStore.listRecordStores() != null){
try {
RecordStore.deleteRecordStore(REC_STORE);
} catch (Exception e) {
e.printStackTrace();
}
}
}
//Salva uma String no RecordStore que foi aberto
public void writeRecord(String str) {
byte[] rec = str.getBytes();

try {
rs.addRecord(rec, 0, rec.length);
} catch (Exception e) {
e.printStackTrace();
}
}

//Faz uma leitura dos dados contidos no RecordStore que foi aberto
public Vector readRecords(){
Vector dados = new Vector();

try {
byte[] recData = new byte[5];
int len;

for (int i = 1; i <= rs.getNumRecords(); i++) {
if(rs.getRecordSize(i) > recData.length){
recData = new byte[rs.getRecordSize(i)];
}
len = rs.getRecord(i, recData, 0);
dados.addElement(new String(recData, 0, len));
}

} catch (Exception e) {
e.printStackTrace();
}

return dados;
}
}

[]‘s

Marcelo Alves!

Criando Games J2ME no NetBeans

Boa Noite

Vi este video onde é mostrado a criação da parte de Designer de um game no netbeans, desde a criação da animação do personagem até o mapa do game.

Creating Mobile Games in NetBeans

[]‘s

Att,

Marcelo Alves

Android

Android

Foi lançando um livro sobre Google Android em Português, aqueles que estiverem interessados acessem este link da notícia:

Portal Android.

Abraços!

Marcelo Alves

Google lança seu novo navegador: Chrome

Aqueles que conhecem a Google como a grande inovadora de ferramentas para web 2.0, agora pode contar com o seu novo navegador Chrome, lançado nesta tarde. Particularmente achei do C@#$%. Abre as paginas mais rápido e fácil. É claro que precisa de melhorias como toda ferramenta recém lançada. Obs.: Estou utilizando ele para postar esta notícia .

Pra quem quiser fazer um Teste-Drive, faça o download no endereço: http://tools.google.com/chrome/

 By Marcelo Alves

GINGA – Middleware para TV Digital

Para aqueles que se interessam em desenvolver aplicativos para TV Digital, ta ai um middleware muito interessante de se estudar e envolver com o projeto. Hoje um tópico muito discutido entre empresas e desenvolvedores para inovações em TV Digital, vale a pena para aqueles que buscam cada dia novos rumos ou MultiThread (rsrs), é interessante participar desta comunidade que esta crescendo. Acessem: www.ginga.org.br

Até a proxima!

JavaMe: Gauge Não Interativo

package j2me.marcelo.interfaceAN.gauge;

import java.util.Timer;
import java.util.TimerTask;

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.Gauge;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class GaugeNInterativo extends MIDlet implements CommandListener
{
private Display display;
private Form frmMain;
private Command cmdExit;
private Command cmdStop;
public Gauge gaProgress;
private Timer tm;
private DownloadTimer tt;

public GaugeNInterativo() {
display = Display.getDisplay(this);
cmdExit = new Command(“Sair”,Command.EXIT,1);
cmdStop = new Command(“Stop”,Command.STOP,1);
gaProgress = new Gauge(“Progresso do Download”,false,20,1);

frmMain = new Form(“Form Gauge Interativo”);
frmMain.addCommand(cmdStop);
frmMain.append(gaProgress);
frmMain.setCommandListener(this);

}

protected void startApp() throws MIDletStateChangeException {
//Cria o cronômetro que é acionado a cada 1000 milissegundos
tm = new Timer();
tt = new DownloadTimer();
tm.scheduleAtFixedRate(tt,0, 1000);
display.setCurrent(frmMain);

}

protected void pauseApp() {

}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
notifyDestroyed();

}

public void commandAction(Command c, Displayable d){
if(c == cmdExit){
try {
destroyApp(true);
} catch (MIDletStateChangeException e) {

e.printStackTrace();
}
}
//Ao Cancelar o download cancela o timer e remove cmdStop e adiciona cmdExit
if(c == cmdStop){
tm.cancel();
frmMain.removeCommand(cmdStop);
frmMain.addCommand(cmdExit);
gaProgress.setLabel(“Download Cancelado!!”);

}
}

/**
* Processa a Task cronômetro
*/
private class DownloadTimer extends TimerTask
{

public final void run()
{
//Verifica se o valor atual do gauge é menor que seu valor máximo
if(gaProgress.getValue() < gaProgress.getMaxValue())
{
//Incrementa + 1
gaProgress.setValue(gaProgress.getValue() + 1);
}else
{
frmMain.removeCommand(cmdStop);
frmMain.addCommand(cmdExit);

gaProgress.setLabel(“Download Concluido”);

cancel();
}
}
}
}

JAVA: HelloWord J2ME CLDC e MIDP

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.TextBox;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class HelloWord extends MIDlet implements CommandListener{
private Display display; //Referencia para o objeto privado Display
private TextBox tbMain; // Caixa de texto para exibir uma mensagem
private Command cmExit; // Comando para sair da MIDlet

public HelloWord() {
//Retorna display e passa por parametro MIDlet
display = Display.getDisplay(this);
cmExit = new Command(“Sair”,Command.EXIT,1);
tbMain = new TextBox(“Bem-Vindo”,“HelloWorld”,50,0);
tbMain.addCommand(cmExit);
tbMain.setCommandListener(this);
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {}

protected void pauseApp() {}

//Chamado pelo gerenciador de aplicações para iniciar o MIDlet
protected void startApp() throws MIDletStateChangeException {
display.setCurrent(tbMain);

}
public void commandAction(Command c,Displayable s){
if(c == cmExit){
try {
//Destroi a aplicação
destroyApp(false);
//Notifica a App. Manager para finalizar o sistema
notifyDestroyed();
} catch (MIDletStateChangeException e) {

e.printStackTrace();
}
}
}

}

JAVA: Exceptions, mostrando descrição da exceção

package pckException;

public class TesteException {

public void exec1(){
try {
exec2();
} catch (Exception e) {
System.out.printf(“%s\n\n”,e.getMessage());

//Imprime o rastreamento de pilha
e.printStackTrace();

 //Recebe as informações do rastreamento de pilha
StackTraceElement[]  stkTraceElements = e.getStackTrace();

System.out.println(“\nMostra a descrição da exceção”);
System.out.println(“Classe\t\t\t\tArquivo\t\t\tLinha\tMetodo”);

//Loop em stkTraceElements para mostrar toda a descrição da exceção
for(StackTraceElement element : stkTraceElements){

System.out.printf(“%s\t”,element.getClassName());
System.out.printf(“%s\t”,element.getFileName());
System.out.printf(“%s\t”,element.getLineNumber());
System.out.printf(“%s\n”,element.getMethodName());

}
}
}
public void exec2() throws Exception{
exec3();
}
public void exec3() throws Exception{
throw new Exception(“Exception lançada em exec3″);
}

public static void main(String[] args) {

TesteException te = new TesteException();
te.exec1();

}

}

JAVA : JTable Implementada

Neste Exemplo teremos duas Classes, uma que implementa o modelo da JTable estudada no tutorial: http://www.guj.com.br/java.tutorial.artigo.147.1.guj , e a outra que é responsavel por criar e preencher os dados buscados via banco de dados. Estou colocando mais um post aqui sobre JTable pois existe muitos que tem duvida de como trabalhar com esta swing.

1 – Classe JTableModel:

package myPck;

import java.util.ArrayList;

import java.util.Iterator;

import javax.swing.table.AbstractTableModel;

/**

* Classe Responsável por definir o modelo da JTable

* Foi utilizado o tipo ArrayList para o atributo linhas

* pois não é definido qual tamanho total de linhas podendo

* ser alterada em tempo de execução(remover ou incluir).

* Obs.: Este código foi implementado juntamente com os comentários

* do site www.guj.com.br pelo autor Bruno Rios Lima

* @author Marcelo Alves

*/

public class JTableModel extends AbstractTableModel {

private ArrayList linhas;

private String[] colunas;

public JTableModel(ArrayList dados,String[] colunas){

setLinhas(dados);

setColunas(colunas);

}

//Retorna o numero de colunas

public int getColumnCount(){

return getColunas().length;

}

//Retorna o numero de linhas

public int getRowCount(){

return getLinhas().size();

}

//Obtem o valor da linhas e coluna

public Object getValueAt(int rowIndex, int columnIndex){

//Recebe a linha, passando por cast para String[]

String[] linha = (String[])getLinhas().get(rowIndex);

//Retorna o objeto na posição de columnIndex

return linha[columnIndex];

}

//Seta valor da linha e coluna

public void setValueAt(Object value,int rowIndex, int columnIndex){

String[] linha = (String[])getLinhas().get(rowIndex);

//Altera o conteúdo da linha na posição do indice columnIndex

linha[columnIndex] = (String)value;

//Dispara o evento da celula alterada

fireTableCellUpdated(rowIndex, columnIndex);

}

//Adiciona nova linha

public void addRow(String[] dadosLinha){

getLinhas().add(dadosLinha);

//Informa ao JTable que ouve linhas incluidas no modelo

//Como os dados são adicionados no final pega o tamanho total das linhas

//menos 1 para obter a linha incluida.

int linha = getLinhas().size() -1;

fireTableRowsInserted(linha,linha);

}

//Remove linha

public boolean removeRow(String val, int col){

//obtem o iterator

Iterator i = getLinhas().iterator();

//Guarda as linhas percorridas

int linha = 0;

//Faz um loop enquando obtiver dados

while(i.hasNext()){

//Obtem as colunas da linha atual

String[] linhaCorrente = (String[])i.next();

linha++;

//Compara o valor da linha atual na coluna e valor

//informado por parametro

if(linhaCorrente[col].equals(val)){

getLinhas().remove(linha);

//informa a JTable que houve dados deletados

//passando a linha removida

fireTableRowsDeleted(linha,linha);

return true;

}

}

//Caso não encontre o valor

return false;

}

//Retorna o nome da coluna

//getColumnName[col] retorna na posição do indice!

public String getColumnName(int col){

return getColunas()[col];

}

public ArrayList getLinhas(){

return linhas;

}

public String[] getColunas(){

return colunas;

}

public void setLinhas(ArrayList dados){

linhas = dados;

}

public void setColunas(String[] dados){

colunas = dados;

}

}

2 – Classe JTableCreate:

package myPck;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Types;

import java.util.ArrayList; import javax.swing.JTable;

/**

* Classe responsável por criar e definir o modelo

* de JTable

* Além das funções de preenchimento dos dados na tabela

* buscandos via banco

* @author Marcelo Alves

*/

public class JTableCreate {

private JTable jTable;

private JTableModel modelo;

/**

* Construtor recebe os parametros das linhas e colunas

* e execulta o metodo createJTable

* @param linhas

* @param colunas

*/

public JTableCreate(ArrayList linhas, String[] colunas){

createJTable(linhas,colunas);

}

/**

* Define o modelo e cria jTable indicando o modelo criado

* @param linhas

* @param colunas

*/

public void createJTable(ArrayList linhas, String[] colunas){

modelo = new JTableModel(linhas,colunas);

jTable = new JTable(modelo);

}

/**

* Responsável por preencher a jTable com dados buscados via

* Banco. Dentro do laço for utiliza-se um switch para verificar

* os dados de dados buscado no banco.

* @param rs

* @throws SQLException

*/

public void popularJTable(ResultSet rs)throws SQLException{

//Obtem os Meta dados do resultset

ResultSetMetaData rsmd = rs.getMetaData();

/**

* Cria a Array de Strings definindo o tamanho com o total de linhas retornada pela consulta

*/

String[] linhaNova = new String[rsmd.getColumnCount()];

//Enquanto existir dados

while(rs.next()){

for(int i=0; i < modelo.getColumnCount(); i++){

switch (rsmd.getColumnType(i + 1)) {

case Types.INTEGER:

linhaNova[i] = “”+rs.getInt(i + 1);

break;

case Types.VARCHAR:

linhaNova[i] = rs.getString(i + 1);

break;

}

}

modelo.addRow(linhaNova);

}

}

/**

* Retorna {@link JTable}

* @return jTable

*/

public JTable getJTable(){

return jTable;

}

/**

* Altera jTable

* @param jTable

*/

public void setJTable(JTable jTable){

this.jTable = jTable;

}

}

Você pode utilizar o tutorial passado juntamente com estas classes, é claro que deverá ser feitas alguma alterações principalmente o acesso a um Banco de Dados.