Conectar Oracle 11g con Android mediante Servicio Web con PHP + CodeIgniter en lista personalizada

Para seguir el siguiente tutorial es necesario poseer conocimientos basicos de programacion, ademas de conocimientos basicos en el framework MVC CodeIgniter para PHP y nociones basicas del motor de base de datos Oracle Database 11g XE.

Los siguientes enlaces pueden ayudarte a conocer un poco sobre lo antes mencionado:

1-) http://ellislab.com/codeigniter/user-guide/

2-) http://docs.oracle.com/cd/E29505_01/server.1111/e25789/intro.htm

Continuemos..

Lo primero que haremos es crear un nuevo sitio web para ello necesitaremos tener instalado LAMP en Linux O XAM, WAMP en Windows.

Yo me ayudare en este caso de Dreamweaver ustedes pueden hacerlo con la IDE que crean conveniente, para ello la estructura quedara asi de acuerdo a los directorios de CodeIgniter.

En el directorio application/config/  se encuentra el archivo database.php que es donde configuraremos 

la conexion a nuestra base de datos Oracle 11g Express Edition (Previamente instalada).

Las lineas de especial cuidado son las siguientes:

$tnsname="(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))

        (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = XE)))";

En la anterior linea se define una constante que contiene la descripcion general de una conexion a Oracle.

$db['default']['dbdriver'] = 'oci8';

"oci8" es el valor por defecto que utiliza CodeIgniter con las conexiones a Oracle Database.

En mi caso habilitare el servicio de OracleXE, por razones de rendimiento siempre es preferible manejar dicho servicio configurado como "manual" para no mermar el rendimiento de nuestro equipo.

Con el servicio corriendo procedere a utilizar uno de los esquemas por defecto de Oracle (Esquema HR) 

creamos una conexion y procedemos a ejecutar una consulta a la tabla "employee" la cual posteriormente mostraremos en una lista desplegable en Android a traves del consumo de un Servicio Web en PHP(CodeIgniter).

Como pueden observar ejecutamos una consulta sencilla mostrando 2 resultados empleado y salario lo cual procederemos a utilizarlo con CodeIgniter.

Ponemos a punto nuestro servidor e iniciamos el servicio de Apache2 en Linux o WAMP, XAMP en Windows.

En mi caso utilizare WAMP Server.

Volvemos a nuestro proyecto CodeIgniter y crearemos el respectivo modelo y controlador.

Con nuestro modelo y controlador listos nos dirigimos a nuestro navegador web en mi caso Google Chrome

y buscamos la siguiente URL: http://IP_DEL_SERVIDOR/NOMBRE_SITIO_WEB/CONTROLADOR

en mi caso cumplo el estandard de la siguiente manera: http://192.168.1.2/codeigniter_oracle/empleados

Si hemos configurado bien CodeIgniter, y tenemos a punto nuestro servicio de Oracle y WAMP deberiamos observar la respuesta de nuestro servicio en formato JSON, asi.

Iniciaremos Eclipse y procederemos a crear un nuevo proyecto Android Application.

Crearemos 5 clases.

Iremos una a una, veremos como primer punto la clase URL, esta clase sera la encargada de gestionar las URL de peticion a servicios web en el caso que debamos consumir mas de un servicio.

La clase Conexion tendra simplemente un metodo que hara una peticion POST a nuestro servicio web.

La clase convertidorJSON es una clase utilitaria que la adjuntare en el codigo fuente.

En la clase AdaptadorEmpleados haremos una herencia a ArrayAdapter y utilizaremos el arreglo que parsearemos en nuestra consulta al servicio.

Nuestra actividad principal esta especificada en el codigo fuente pero en ella simplemente crearemos una clase que heredara de Asyntask para ejecutar en segundo plano la consulta a nuestro servicio web 

y parsearemos ademas los controles Android.

Nuestras vistas se conforman del activity_main.xml y un layout alternativo llamado item donde colocaremos

el DISEÑO de nuestra lista.

Si todo a salido correcto corremos nuestro emulador y veremos el resultado final de nuestro trabajo.

Adjunto enlace para descargar el codigo Fuente, espero haber aportado con este tutorial a todos aquellos

