Resumo
Aprender a programar para Android
exige a absorção de conceitos básicos que são mais naturalmente entendidos
quando aplicados em algum projeto de desenvolvimento. Objetivando introduzir o
contato com o Kotlin para Android, foi criado neste artigo um aplicativo simples
de calculadora que possibilita a apresentação do tratamento de eventos de botões, uso de expressões regulares e utilização de um método
estático.
Introdução
O desenvolvimento
de aplicativos envolve o entendimento de conceitos que devem ser naturalizados pelos
desenvolvedores. Uma das formas mais comuns de se naturalizar os diversos
recurso de uma plataforma é desenvolver projetos que demonstrem o funcionamento
prático dos conceitos implementados.
O aplicativo Calculadora foi desenvolvido por possibilitar
o contato inicial do desenvolvedor com os conceitos de tratamento de eventos,
métodos estáticos e expressões regulares.
O código
desenvolvido buscou implementar estes conceitos de maneira introdutória. Não
foi priorizado o desenvolvimento de uma interface gráfica visualmente atrativa.
O desenvolvimento foi focado em aplicar uma solução para tratar os diversos
eventos de botões oriundos da interface Android, uma abordagem prática para a
utilização de um método estático e a utilização de expressões
regulares para tratamento de strings.
1. Configuração do Projeto
O projeto foi desenvolvido utilizando o Android Studio
4.1 e a linguagem Kotlin 1.2.0.
Para facilitar o atrelamento dos componentes
gráficos da tela foi instalado o plugin kotlin-android-extensions. A instalação foi realizada
incluindo a linha abaixo no arquivo de módulo build.gradle
apply
plugin: "kotlin-android-extensions"
Esse plugin permite o tratamento direto
do componente fazendo referência ao nome do seu id no código. Para maiores informações consulte o link https://medium.com/kotlin-para-android/kotlin-android-extensions-8abdc33f21ef
Obs: O plugin kotlin-android-extensions foi descontinuado. Porém, a solução implementada poderá ser ajustada pelo desenvolvedor. Podedo substituir as referências aos componentes da tela com o comando findViewById.
2. Projeto Calculadora
a.Tela do Aplicativo
A tela do aplicativo foi desenvolvida com a inclusão
de dois TextViews e dezesseis botões. Os TextViews são utilizados para armazenar
a expressão matemática digitada pelo usuário e apresentar o resultado calculado
pelo aplicativo. Os botões oferecem as opções de digitação dos números,
operadores matemáticos e de apagar a expressão e o resultado dos cálculos.
b. Estrutura do Projeto
O projeto foi desenvolvido no Android Studio com a criação de duas classes: MainActivity e Calculadora. A classe MainActivity foi gerada automaticamente no momento em que o projeto foi criado no Android Studio.
MainActivity será a classe responsável
por capturar e tratar os eventos gerados na interface gráfica. A classe Calculadora contém o método
para calcular as operações matemáticas (soma, subtração, multiplicação e divisão)
definidas pela expressão digitada pelo usuário. Segue a imagem da estrutura de
classes do projeto.
c. Detalhamento Classe MainActivity
A classe MainActivity implementa
a interface View.OnClickListener que obriga a sobrescrita do método onClick.
Este método concentrará todos os eventos de clicks realizados pelo usuário através
dos botões da calculadora. Além deste método a class MainActivity possui
os métodos onCreate, clickListeners, atualizaTextView, atualizaOperacaoCalculo
e atualizaNumeroExpressao .
onCreate – Inicializa a tela
do aplicativo e os valores iniciais dos objetos que serão utilizados pela tela.
clickListeners – Associa os botões com a tela. Fazendo com que a tela seja uma “ouvinte” dos botões, ou seja, todas as vezes que os botões forem clicados, a Tela “escutará” estes eventos e executará o método onClick
atualizaOperacaoCalculo – Esse método é responsável por atualizar o TextView da expressão toda vez que o usuário clicar em um dos botões que representa uma operação matemática
atualizaNumeroExpressao - Esse método é responsável por atualizar os valores dos resultados na tela cada vez que o usuário insere ou modifica um número.
A classe MainActivity também
possui os atributos resultado – responsável por armazenar os valores calculados e operacaoAcionada
- que é do tipo Boolean e indica quando o usuário selecionou uma operação
matemática.
class MainActivity
: AppCompatActivity(), View.OnClickListener
{
private var resultado:Int = 0
private var operacaoAcionada:Boolean
= false
override fun onCreate(savedInstanceState:
Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
clickListeners()
txtDisplay.setText("")
txtResultado.setText("")
}
private fun clickListeners()
{
btn0.setOnClickListener(this)
btn1.setOnClickListener(this)
btn2.setOnClickListener(this)
btn3.setOnClickListener(this)
btn4.setOnClickListener(this)
btn5.setOnClickListener(this)
btn6.setOnClickListener(this)
btn7.setOnClickListener(this)
btn8.setOnClickListener(this)
btn9.setOnClickListener(this)
btnDiv.setOnClickListener(this)
btnMult.setOnClickListener(this)
btnSub.setOnClickListener(this)
btnSoma.setOnClickListener(this)
btnZerar.setOnClickListener(this)
}
override fun onClick(v:
View?) {
when
(v?.id)
{
R.id.btn0->
{
atualizaNumeroExpressao("0")
}
R.id.btn1->
{
atualizaNumeroExpressao("1")
}
R.id.btn2->
{
atualizaNumeroExpressao("2")
}
R.id.btn3->
{
atualizaNumeroExpressao("3")
}
R.id.btn4->
{
atualizaNumeroExpressao("4")
}
R.id.btn5->
{
atualizaNumeroExpressao("5")
}
R.id.btn6->
{
atualizaNumeroExpressao("6")
}
R.id.btn7->
{
atualizaNumeroExpressao("7")
}
R.id.btn8->
{
atualizaNumeroExpressao("8")
}
R.id.btn9->
{
atualizaNumeroExpressao("9")
}
R.id.btnSoma->
{
atualizaOperacaoCalculo("
+ ")
}
R.id.btnSub->
{
atualizaOperacaoCalculo("
- ")
}
R.id.btnMult->
{
atualizaOperacaoCalculo("
x ")
}
R.id.btnDiv->
{
atualizaOperacaoCalculo("
/ ")
}
R.id.btnZerar->
{
atualizaTextView(txtDisplay,"",true)
atualizaTextView(txtResultado,"",true)
}
}
}
private fun atualizaTextView(textView:
TextView,caracter:String,zerar:Boolean
= false ){
if(zerar){
textView.setText(caracter);
} else
{
textView.text
= textView.text.toString()
+ caracter;
}
}
private fun atualizaOperacaoCalculo(caracter:String
){
txtDisplay.text
= txtDisplay.text.toString()
+ caracter
operacaoAcionada
= true
}
private fun atualizaNumeroExpressao(caracter:String){
atualizaTextView(txtDisplay,caracter)
if
(operacaoAcionada){
operacaoAcionada
= false
} else
{
atualizaTextView(txtResultado,caracter)
}
val
calcResultExp: Int
calcResultExp = Calculadora.getCalculo(txtDisplay.text.toString())
txtResultado.setText(calcResultExp.toString())
}
}
d. Detalhamento Classe Calculadora
A classe Calculadora possui o método estático getCalculo. Um método estático é um tipo de método pertencente à classe que não necessita da criação de um objeto para que a mesmo possa ser utilizado. Este método é chamado na classe MainActivity através do comando Calculadora.getCalculo(txtDisplay.text.toString()) presente em atualizaNumeroExpressao. Este método utiliza expressão regular para quebrar a expressão matemática em apenas números e operações conforme a explicação dos comandos abaixo:
val
nums = expressao.split("[+-/x]".toRegex()).toTypedArray()
- pega a expressão matemática e transforma em um array com os números e armazena na variável nums
Ex: 1 + 2 + 3
será transformado em um array com os seguintes
valores
[0] – 1, [1] – 2, [2] – 3.
OBS: O parâmetro "[+-/x]".toRegex() passa para o método split que a string deverá ter as operações matemáticas como ponto de exclusão para formar o array de números
Val
op = expressao.replace("\\s+".toRegex(),"").split("\\d".toRegex()).toTypedArray()
– pega a expressão matemática e gera um array com apenas os símbolos das operações matemáticas.
EX: 1 + 2 - 3 irá gerar o array
[0] – ‘+’, [1] - ‘-‘
itemOp.contains("[+-/x]".toRegex()) – verifica se a string possui um dos operadores matemáticos especificados na expressão regular.
class Calculadora {
companion object {
fun
getCalculo(expressao:String): Int {
var
resultado:Int = 0
val
nums = expressao.split("[+-/x]".toRegex()).toTypedArray()
val
op = expressao.replace("\\s+".toRegex(),"").split("\\d".toRegex()).toTypedArray()
var
i:Int = 1
resultado
= resultado + nums[0].toString().trim().toInt()
for(itemOp
in op ){
if(itemOp.contains("[+-/x]".toRegex())){
when
(itemOp) {
"+"->
{
resultado =
resultado + nums[i].toString().trim().toInt()
}
"-"->
{
resultado =
resultado - nums[i].toString().trim().toInt()
}
"x"->
{
resultado =
resultado * nums[i].toString().trim().toInt()
}
"/"->
{
resultado =
resultado / nums[i].toString().trim().toInt()
}
}
i++
}
}
return
resultado
}
}
}
3. Conclusão
O projeto da Calculadora foi criado
para demonstrar a aplicação do tratamento de eventos no Android, a utilização
de um método estático com o Kotlin e o uso de expressão regular com o método
split e contains da classe String. Explicações completas sobre os temas devem ser
buscados na documentação do kotlin ou nos links de referência.
O código está disponível através
do endereço do github
https://github.com/santanna106/CalculadoraAndroidKotlin.git
4. Referências
https://developer.android.com/reference/kotlin/android/widget/Button
https://developer.android.com/kotlin/learn
https://developer.android.com/kotlin/first
https://kotlinlang.org/docs/data-classes.html
Comentários
Postar um comentário