Arquivo diário: 19 de julho de 2011
Quais os melhores campos de atuação na área de TI?
Conheça os mais comuns
Umas das carreiras mais buscadas nos dias de hoje é a Tecnologia da Informação, que é um conjunto de atividades e soluções providas por recursos tecnológicos que visam permitir o armazenamento, o acesso e o uso das informações. “Na verdade, as aplicações para TI são enormes e estão ligadas às mais diversas áreas dentro de Telecomunicações e Informática (Hardware e Software)”, conta Cláudio Pinheiro, da Pixel TI, localizada em Santa Rita do Sapucaí (MG).
Já o consultor de TI e empreendedor, Fábio David Batista, gosta de enxergar a TI como uma área de apoio a qualquer outra área. “Hoje em dia a ‘informatização’ é presente e necessária em todas as áreas da nossa sociedade. O bom profissional de TI é aquele que consegue conciliar o conhecimento e habilidades técnicas em uma ou mais das especializações de TI, com a flexibilidade e desenvoltura de aplicar a outra área da sociedade que precise deste apoio”.
Segundo ele, as áreas mais comuns são:
– Desenvolvimento: criação de software – podem ser websites, sistemas completos, jogos etc. Nessa área existem as funções de Gerente de Projetos, Arquiteto de Software, Engenheiro de Software, Programador, Analista de Sistemas, Analista de Negócio, Analista de Testes, Web Designer, Testador, entre outros.
– Infraestrutura: envolve trabalhar hardware e software para manter um ambiente de TI funcionando. Há diversas especializações, entre elas Servidores Windows, Servidores Linux, Redes, Bancos de Dados etc. Há certificação formal para muitas dessas especializações, emitida pelas empresas fabricantes do software ou do hardware.
– Suporte ou apoio: envolve prestar auxílio no dia a dia das pessoas e empresas, no uso dos recursos de TI.
Quais os melhores campos de atuação?
Segundo Cláudio, não há um campo mais receptivo para atuação, pois isto depende de cada um: “Atualmente não existe uma área especifica, há mercado e demanda de profissionais em todas as áreas. O maior patrimônio dentro de uma empresa é a informação e os talentos responsáveis pela geração destas informações”. Já Fábio conta que a TI é um “campo” em que as profissões são muitas, sendo assim, no geral, está longe de estar saturada. “Há uma grande demanda por profissionais qualificados nas empresas. E também é muito difícil encontrar uma empresa hoje que realmente ‘trabalhe’. Porém, há o lado negativo, em que muitas empresas não sabem exatamente o que contratar, o que esperar do profissional, como motivá-lo ou como medir sua produtividade. Muitas empresas colocam critérios altamente especializados, por exemplo, ‘desenvolvedor em quatro linguagens e com experiência no ‘ERP X’, ou ‘obrigatório certificação Y’, e acabam não conseguindo encontrar bons profissionais, ou contratando os ditos picaretas”.
E quanto aos salários: quais pagam mais e quais pagam menos
O consultor Fábio aponta que pelo o que tem observado, as melhores condições salariais estão nos cargos gerenciais, como os Gerentes de Projetos. “As funções altamente especializadas, diretamente vinculadas a sistemas existentes, como exemplos Consultor SAP, DBA Oracle etc, estão em segundo lugar, porém demandam investimento em certificações, cursos e muita atualização”.
O importante é saber que quase toda função é relativamente nova, e não há um “sindicato” ou “conselho” da área, então os salários acabam sendo bastante discrepantes de empresa para empresa. Vale ressaltar que a pessoa deve se colocar como um profissional com mais do que apenas qualidades técnicas, para receber o devido reconhecimento e pleitear melhores salários.
“Suporte técnico e programação, principalmente nos estágios iniciais e em linguagens consideradas mais ‘simples’, são as que pagam menos. Dificilmente um programador PHP consegue uma remuneração acima de 10 salários mínimos, mas o mesmo programador, trabalhando com NET ou Java, pode ultrapassar os 20”.
Como se destacar neste mercado?
De acordo com Cláudio, quem quer se destacar nesta profissão tem de ter inventividade, ser interessado em tecnologia e as suas evoluções, além de saber trabalhar em equipe e mostras proatividade. “Eu recomendo muita leitura e que a pessoa não perca uma das mais importantes características que é essencial para estes profissionais: a criatividade”.
Fábio também deixa o seu recado: “Lembre-se sempre que se você tiver apenas um martelo na mão, vai achar que todos os seus problemas são pregos. Diversifique suas ferramentas e suas habilidades. Nascem e morrem novas tendências e ferramentas de TI todos os dias. Mantenha-se sempre atualizado e engajado, porém mantendo o foco. O mercado está começando a valorizar cada vez mais o perfil generalista. E não tenha medo de ser chamado de ‘nerd’ nessa área, pois a inteligência e a dedicação realmente importam”.
Por – Priscilla Silvestre
Introdução ao Desenvolvimento Android
Autor: Fabio Mattes <fabiomattes2007 at gmail.com>
Data: 18/07/2011
O que é esse tal de Android?
Segundo a wikipédia:
“Android é um sistema operacional móvel que roda sobre o núcleo Linux, embora por enquanto seja ainda desenvolvido numa estrutura externa ao núcleo Linux. Foi inicialmente desenvolvido pela Google e posteriormente pela Open Handset Alliance, mas a Google é a responsável pela gerência do produto e engenharia de processos. O Android permite aos desenvolvedores escreverem software na linguagem de programação Java controlando o dispositivo via bibliotecas desenvolvidas pela Google. Existem atualmente mais de 100 mil aplicações disponíveis para Android. O sistema operativo Android consiste em 12 milhões de linhas de código, incluindo 3 milhões em XML, 2.8 milhões de linhas de C, 2.1 milhões de linhas de código Java e 1.75 milhões de linhas de código em C++.”
Fonte: http://pt.wikipedia.org/wiki/Android
Os Principais Sistemas Disponíveis
Symbian:
Atualmente rodando nos celulares da Nokia (esta sem previsão de portar seus celulares para Android), sucessor do Epoc, este sistema é agradável de se usar, mas a parte de desenvolvimento é complicada sendo só possível fazer aplicações em Java puro. Rápido e multitarefa, ele pode ser rodado em aparelhos mais antigos e com poucos recursos de processamento. Por exemplo o Psion 5 que tinha um processador de apenas 36MHZ, 10 vezes mais inferior que os atuais ARM’s.
Windows Mobile:
O mais usado em Smartphones (Infelizmente), devido a sua interface idêntica ao sistema operacional Windows e pela integração com o MS-Outlook, MSN e outros. Por ser mais pesado (novidade), é mais usado em aparelhos com poder de processamento mais alto, isso sem contar o fato de que os aparelhos rodando o Windows Mobile são mais caros. Mas ainda é o mais usado por conter uma gama de aplicativos maior que os demais, por exemplo o Skype.
PalmOS:
A dor de cabeça de quem tem um aparelho com este SO, é que ele está desatualizado e perdendo mercado para os concorrentes com maior poder de desenvolvimento. Ainda pode ser usado, mas em aparelhos antigos. Os aparelhos lançados até o momento ainda sofrem com a falta de desenvolvimento de aplicações novas.
Em fim o Android:
O Android é a solução do Google para o problema. SO Open-Source, com Kernel Linux. Agrandando 4 setores diferentes:
-
Os fabricantes de aparelhos;
-
Os desenvolvedores;
-
Os fabricantes de chips;
-
Os próprios consumidores.
Agrada os fabricantes de aparelhos devido ao custo zero, aos desenvolvedores por que o mesmo já tem a sua SDK própria gratuita com emulador e tudo mais, agrada aos fabricantes de chips por adicionar novos recursos aos aparelhos, aumentando a demanda de aparelhos mais potentes e por último, mas não menos importante, agrada os consumidores, por ter um visual bonito e limpo, sem falar que tem muitas aplicações desenvolvidas (praticamente todo dia aparecem novas).
Palmas para o Google.
Começando: Eclipse e AndroiSDK
Primeiramente antes de começa,r vou levar em conta que você já tenha a java SDK instalada e configurada no seu sistema.
A distribuição que estou usando é o Debian 6 Squeeze, mas pode ser usada em qualquer distribuição.
Os softwares necessários são:
-
AndroidSDK : dl.google.com/android/android-sdk_r11-linux_x86.tgz
-
EclipsePlugin ADT : dl.google.com/android/ADT-11.0.0.zip
Instalando o Eclipse Classic
Crie a seguinte pasta /home/seusuario/eclipse e descompacte o Eclipse e coloque dentro dela.
Execute o arquivo eclipse. Você também pode adicionar um atalho ao seu Desktop para ele. Lembrando novamente que estou levando em consideração que você já tenha a sdk do java instalado e configurado.
Ao inciar o Eclipse pela primeira vez, lhe será pergunta onde será o workspace, ou seja, onde ficarão armazenados os projetos, você pode deixar o padrão ou pode criar uma pasta a parte se você quiser.
Depois de aberto, lhe será mostrado a área de trabalho do Eclipse como na imagem abaixo:
Instalando o AndroidSDK
Agora iremos instalar o emulador do Android, o AndroidSDK.
Depois de baixado, abra um terminal e acesse a pasta onde se encontra o arquivo compactado, em seguida descompacte o arquivo:
$ tar -xvzf android-sdk_r11-linux_x86.tgz
Ele irá descompactar a pasta android-sdk-linux_x86, entre nesta pasta e dê um ls.
$ cd android-sdk-linux_x86
$ ls
Resultado:
add-ons platforms platform-tools SDK Readme.txt temp tools
A pasta tools é onde se encontra o emulador em si, acesse ela e execute o emulador:
$ cd tools
$ ./android
E isso ai, estamos prontos para instalar o Android em nosso emulador:
Você também pode criar se quiser um atalho no Desktop para ele.
Agora iremos instalar o Android, primeiramente veja que temos 5 opções na lateral esquerda, clique em Available Packages, aguarde ele atualizar a lista de aplicativos:
Clique na setinha que se encontra ao lado dehttps://dl-ssl.google.com/android/repository/repository.xml.
Será mostrado todas as aplicações disponíves para instalar no emulador. Para o nosso artigo iremos utilizar apenas a plataforma 2.2 do Android então marque:
Marque apenas a opção SDK Platform Android 2.2, API 8, revision 2 e clique em Install Selected, será exibida uma janela para confirmação, clique em Accept e em seguida Install. Será iniciado o download do nosso Android 2.2.
Após terminar o download a tela não irá fechar sozinha, clique em Close como na imagem abaixo e pronto.
Criando o nosso Dispositivo Virtual
Agora criaremos o nosso AVD (Android Virtual Device) para que possamos rodar nosso Sistema Android.
Clique na opção Installed Packages na lateral esquerda e veja que apenas o nosso SDK Platform Android 2.2, API 8, revision 2 se encontra instalado.
Vamos criar nosso dispositivo virtual, clique na aba Virtual Devices e em seguida clique em New, lhe será apresentada a seguinte tela:
Onde os campos são:
-
Name: Nome que deseja dar para este Dispositivo Virtual;
-
Target: Você deve apontar para a API desejada. No meu caso, apontei para o Android 2.2 que instalei;
-
SD Card: Aqui você define o tamanho que deseja para o arquivo que será o Dispositivo Virtual;
-
Skin: Nesta opção você poderá definir a resolução que deseja utilizar ou tamanho de tela;
-
Hardware: Opções para abstração ou comunicação com o seu hardware.
Iremos usar a seguinte configuração:
-
Name: Android2.2
-
Target: Android 2.2 – API Level 8
-
SD Card: 2000 MiB
-
Skin: Built-in: HVGA
-
Hardware: Podem deixar o padrão que se encontra.
Após preenchermos todas as configurações clicamos em Create AVD, ele irá demorar um pouco, mas isso é totalmente normal.
Depois de criado podemos iniciar o nosso Android 2.2 clicando em Start, ele irá abrir a tela abaixo, clique em Launch e pronto, ele também demora para carregar, mas é só pra carregar, quando estivermos desenvolvendo, basta deixarmos ele aberto e nossa aplicação irá se atualizar, sem precisarmos fechar o emulador.
Iniciando o Android 2.2
Depois de Iniciado:
Agora podem brincar com seu Android, podem até navegar na internet usando o navegador dele:
Plugin ADT e testando o Ambiente de Desenvolvimento
O Plugin ADT
O Plugin ADT é um plugin para Eclipse desenvolvido para agilizar no processo de desenvolvimento para a plataforma Android.
Basicamente existem duas maneiras de se instalar o ADT:
-
Instalação online;
-
Instalação offline.
Instalação Online:
Com o Eclipse aberto clique em Help > Install New Software, será aberta a tela de instalação de novos plugins:
Em seguida clique em add no canto direito para adicionarmos o repositório para instalação:
Serão mostrados dois campos:
-
Name;
-
Location.
Em Name coloque um nome para o plugin ADT, por exemplo ADT Plugin.
Em Location coloque: https://dl-ssl.google.com/android/eclipse/, caso não encontre a url troque o https por http, e clique em ok, ele irá carregar os plugins para o Eclipse, fazer o Download e Instalar, após isso será mostrado a seguinte tela:
Marque a caixa Developer Tools e clique em next, lhe será mostrado:
Clique em next na próxima janela, depois clique em Accept e Finish na próxima janela:
Lhe será mostrada a seguinte janela, apenas clique em Ok e continue:
Ele irá instalar o plugin:
Em seguida será perguntado se você quer reiniciar o Eclipse, clique em Restart Now e pronto, plugin ADT instalado:
Instalação Offline:
Para a instalação offline o único diferencial é que ao invés de você digitar a url na janela de adição de url’s, vc irá selecionar o zip do ADT em sua maquina clicando em Archive, o resto é idêntico ao método online.
Testando o Plugin e o Android SDK
Agora que temos tudo pronto, que tal testarmos o nosso ambiente de desenvolvimento.
Abra o Eclipse e clique em File > New > Other, lhe será exibida a seguinte imagem:
Clique na seta Android e em Android Project, em seguida Next. Abrirá a tela de configuração do projeto:
Preencha os campos conforme abaixo, os demais deixe padrão:
-
Project Name: TesteAndroid
-
Build Target: Marque a caixa Android 2.2
-
Application Name: Teste de Android
-
Package: br.com.teste
-
Create Activity: Marque a caixa Create Activity e preencha com actTeste
Obs.: Activity é o que gerencia toda a interface com o usuário. -
-
Min SDK Version: Reparem que esse campo é o mais interessante, notem que logo acima em Build Target no Android 2.2 tem um campo chamado API Level, esse é o nível das aplicações desenvolvidas nessa plataforma, no número que está nela é 8, se você digitar no campo Min SDK Version outro número, ele não aceitara, possibilitando assim não cometermos erro na hora de selecionar a plataforma desejada, seja ela 1.5, 2.2, 2.3, 3.0, etc. Sempre preencha este campo com o número igual ao da API Level da plataforma, como a gente está usando a 2.2 a sua a API Level é 8.
Ficando assim nossa configuração:
Clique em Finish e ele irá criar o nosso projeto TesteAndroid e sua estrutura de arquivos e pastas:
Agora reparem que ele montou a seguinte estrutura:
-
src -> br.com.teste -> actTeste.java
-
gen -> br.com.teste -> R.java
-
Android 2.2 -> android.jar
-
assets
-
res
-
-> drawable-hdpi -> icon.png
-
-> drawable-ldpi -> icon.png
-
-> drawable-mdpi -> icon.png
-
-
layout -> main.xml
-
values -> strings.xml
-
AndroidManifest.xml
-
default.properties
-
proguard.cfg
A pasta src é onde se encontra o nosso fonte em java, exemplo: a classe principal, classes auxiliares, etc.
A pasta gen é a mais interessante, é nela que fica o arquivo R.java, este arquivo é o que faz a comunicação das janelas, componentes e variáveis com o fonte java. Ele é gerado automaticamente, por recomendação não deve ser editado.
A pasta Android 2.2 é onde ficam as bibliotecas responsáveis para se trabalhar com o Android.
A pasta res é onde ficam nossos resources como imagens.
A pasta layout como o nome já diz, é onde ficam nossas interfaces gráficas, janelas com botões, etc.
A pasta values é onde se encontram as nossa variáveis de comunicação com componentes, explicarei com mais detalhes assim que começarmos a programar.
Estas são as pastas e arquivos mais importantes para começarmos a analisar nosso projeto.
Vamos testar nossa aplicação sem mexer em nada, clique com o botão direito do mouse em cima do nome da nossa aplicação, ou seja TesteAndroid e seguida em Run As e Android Application, se o emulador estiver fechado o eclipse abrirá o emulador, ele pode demorar um pouco como disse mais atrás, mas para evitar de ficar abrindo o emulador toda hora, deixe ele aberto, ele atualiza sua aplicação direto no emulador aberto:
Legal né?
Se ele rodou e mostrou a seguinte tela para você, então está tudo pronto para começarmos a desenvolver.
Mãos a obra, uma calculadora simples
Bom vamos começar nosso desenvolvimento com uma calculadora simples.
Com o tempo eu irei criando mais artigos com mais exemplos de aplicações.
Primeiramente crie um novo projeto Android como mostrei na parte anterior, com as seguintes propriedades:
-
Project Name: calculadora
-
Build Target: Android 2.2
-
Application Name: Calculadora 1.0
-
Package Name: br.com.calculadora
-
CreateActivity: calcActivity
-
Min. SDK Version: 8
Primeiramente clique 2 vezes no arquivo main.xml na pasta res -> layout, esse arquivo é o responsável pela interface gráfica da nossa aplicação, como vocês podem ver na tela abaixo:
Reparem que na parte de cima nós temos algumas propriedades:
-
A primeira que temos é a da resolução do dispositivo, clique nele e selecione 3.2in HVGA (ADAP2), que no caso é o padrão 320×480 px. Note que ele aumentou a janela para adicionarmos nossos widgets;
-
Ao lado da resolução temos a orientação: Portrait ou Landscape, ou seja, Retrato ou Paisagem, deixe como Portrait(Retrato);
-
Ao lado temos os temas, deixe como está. E por último temos a plataforma usada, ou seja, Android 2.2;
-
No lado esquerdo abaixo temos nossa paleta de widgets, é aqui que se encontram todos os nossos componentes visuais, basta como no Delphi, Lazarus ou NetBeans, clicar e arrastar para adicionar o nosso widget.
Muito prático, mas também é possível adicionar ou alterar nossos componentes via xml clicando logo abaixo em main.xml:
Vejam que dos dois modos é muito fácil de se criar uma janela com xml, faça um teste, se você está no modo xml clique em Graphical Layout e apague todos os widgets que estão nele clicando em cima apertando a tecla DEL, adicione o primeiro widget chamado TextView, ele é o equivalente ao Label do Delphi/Lazarus, em seguida clique em main.xml e veja que ele automaticamente criou o código xml:
<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:orientation=”vertical”>
<TextView android:text=”TextView” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”>
</LinearLayout>
Agora no modo xml selecione a linha que começa por <TextView, copie com CTRL+C, dê um enter e cole com CTRL+V, agora volte ao modo gráfico, e veja que ele já adicionou um novo TextView, legal demais. Faça os testes, coloque um Button pelo modo gráfico e entre no modo xml e veja o código, notem que ele tem muitas propriedades. Tá! E pra alterar estas propriedades?
Simples, no modo gráfico olhe a aba outline dê 2 cliques no nome do widget e veja abaixo as propriedades:
Mas, nada me impede de alterar as propriedades via xml, vamos conhecer algumas:
android:text – está propriedade altera o texto do widget, você pode colocar um texto normal ou uma variável criada no arquivo strings.xml. Exemplo 1: Altere a propriedade android:text do widget TextView:
<TextView android:text=”Olá Mundo” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
Execute o emulador clicando com botão direito do mouse em cima do projeto e clique em Run As -> Android Application e veja o resultado.
Exemplo 2: Abra o arquivo strings.xml na pasta res -> values, clique em add, será mostrado a seguinte tela:
Clique em String e de um ok, ele irá voltar para a tela de adição de variáveis, clique na variável String que acabamos de criar e olhem a direita, temos 2 propriedades para preencher: Name e Value. Preencha como “teste” e “Olá mundo2”.
Agora volte ao nosso main.xml e no modo xml altere a propriedade android:text para:
<TextView android:text=”@string/teste” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
Execute novamente a aplicação, como eu já havia mostrado antes.
Com isto estamos referenciando o texto para pegar o valor da variável teste que criamos.
android:id
A propriedade android:id nada mais é do que um identificador para os widgets, ou seja, quando formos criar nossas aplicações no arquivo java, iremos referenciar no widgets ao código java por este ID.
Vamos a um exemplo pratico, volte ao modo gráfico e adicione um Button na tela, em seguida volte ao modo xml e altere as seguintes linhas:
<TextView android:text=”@string/teste” android:id=”@+id/textView1″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<Button android:text=”Button” android:id=”@+id/button1″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></Button>
Para:
<TextView android:text=”@string/teste” android:id=”@+teste/txtTexto” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<Button android:text=”Trocar Texto” android:id=”@+teste/btnTroca” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></Button>
Veja que alteramos a propriedade id do TextView para @+teste/txtTexto, ou seja, trocamos o seu nome e seu identificador, a mesma coisa com o Button, essa propriedade é muito interessante caso você tenha uma aplicação com várias telas, você poderia identificar cada widget em suas respectivas telas.
Outra coisa interessante também seria você abrir o arquivo R.java na pasta gen e olhar seu conteúdo, mas lembre-se de não altera-lo:
Notem que tudo o que foi criado se encontra nele, é ele que irá fazer a ponte entre o xml dos widgets e o código java em si.
Voltemos então ao nosso exemplo prático, abra o arquivo principal do nosso exemplo, o calcActivity.java:
Nele iremos fazer acontecer a mágica. Eis o seu conteúdo:
package br.com.calculadora;
import android.app.Activity;
import android.os.Bundle;
public class calcActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Primeiramente vamos importar as bibliotecas necessárias. Na seção imports digite:
import android.widget.*; // Importando a classe widget
import android.view.*; // importando a classe view
Sem essas classes não iremos conseguir manipular os widgets e nem criar seus eventos.
Agora vamos instanciar nossos widgets, antes de @override digite o seguinte código:
TextView txtTexto; // Cria um Objeto TextView
Button btnTroca; // Cria um Objeto Button
Criado nossos widgets vamos referência-los ao nosso main.xml, logo abaixo a linha setContentView(R.layout.main); digite:
txtTexto = (TextView) findViewById(R.teste.txtTexto); // Aqui fazemos a referencia com o método findViewById(), muito fácil.
btnTroca = (Button) findViewById(R.teste.btnTroca);
Que tal agora criarmos um evento pra eles, logo abaixo a linha btnTroca = (Button) findViewById(R.teste.btnTroca); digite o seguinte código:
btnTroca.setOnClickListener(new View.OnClickListener() { // Criando o evento para o clique do botão
@Override
public void onClick(View arg0) {
txtTexto.setText(“Você trocou o texto!”);
}
});
Execute novamente e olhe o resultado. Muito simples não?
Eis o código completo:
package br.com.calculadora;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
public class calcActivity extends Activity {
/** Called when the activity is first created. */
TextView txtTexto;
Button btnTroca;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
txtTexto = (TextView) findViewById(R.teste.txtTexto);
btnTroca = (Button) findViewById(R.teste.btnTroca);
btnTroca.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
txtTexto.setText(“Você trocou o texto!”);
}
});
}
}
Calculadora simples, Layout…
Agora vamos finalmente criar a nossa calculadora. Apague todos os widgets que estão na tela, e remova os seguintes trechos de código da classe principal calcActivity.java:
package br.com.calculadora;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
public class calcActivity extends Activity {
/** Called when the activity is first created. */
TextView txtTexto; // <- Remover
Button btnTroca; // <- Remover
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
txtTexto = (TextView) findViewById(R.teste.txtTexto); // <- Remover daqui
btnTroca = (Button) findViewById(R.teste.btnTroca);
btnTroca.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
txtTexto.setText(“Você trocou o texto!”);
}
}); <- até aqui
}
}
Vamos começar adicionando os widgets nesta sequência, lembrando sempre em colocar os valores das propriedades entre ” (aspas duplos):
*TextView
propriedade text: Calculadora 1.0
*TextView
propriedade text: Digite o primeiro número:
*EditText
propriedade text: em branco
propriedade layout_width: match_parent
propriedade id: @+calc/edtNum1
*TextView
propriedade text: Digite o segundo número:
*EditText
propriedade text: em branco
propriedade layout_width: match_parent
propriedade id: @+calc/edtNum2
*TextView
propriedade text: Resultado:
*EditText
propriedade text: em branco
propriedade layout_width: match_parent
propriedade id: @+calc/edtResultado
*LinearLayout
O LinearLayout organiza os componentes em ordem Horizontal e/ou Vertical, aqui deixaremos ele como Horizontal, clicando nos botões em destaque na imagem abaixo:
E dentro deste LinearLayout vamos adicionar um Button com as seguintes propriedades:
propriedade text: Somar
propriedade id: calc/btnSomar
E pronto nosso layout está pronto, se quiser executar para ver como fica no emulador fica a seu critério:
Segue o código xml, arquivo main.xml:
<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
>
<TextView android:text=”Calculadora 1.0″ android:id=”@+id/textView1″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<TextView android:text=”Digite o primeiro número:” android:id=”@+id/textView2″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<EditText android:layout_height=”wrap_content” android:id=”@+calc/edtNum1″ android:text=”” android:layout_width=”match_parent”></EditText>
<TextView android:text=”Digite o segundo número:” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<EditText android:layout_height=”wrap_content” android:id=”@+calc/edtNum2″ android:text=”” android:layout_width=”match_parent”></EditText>
<TextView android:text=”Resultado:” android:id=”@+id/textView4″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<EditText android:layout_height=”wrap_content” android:layout_width=”match_parent” android:id=”@+calc/edtResultado” android:text=””></EditText>
<LinearLayout android:layout_height=”wrap_content” android:layout_width=”match_parent” android:id=”@+id/linearLayout1″>
<Button android:text=”Somar” android:id=”@+calc/btnSomar” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></Button>
</LinearLayout>
</LinearLayout>
Calculadora simples, Codificação
Agora vem a parte interessante, a codificação da nossa aplicação Calculadora.
Até agora o código do nosso calcActivity está assim:
package br.com.calculadora;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
public class calcActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Vamos começar fazendo uma soma simples, abra o arquivo calcActivity.java se não estiver aberto.
Instancie os widgets e crie as variáveis em formato double para armazenar os números, com o seguinte código acima de @override:
EditText edtNum1, edtNum2, edtResultado;
Button btnSomar;
double num1, num2, resultado;
Agora vamos referência-los, abaixo da linha setContentView(R.layout.main); digite:
// Casts para relacionar os widgets
edtNum1 = (EditText) findViewById(R.calc.edtNum1);
edtNum2 = (EditText) findViewById(R.calc.edtNum2);
edtResultado = (EditText) findViewById(R.calc.edtResultado);
btnSomar = (Button) findViewById(R.calc.btnSomar);
Vamos criar o evento do botão somar, abaixo do cast btnSomar digite:
btnSomar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
num1 = Double.parseDouble(edtNum1.getText().toString()); // Variavel num1 recebe o valor convertido em double do EditText edtNum1
num2 = Double.parseDouble(edtNum2.getText().toString()); // Variavel num2 recebe o valor convertido em double do EditText edtNum2
resultado = num1 + num2; // Variavel resultado recebe o valor da soma de num1 = num2
edtResultado.setText(String.valueOf(resultado)); // Valor de resultado é convertido em string e passado para o edtResultado.
}
});
Pronto, simples não, pode rodar e testar a aplicação:
E é isso ai gente. Agora ficou fácil de implementar o resto das função como subtrair, multiplicar e dividir, fica ai então como exercício e divertimento de vocês fazerem estas funções.
Espero voltar com mais artigos sobre Android, pois achei muito interessante desenvolver nessa plataforma, espero que tenham gostado e muito obrigado.
Também quero deixar meu agradecimento ao Professor Neri Neitzk, sem o qual nunca teria conhecimento de como programar nesta fabulosa plataforma que é o Android.
Referências:
fabiano florentino 