que desean adentrarse al desarrollo Android con manejo de servicios web y bases de datos.

https://mega.co.nz/#!tt0WEAaY!BCGiIKem-DhLh9WuRef64ef25muBSIQIqTsaglfZ0Io

Volley libreria de Google para hacer mas faciles y rapidas nuestras aplicaciones Android que descargan contenido en red.

Que es Volley?
Es una libreria que podremos integrar a nuestro proyecto Android para hacer mas faciles y rapidas las operaciones de red como: Descarga de imagenes, peticiones o envio de datos entre cliente y servidor.

Para una mejor percepcion dejo el enlace a la explicacion oficial de los ingenieros de Google:
http://www.youtube.com/watch?v=yhv8l9F44qo

Aqui una traduccion de Google translate sobre las ventajas de Volley al aplicarla en nuestros proyectos:

-Volley automáticamente programa todas las solicitudes de red. Significa que Volley se hace cargo de toda ls solicitudes de red que su aplicación ejecuta para ir a buscar la respuesta o la imagen de la web.
-Volley ofrece disco transparente y el almacenamiento en caché de memoria.
-Volley ofrece una potente API solicitud de cancelación. Esto significa que usted puede cancelar la solicitud o puede establecer bloques o ámbitos de peticiones para cancelar.
-Volley proporciona potentes capacidades de personalización.
-Volley proporciona herramientas de depuración y rastreo.

COMO UTILIZAR VOLLEY:
PASO 1: Clonar el proyecto de Github
Direccion: https://android.googlesource.com/platform/frameworks/volley.

Si no sabes como clonar un proyecto de Github te dejo el enlace hacia un tutorial.
 http://www.technotalkative.com/android-import-android-projects-from-git/

Si no quieres clonarla puedes descargarla de aqui:

 https://mega.co.nz/#!Rpd1TZBJ!NsGKxVL3klmXUl-9qX2SVkxI54do1P_-ub3vjqG9kLk


PROYECTO EJEMPLO:

Lo primero, dentro de Volley se encuentran dos clases java importantes:
1. Request queue: Si tu interés es utilizar Volley para el envío de solicitudes a la red, puedes hacer una cola de peticiones en demanda si lo deseas, pero por lo general, la libreria las crea desde el principio, en el momento de arranque, y mantenerlo alrededor y utilizarlo como Singleton(instancia unica).
2. Request: Contiene todos los detalles necesarios para hacer llamadas de API Web. Por ejemplo: el método a utilizar (GET o POST), datos de la solicitud, escuchadores(listeners), escuchador de errores(error listeners).

DESARROLLO:
A-) Importar Volley en nuestro espacio de trabajo de Eclipse.

Creamos un nuevo proyecto del tipo aplicacion Android:

Recuerda que en el paso anterior le das el nombre a tu proyecto el nombre de paquete(Package Name) con el cual sera reconocido en Google Play(Yo recomiendo utilizar "com.nombretuproyecto.nombretuproyectoapp" pero puedes llamarlo como quieras) luego los SDK minimos Target, compilacion y el Tema de tu App.

En mi caso le puse de nombre "EjemploVolley" al proyecto y al paquete "com.ejemplo.volley" como puedes ver a continuacion:

Importamos Volley haciendo clic derecho sobre la carpeta de proyecto luego "propiedades/android/"

Recuerda agregar al Manifest de tu aplicacion los permisos de Internet:
<uses-permission android:name="android.permission.INTERNET"/>

En nuestro proyecto veremos como Volley trabaja en la peticion de imagenes para ello comenzaremos creando una clase java la cual nos servira para el tratamiento de la cache.

Luego crearemos una clase llamada ConvertidorJSON que nos servira para hacer peticiones de url de imagenes via JSON.
package com.ejemplo.volley;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

