Vamos a hablar sobre como programar una aplicación para un dispositivo con Android que se va a tratar de una sencilla calculadora.
Como todos sabemos, Android se programa mediante el lenguaje de programación Java. Este ejemplo de la calculadora puede parecer demasiado básico, pero con una idea inicial de como hacer una pequeña aplicación para Android y nociones sobre Java, veremos que desarrollar un programa más complejo es muy fácil.
En primer lugar, necesitaremos el Android SDK que lo podemos descargar de http://developer.android.com/sdk/index.html
Tras instalarlo deberemos ejecutar el archivo android dentro de la carpeta tools y hacer lo siguiente:
- Instalar la plataforma de la versión Android a emular, lo haremos desde la pestaña Available packages y elegiremos la versión que queramos (2.1, 2.2, 2.3, etc)
- Crear un dispositivo virtual, pestaña Virtual devices, que será nuestro dispositivo a emular.
Como segundo paso, haremos uso de la plataforma Eclipse y su plugin ADT para el desarrollo de Android bajo Eclipse. Podemos hacerlo desde la dirección http://developer.android.com/sdk/eclipse-adt.html
Ahora nos quedaría configurar Eclipse para que supiera la ruta hasta el SDK de Android y tendríamos todo preparado para trabajar. Lo podemos hacer desde el menú Window -> Preferences y dentro de la ventana en la pestaña Android tenemos la opción SDK Location.
Ahora tenemos todo preparado y configurado para empezar a crear aplicaciones. La web del SDK de Android contiene varios ejemplo de como empezar a programar y el ejemplo más sencillo es el del "Hola Mundo" donde viene todo el proceso indicado arriba de forma más detallada (lo podéis encontrar aquí http://developer.android.com/resources/tutorials/hello-world.html).
Nosotros nos vamos a basar en uno un poco más avanzado y lo vamos a ampliar hasta crear una aplicación con cierta utilidad. Este ejemplo es el de como posicionar elementos con tamaños y posiciones relativas http://developer.android.com/resources/tutorials/views/hello-relativelayout.html y vamos a añadir algunos elementos y funcionalidades para crear nuestra sencilla calculadora.
Creando nuestra primera aplicación para Android
Para ver cual queremos que sea la interfaz final e intuir el funcionamiento, vamos a mostrar una captura de pantalla del resultado final en el emulador:
donde podemos ver tres elementos: TextView (objeto para mostrar texto), EditText (caja de entrada de texto) y Button (botón).
Empezaremos creando en Eclipse un proyecto para Android, modificaremos el archivo res/layout/main.xml en su vista de código de fuente y pegaremos el siguiente código XML:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView
android:id="@+id/label_a"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Operando A:"/>
<EditText
android:id="@+id/op_a"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:background="@android:drawable/editbox_background"
android:layout_below="@id/label_a"/>
<TextView
android:id="@+id/label_b"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_below="@id/op_a"
android:text="Operando B:"/>
<EditText
android:id="@+id/op_b"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:background="@android:drawable/editbox_background"
android:layout_below="@id/label_b"/>
<Button
android:id="@+id/sumar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/op_b"
android:layout_alignParentLeft="true"
android:layout_marginLeft="1dip"
android:onClick="cSumar"
android:text="+" />
<Button
android:id="@+id/restar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_toRightOf="@id/sumar"
android:layout_alignTop="@id/sumar"
android:onClick="cRestar"
android:text="-" />
<Button
android:id="@+id/multiplicar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_toRightOf="@id/restar"
android:layout_alignTop="@id/restar"
android:onClick="cMultiplicar"
android:text="*" />
<Button
android:id="@+id/dividir"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_toRightOf="@id/multiplicar"
android:layout_alignTop="@id/sumar"
android:onClick="cDividir"
android:text="/" />
<TextView
android:id="@+id/texto_resultado"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_below="@id/dividir"
android:text="Resultado:"/>
<TextView
android:id="@+id/resultado"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_below="@id/texto_resultado"
android:text="Realice operación para obtener resultado"/>
</RelativeLayout>
Los atributos relevantes para este ejemplo de cada elemento son:
- android:id identificador de cada objeto
- android:layout_width y android:layout_height, anchura y altura respectivamente
- android:layout_below: indica si el objeto está debajo de otro
- android:layout_toRightOf y android:layout_alignTop: indican si están varios elementos en la misma fila sobre qué objeto se coloca a su derecha y su posicionamiento en altura
- android:text es el texto por defecto en cada elemento
- android:onClick es el nombre del método público a ejecutar al pulsar ese botón. Este método debe ser obligatoriamente público y tener como parámetro de entrada la vista, ejemplo public void function cSumar(View view) { ... }.
ahora vamos a programar el funcionamiento de los objetos descritos en el archivo de extensión java creado para el proyecto:
package com.android.calculadora;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
public class Calculadora extends Activity {
// Instancias de objetos a usar
private double valor_a, valor_b;
private EditText op_a, op_b;
private TextView resultado;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// Asignamos los objetos
this.op_a = (EditText) findViewById(R.id.op_a);
this.op_b = (EditText) findViewById(R.id.op_b);
this.resultado = (TextView) findViewById(R.id.resultado);
}
public void cSumar(View view) {
if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) {
this.valor_a = Double.parseDouble(this.op_a.getText().toString());
this.valor_b = Double.parseDouble(this.op_b.getText().toString());
this.resultado.setText(Double.toString((this.valor_a + this.valor_b)));
}
}
public void cRestar(View view) {
if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) {
this.valor_a = Double.parseDouble(this.op_a.getText().toString());
this.valor_b = Double.parseDouble(this.op_b.getText().toString());
this.resultado.setText(Double.toString((this.valor_a - this.valor_b)));
}
}
public void cMultiplicar(View view) {
if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) {
this.valor_a = Double.parseDouble(this.op_a.getText().toString());
this.valor_b = Double.parseDouble(this.op_b.getText().toString());
this.resultado.setText(Double.toString((this.valor_a * this.valor_b)));
}
}
public void cDividir(View view) {
if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) {
this.valor_a = Double.parseDouble(this.op_a.getText().toString());
this.valor_b = Double.parseDouble(this.op_b.getText().toString());
if(this.valor_b != 0) {
this.resultado.setText(Double.toString((this.valor_a / this.valor_b)));
}
else {
this.resultado.setText("Infinito");
}
}
}
}
El método onCreate se ejecuta al crear la aplicación y es donde asignamos los objetos declarados en el XML a objetos Java. Tras ello declaramos las funciones definidas en los atributos onClick de cada botón.
Por último nos quedaría ejecutarlo y probar el funcionamiento.
Conclusiones
Como hemos dicho, este ejemplo de una calculadora es un ejemplo muy sencillo pero podemos ver que con un poco de código y unas pequeñas nociones sobre Android SDK podemos sacar muchísimo provecho de nuestros conocimientos sobre Java.
Comentarios