public class ConvertidorJSON {
static InputStream is = null;
    static JSONObject jObj = null;
    static String json = "";
   public ConvertidorJSON()
   {
 
   }
   public JSONObject getJSONFromUrl(String url) {
  
       
       try {
          
           DefaultHttpClient httpClient = new DefaultHttpClient();
           HttpPost httpPost = new HttpPost(url);

           HttpResponse httpResponse = httpClient.execute(httpPost);
           HttpEntity httpEntity = httpResponse.getEntity();
           is = httpEntity.getContent();           

       } catch (UnsupportedEncodingException e) {
           e.printStackTrace();
       } catch (ClientProtocolException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
        
       try {
           BufferedReader reader = new BufferedReader(new InputStreamReader(
                   is, "UTF-8"), 8);
           StringBuilder sb = new StringBuilder();
           String line = null;
           while ((line = reader.readLine()) != null) {
               sb.append(line + "\n");
           }
           is.close();
           json = sb.toString();
       } catch (Exception e) {
           Log.e("Buffer Error", "Error converting result " + e.toString());
       }

       // try parse the string to a JSON object
       try {
           jObj = new JSONObject(json);
       } catch (JSONException e) {
           Log.e("JSON Parser", "Error parsing data " + e.toString());
       }

       // return JSON String
       return jObj;

   }
}

Luego creamos el codigo de nuestra vista XML. En el cual tendremos ademas de un control ImageView tradicional uno referente a la libreria Volley que es el NetworkImageView.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="150dp"
        android:layout_height="170dp"
        android:layout_centerHorizontal="true"
        android:src="@drawable/ic_launcher" />

    <com.android.volley.toolbox.NetworkImageView
        android:id="@+id/networkImageView"
        android:layout_width="150dp"
        android:layout_height="170dp"
        android:layout_below="@+id/imageView1"
        android:layout_centerHorizontal="true"
        android:src="@drawable/ic_launcher" />

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:orientation="vertical" >

      
    </LinearLayout>

</RelativeLayout>

El codigo anterior deberia generarnos la siguiente vista grafica.

La siguiente codificacion corresponde al codigo de tu activity en este ejemplo cargaremos dos imagenes una por medio de URL y la otra a travez de la lectura de un JSON generado por un Servicio Web en PHP.

package com.ejemplo.volley;

import org.json.JSONException;
import org.json.JSONObject;
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.ImageView;
import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley;
import com.technotalkative.volleyimageloading.R;

public class MainActivity extends Activity {

private RequestQueue mRequestQueue;
private ImageLoader imageLoader;
private String img1, img2;
private ImageView imageView;
private NetworkImageView networkImageView;
String urlimg1, urlimg2;
private static final String IMAGE_URL = "http://developer.android.com/images/gp-device.png";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

networkImageView = (NetworkImageView) findViewById(R.id.networkImageView);
imageView = (ImageView) findViewById(R.id.imageView1);
new MiTarea()
.execute("http://miweb/ws/webservice.php");
mRequestQueue = Volley.newRequestQueue(this);
imageLoader = new ImageLoader(mRequestQueue, new BitmapLruCache(
BitmapLruCache.getDefaultLruCacheSize()));

}

 

private class MiTarea extends AsyncTask<String, Float, Integer> {
private static final String im1= "nombreimg1";
private static final String im2= "nombreimg2";

protected void onPreExecute() {
// antes de comenzar
}

protected Integer doInBackground(String... params) {

String url = params[0];
try {

try {
ConvertidorJSON jp = new ConvertidorJSON();
JSONObject json = jp.getJSONFromUrl(url);
img1 = json.getJSONArray(im1).getString(0);
img2 = json.getJSONArray(im2).getString(0);

} catch (JSONException e) {
e.printStackTrace();
}
} catch (Exception e) {
e.printStackTrace();
}
String urlbase = "http://miweb/ubicaciondeimagenes/";

// urls para imagenes
urlimg1 = urlbase + "directorio/" + img1;// url para imagen 1
urlimg2 = urlbase + "directorio/" + img2; // url para imagen2

return null;

}

protected void onProgressUpdate(Float... valores) {

}

protected void onPostExecute(Integer bytes) {
networkImageView.setImageUrl(urlimg1, imageLoader);
imageLoader.get(urlimg1, ImageLoader.getImageListener(imageView,
R.drawable.ic_launcher, R.drawable.ic_error));
}
}

}

Podras observar que para la descarga de imagenes se hizo en un hilo secundario gracias a la potencia de la clase abstracta Asyntask http://developer.android.com/reference/android/os/AsyncTask.html

de Android, toda accion de descarga de contenido en red es preferible hacerlo en segundo plano a traves de un nuevo hilo de ejecucion.

A continuacion podemos ver la ejecucion de nuestro proyecto y la rapidez con la cual descarga las imagenes inclusive en una conexion a internet no muy rapida, yo utilizo Genymotion como emulador es un poco mas rapido que los emuladores del SDK de Android. http://www.genymotion.com/

Puedes por ejemplo programar un boton y mediante el descargar las imagenes para que veas como Volley realiza su trabajo a travez del LogCat.

Esto ha sido todo en el post, espero haber aportado un poco al conocimiento general, saludos.

(Disculpen si en la ortografia faltaron acentos XD y tambien si el formato no es tan adecuado) cualquier duda pueden dejar su comentario

Recuerda que este blog sobrevive gracias a tus donaciones o clics en los anuncios, ya sabes como apoyar este recurso para continuar subiendo mas tutoriales. Gracias.

Conectar java utilizando netbeans IDE a Oracle 11g

En esta ocasión comparto con ustedes un sencillo, pero útil tutorial sobre los procesos que deben efectuarse para establecer una conexión entre JAVA y ORACLE.

En la siguiente tabla encontraras los recursos necesarios que deberas descargar e instalar en tu ordenador para poder seguir el tutorial.

Software o recursos	Versiones requeridas
NetBeans IDE	7.0, 7.1, 7.2, Java EE bundle
Java Development Kit (JDK)	Version 6 or 7
Oracle Database XE	11 g Express Edition
Oracle JDBC driver	ojdbc6.jar

Ahora que ya estas listo, pasaremos a los pasos necesarios para obtener una conexion satisfactoria al gestor de bases de datos Oracle (En este caso utilizaremos Netbeans IDE 7.1.2).

La practica consistirá en conectarnos a una instancia local de Oracle, pero perfectamente es aplicable para conexiones con instancias remotas.

Existen 2 categorías de drivers (conectores) para establecer una conexión con Oracle los cuales son: OCI y JDBC Thin, en nuestro caso utilizaremos la segunda opción porque en la mayoria de casos es suficiente para un uso eficiente de nuestra base de datos.

ESTABLECIENDO CONEXION A BASE DE DATOS ORACLE.

1-) Inicia el servicio de Oracle en tu computador.
2- Inicia Netbeans IDE
3-) Ve a la opción Window/Services en Netbeans, y selecciona "nueva conexión".

4-) Cuando te aparezca el asistente de configuración, selecciona de la lista desplegable "Oracle Thin", luego clic en "add" para agregar el driver que descargaste es decir el ojdbc6.jar luego da clic en "Next".

5-) En el panel de personalización de conexión ingresa los siguientes valores y luego has clic en "Next".

Name	Value
Driver Name	Oracle Thin (with Service ID (SID))
Host	localhost o 127.0.0.1. Nota: En el caso de una conexion remota, proporciona la IP o el nombre de Host para resolver la direccion de la maquina donde esta alojada la base de datos.
Port	1521 (default)
Service ID (SID)	XE (default SID para Oracle Database XE). Nota: Si estas conectado a una base de datos remota, solicita al administrador de base de datos el SID.
Username	Ingresa el nombre de usuario. Para el propósito de este tutorial ingresa HR (Una de las cuentas de ejemplo de Oracle).
Password	Ingresa la contraseña del usuario en este caso la contraseña de HR, tu puedes crearle una nueva clave desde Oracle*Plus u otra IDE.

6-) Haz clic en Test Connection para confirmar que la IDE esta habilitada para conectarse a la base de datos, has clic en Next y se te desplegara un mensaje confirmando la conexión.

COMPROBANDO LA CONEXIÓN DESDE UNA APLICACIÓN JAVA

Ahora comprobaremos la conexion al esquema HR de Oracle desde una aplicacion Java.

1-) Selecciona en Netbeans File/New Project/JavaAplication
2-) Le nombraremos al proyecto OracleConection
3-) Se creara la clase por defecto y el método Main que es donde ejecutaremos las instrucciones necesarias para establecer la conexión.
4-) Importaremos los paquetes "java.sql.Connection" y "java.sql.DriverManager" necesarios en este caso.
5-) Crearemos un objeto de tipo conexión "private Connection conexion;"
6-) Desarrollaremos los respectivos Getter y Setter para el objeto conexion.

 public Connection getConexion() {
        return conexion;
    }

   
    public void setConexion(Connection conexion) {
        this.conexion = conexion;
    }

7-) Luego crearemos un método del tipo OracleConection. En dicho método utilizaremos la dirección que tenemos especificada en la conexión que realizamos con anterioridad. Con una condición verificaremos si la conexión es diferente de nulo es porque hemos logrado acceder al esquema HR.


public OracleConection Conectar()
    {
        try{
        Class.forName("oracle.jdbc.OracleDriver");
        String BaseDeDatos = "jdbc:oracle:thin:@localhost:1521:XE";
        conexion= DriverManager.getConnection(BaseDeDatos,"HR","HR");
        if(conexion!=null)
        {
        System.out.println("Conexion exitosa a esquema HR");
        }
        else{System.out.println("Conexion fallida");}
        }
        catch(Exception e)
        {e.printStackTrace();}
     
    return this;
    }

8-) Para finalizar en el metodo MAIN crearemos un objeto para invocar al metodo conectar.


public static void main(String[] args) {
    OracleConection conexion = new OracleConection();
    conexion.Conectar();
}


9-) Le damos clic derecho "Run" a nuestro proyecto y debería enviarnos el mensaje respectivo como en la siguiente imagen.

Fácilmente podemos adaptar la lógica para conectarnos a una aplicación Swing o JSP con lo practicado en este tutorial, recuerda que este blog sobrevive gracias a tus donaciones o clics en los anuncios, ya sabes como apoyar este recurso para continuar subiendo mas tutoriales. Gracias.

controles básicos en Android

Este tutorial se preparó para todas aquellas personas que deseen iniciarse en la programación de aplicaciones para dispositivos móviles, en este caso para dispositivos android, cabe aclarar que en esta ocasión será en SO Windows 7 pero el proceso de instalación de los componentes necesarios es muy similar en plataformas Linux.

Que necesitaremos para este ejemplo básico de android:

1-      Descargar Eclipse IDE desde http://www.eclipse.org/downloads/ (recomiendo la versión “eclipse for mobile developers” pero queda a su preferencia J

2-      El SDK de android en este caso descargaremos el de la parte “USE AN EXISTING IDE”.

3-      Luego en la opción Window de eclipse dan clic en la opción “preferences” y buscan el PATH de instalación del SDK que por lo general se encuentra en C:\Users\TUUsuario\AppData\Local\Android\android-sdk.

4-      En la misma opción Window de Eclipse configuramos nuestras versiones del SDK que utilizaremos y también los dispositivos virtuales con las opciones “Android SDK Manager” y “AVD Manager”.

5-      Listo tenemos lo necesario para iniciar el tutorial.

   Utilizando controles básicos aplicación “MiEdad”

   La finalidad como se mencionó al inicio es ejemplificar el uso de algunos controles básicos de android en este caso en una sencilla aplicación para el cálculo de la edad, algoritmo sencillo pero de gran utilidad para nuestro objetivo.

      A-) Iniciaremos creando un nuevo proyecto haciendo clic en File/New/Other y luego seleccionando la opción Android Aplication Project.

      En la siguiente opción seleccionamos el nombre de nuestra aplicación siempre con inicial mayúscula en este caso le llamaremos “MiAge” y seleccionare la API 2.2 de Android. Damos clic en next y luego pasaremos a definir el icono de nuestra aplicacion el cual podemos perfectamente crear uno personalizado, en nuestro caso utilizaremos el que viene por defecto.

      En las siguientes opciones pasaremos a configurar la actividad principal de nuestra aplicación en este caso también le dejaremos el nombre por defecto “MainActivity” pero perfectamente puedes renombrarle con el que desees, si creas nuevas actividades en el proyecto recuerda siempre agregarlas al Android Manifest para que no cause ningún conflicto en la aplicación.

      Listo ya tenemos nuestra aplicación creada, ahora procederemos a demostrar la utilización de los controles básicos de android como el TextView, el EditText y el Button, cabe aclarar que estos controles siempre se colocaran dentro de un Layout o como yo les digo “contenedor” existen diferentes layout el RelativeLayout, LinearLayout, TableLayout entre otros que probablemente mencionaremos en otro post.

      Eliminaremos el TextView que viene por defecto en nuestra aplicación ya sea desde el editor gráfico o desde el editor XML eliminando todo el código entre las etiquetas <TextView></TextView> junto con dichas etiquetas por supuesto, y luego desde la paleta de herramientas agregaremos:

-          2 TextView

-          2 Button

-          2 EditText (hay con características distintas en este caso elegiremos 1 numerico y uno de tipo First Name Last Name)

      Ahora renombraremos los controles esto lo haremos desde el archivo strings.xml que se encuentra en el directorio res/values de nuestro proyecto, es preferible renombrar los componentes desde acá porque las aplicaciones de calidad requieren múltiples lenguajes, de esta manera al guardar los valores tipo string en dicho archivo se volvería mucho más fácil traducir nuestra aplicación a distintos idiomas.

l     En el archivo activity_main.xml colocamos la referencia con @string/valor a cada uno de los controles que deseamos cambiar el nombre luego el aspecto de nuestra vista debería cambiar con los nuevos nombres por cada control modificado.

2   El método onCreate() es invocado cuando la actividad se inicia, allí crearemos los objetos necesarios a partir de las vistas pertenecientes a los controles básicos que utilizamos en este ejemplo, luego en el método sobrecargado OnClick de la clase anónima OnclickListener del método setOnClickListener del objeto perteneciente al botón “calcular” invocaremos el método que llamaremos Edad() que no es mas que un método que devuelve un objeto derivado de la clase AlertDialog que mostraremos mediante el método show() perteneciente al mismo.

La funcionalidad es sencilla simplemente restaremos el año actual (obtenido gracias a la clase Calendar) al año de nacimiento del usuario, pediremos como datos de entrada el nombre, apellido y año de nacimiento, mostrando la edad en una alerta.

A continuacion el codigo que debe ir en la clase MainActivity.java

package com.ejemplo.miage;

import java.util.Calendar;

import android.os.Bundle;

import android.app.Activity;

import android.app.AlertDialog;

import android.app.Dialog;

import android.content.DialogInterface;

import android.view.Menu;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

import android.widget.EditText;

public class MainActivity extends Activity {

EditText txt1;

EditText txt2;

Button botoncalc;

int anioactual;

@Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

       txt1=(EditText)findViewById(R.id.editText1);

         txt2=(EditText)findViewById(R.id.editText2);

       botoncalc=(Button)findViewById(R.id.button1);

       botoncalc.setOnClickListener(new OnClickListener() {

@Override

public void onClick(View arg0) {

// TODO Auto-generated method stub

  

   Edad().show();

}   

       });

    }

 private Dialog Edad()

 {

// anionac=Integer.parseInt(txt2.getText().toString());

// edad= anioactual-anionac;

Calendar fecha= Calendar.getInstance();

 

      anioactual=fecha.get(Calendar.YEAR);

 int anionac=Integer.parseInt(txt2.getText().toString()); 

  int edad= anioactual - anionac;

     AlertDialog.Builder mensaje = new AlertDialog.Builder(this);

      mensaje.setTitle("Estimado "+txt1.getText());

     mensaje.setMessage("Su edad es: "+edad);

    mensaje.setPositiveButton("OK", new DialogInterface.OnClickListener() {

      public void onClick(DialogInterface dialog, int which) {

         // here you can add functions

      dialog.cancel();

      }

    });

    mensaje.setIcon(R.drawable.ic_launcher);

     return mensaje.create();

 }

    

    @Override

    public boolean onCreateOptionsMenu(Menu menu) {

        getMenuInflater().inflate(R.menu.activity_main, menu);

        return true;

    }

}

3- Ahora procederemos a probar nuestra aplicación en el emulador

4- Y por fortuna hemos finalizado este ejemplo, esperando halla sido de gran ayuda para quienes quieran comenzar a descubrir el mundo del desarrollo de aplicaciones para dispositivos android