Spring - Primera Aplicación

Lo primero que vamos a hacer es descargar eclipse, si no los tenemos ya instalado, desde la misma página de spring podemos hacer esto. Podemos descargarlo aquí.

A continuación y desde eclipse vamos a la opción del menú Help -> Eclipse Markeplace, tal y como vemos en la imagen

Ahora realizamos una búsqueda para por la palabra Spring e instalamos la versión que se corresponda con nuestra versión de eclipse.

Tras esto se nos pedira que reiniciemos el eclipse y ya podemos empezar a trabajar. Creamos un nuevo proyecto del tipoSpring.

 En la siguiente pantalla vamos a seleccionamos "Simple Java".

A continuación vamos a descargarnos las librerías de spring desde la suigiente url: http://maven.springframework.org/release/org/springframework/spring.

Desde donde descargaremos la versión mas reciente.

Debemos añadir al proyecto las siguientes librerías (la parte final del nombre variará en función de la versión que se hay descargado):

• spring-aop-4.1.1.RELEASE.jar 
• spring-aspects-4.1.1.RELEASE.jar 
• spring-beans-4.1.1.RELEASE.jar 
• spring-context-4.1.1.RELEASE.jar 
• spring-context-support-4.1.1.RELEASE.jar 
• spring-core-4.1.1.RELEASE.jar 
• spring-expression-4.1.1.RELEASE.jar 
• commons-logging-1.2.jar 

 Ahora vamos a crearnos dos clases:

package com.ljlg.blog.spring;

public class HolaMundo {
   
    private String mensaje;
   
    public void setMensaje(String mensaje)
    {
        this.mensaje = mensaje;
    }
   
    public void mostrarMensaje()
    {
        System.out.println(mensaje);
    }
}

package com.ljlg.blog.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HolaMundoApp {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");      
        HolaMundo bean = (HolaMundo)context.getBean("holaMundo");       
        bean.mostrarMensaje();      
    }
}

A continuación creamos un archivo Beans.xml en la carpeta src. Este archivo es el archivo de configuración del contexto donde se definiran que objetos deben existir al cargar el mismo. En nuestro ejemplo se define un objeto del tipo HolaMundo, con el campo mensaje inicializado.

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

<bean class="com.ljlg.blog.spring.HolaMundo" id="holaMundo">
       <property name="mensaje" value="Hola mundo, esta es mi primera aplicación con Spring">
   </property>
</bean>

</beans>

Ya podemos ejecuatr nuestra primera aplicación hecha con spring.

Dibujar con Android 1

Dibujar con Android 1.

Para dibujar en la pantalla simplemente debemos sobreescribir la función onDraw del componente en el cual deseamos dibujar. 

A continuación os pongo un ejemplo. He creado una clase que extiende de la clase View, en esta como podeis ver se sobreescribe la función onDraw y en ella se dibuja un circulo de color azul sobre fondo negro en el centro del componente.

package com.ljlg.dibuja;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.util.AttributeSet;
import android.view.View;

public class DrawCircle extends View {

    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);

    public DrawCircle(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public DrawCircle(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public DrawCircle(Context context) {
        super(context);
    }

    @Override
    protected void onDraw(Canvas canvas) {

         // Calculamos el punto central del componente
        int cx = this.getWidth() / 2;
        int cy = this.getHeight() / 2;

        // Ponemos el fondo de color negro
        canvas.drawColor(Color.BLACK);

         // Dibujamos un circulo relleno de color azul
        paint.setStyle(Style.FILL_AND_STROKE);
        paint.setColor(Color.BLUE);
        canvas.drawCircle(cx, cy, 100, paint);

    }

}
 

Así pues lo único que debeis hacer es dibujar en el canvas aquello que se desee (circulos, líneas, un bitmap, texto, etc..)

En caso de que se desee que forzar la llamada a la función onDraw simplemente se debe hacer una llamada a la función invalidate().

Para añadir el componente creado simplemnete nos vamos a la actividad en la cual queremos que aparezca y lo añadirmos, tal y como se muestra a continuación

<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="com.ljlg.dibuja.MainActivity" >

 <com.ljlg.dibuja.DrawCircle
        android:id="@+id/drawView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:layout_marginLeft="1dp"
        android:layout_marginTop="1dp"/>


</RelativeLayout>

Como puede verse sólo es necesario añadir una etiqueta indicando la clase que implementa el componente. 

Las Canteras

Ahora que llega el verano y que van a empezar mis vacaciones os quiero recomendar la playa que tengo cerquita de mi casa que es la playa de Las Canteras.

Se trata de la principal playa de la ciudad de Las Palmas de Gran Canaria. Una playa de la que se puede disfrutar durante todo el año pues es muy raro que bajemos de los 20 grados en cualquier época del año.

 En la playa se pueden distinguirvarias zonas: por un lado la mayor parte de la playa está protegida por una barrera de roca natural lo que hace que casi nunca haya oleaje, cuando la marea está baja es casi como estar en una piscina. Por otro tenemos la llamada zona de la Cicer donde si hay mas corrientes y olas y mi zona preferida pues es a donde voy a despejarme haciendo surf. Si os gusta el surf además teneís la zona del Lloret, junto al auditorio que se trata de una zona de rocas donde suelen salir muy buenas olas.

La Cicer

Si lo que os gusta es caminar teneís una larga avenida que recorre todas la playa y continuá mas allá hasta el Confital, donde teneís una zona de baño tranquila aunque con bastantes corrientes y con olas para surfear que pueden llegar a ser peligrosas.

El Confital

Aquí os pongo la vista de una cámara en directo:

Y aquí un enlace a una nueva webcam en la zona de la cicer.

Android - AlarmManager

Anteriormente hemos visto un artículo en el cual se muestra como hacer que una función se ejecute cada cierto tiempo, sin embargo si lo que queremos es que el proceso se ejecute cada cierto tiempo aunque la aplicación se cierre, la manera correcta es usar la clase AlarmManager. A través de esta clase podemos añadir al servicio de alarma de Android llamadas a nuestro proceso. Lo primero que debemos hacer es crear una clase que extienda de la clase BroadcastReceiver y sobreescribir la función onReceiver con las funcionalidades que se deseen.

package com.example.alarmexample;

import java.text.SimpleDateFormat;
import java.util.Date;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.location.Location;

public class ExampleBroadcastReceiver extends BroadcastReceiver {
   
    @Override
    public void onReceive(Context context, Intent intent) {
        // Aquí lo que se quiera ejecutar
        System.out.println("*******Temporizador " + new SimpleDateFormat("HH:mm:ss").format(new Date()));      
    }
}

El segundo paso es modificar el archivo AndroidManifest.xml. De este modo registramos el Receiver.

...
       <activity
            android:name="com.example.alarmexample.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>     
       </activity>

        <!-- Registar el Receiver -->
        <receiver
            android:name="com.example.alarmexample.ExampleBroadcastReceiver"
            android:enabled="true" >
        </receiver>

Finalmente debemos añadir el código necesario para registrar la acción a ejecutarse y para pararla. Suponiendo que se han añadido dos botones a nuestra aplicación el código sería el siguiente:

package com.example.alarmexample;

import android.support.v7.app.ActionBarActivity;
import android.support.v4.app.Fragment;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.TextView;

public class MainActivity extends ActionBarActivity {
   
    private ImageButton btnStart;
   
    private ImageButton btnStop;
   
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
       
        btnStart = (ImageButton) findViewById(R.id.imageButton1);
      
        btnStart.setOnClickListener(new OnClickListener() {
             
            // Acción a ejecutar cada vez que se pulse el botón
            @Override
            public void onClick(View v) {               
                /***********************************************************/
                /***********************************************************/
                /***********************************************************/
                // Registrar el servicio cada 60 segundos
                AlarmManager am = (AlarmManager) MainActivity.this.getSystemService(ALARM_SERVICE);                              
                Intent intent = new Intent(MainActivity.this, ExampleBroadcastReceiver.class);               
                  PendingIntent pendingIntent =
                          PendingIntent.getBroadcast(MainActivity.this, 1234567,
                                  intent, PendingIntent.FLAG_UPDATE_CURRENT);               
                  // Realizar la repetición cada 60 segundos. 
                 // Con el primer parámetro estamos indicando que se continue ejecutando 
                 // aunque el dsipositivo este con la pantalla apagada.
                 // En el segundo parámetro se indica a partir de cuando comienza el scheduler,
                 // en este ejemplo es desde el momento actual
                 // El tercer parámetro indica cada cuanto tiempo.
                 // El cuarto hace referencia al receiver que se va a ejecutar.
                 am.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), 60*1000, pendingIntent);                /***********************************************************/
                /***********************************************************/
                /***********************************************************/
                               
            }
        });    
      
        btnStop = (ImageButton)findViewById(R.id.ImageButton01);
        btnStop.setOnClickListener(new OnClickListener() {
             
            // Acción a ejecutar cada vez que se pulse el botón
            @Override
            public void onClick(View v) {
                /***********************************************************/
                /***********************************************************/
                /***********************************************************/
                // Cancelación
                AlarmManager am = (AlarmManager) MainActivity.this.getSystemService(ALARM_SERVICE);
              
                Intent intent = new Intent(MainActivity.this, com.example.alarmexample.ExampleBroadcastReceiver.class);               
                PendingIntent pendingIntent =
                      PendingIntent.getBroadcast(MainActivity.this, 1234567,
                                intent, PendingIntent.FLAG_UPDATE_CURRENT);               
                am.cancel(pendingIntent);
                /***********************************************************/
                /***********************************************************/
                /***********************************************************/
            }
        });          
    }
}

Android - Planificador de tareas (scheduler)

Para crear una aplicación que se ejecute cada cierto tiempo en Android podemos hacerlo de dos modos diferentes, mediante el uso de timers o mediante el uso de  la clase ScheduledThreadPoolExecutor. En este artículo vamos a usar la clase ScheduledThreadPoolExecutor.

La clase ScheduledThreadPoolExecutor se trata de una implementación de un pool de hilos de ejecución de java.

Para instanciar una un pool de hilos con un número n de hilos podemos usar la clase java.util.concurrent.Executors, que mediante la función newScheduledThreadPool(n) nos retornará un pool con el número de hilos requeridos. Para nuestro ejemplo vamos a pedir un único hilo:

private ScheduledThreadPoolExecutor sch = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1);

Otra clase que es importante y que vamos a usar es ScheduledFuture. Esta clase nos permite controlar la acción a ejecutar de modo que en cualquier momento podamos cancelar el scheduler.

        // Definir que una tarea (una instancia del tipo Runnable) se ejecute cada 10 segundos.
        periodicFuture = sch.scheduleAtFixedRate(tarea, 0, 10,  TimeUnit.SECONDS);

Para cancelar la tarea sólo es necesario usar la función cancel de la clase ScheduledFuture.

       periodicFuture.cancel(false);

A continuación  veamos todo el código junto de modo tenemos una clase que cada 10 segundos ejecutará un System.out

package com.ljlg.blogscheduler;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class MySchedule {
    private ScheduledThreadPoolExecutor sch = (ScheduledThreadPoolExecutor) Executors
            .newScheduledThreadPool(1);

    private ScheduledFuture<?> periodicFuture;
  
    public void start() {
        // Tarea que queremos ejecutar
        Runnable tarea = new Runnable() {
            @Override
            public void run() {
                // Tú código aquí
                System.out.println("Probando");
            }
        };

        // Indicar cuando se ejecuta la próxima ejección
        periodicFuture = sch.scheduleAtFixedRate(tarea, 0, 10,
                TimeUnit.SECONDS);
    }

    public void stop() {
        periodicFuture.cancel(false);
    }
}

Finalmente sólo será necesario que instanciemos nuestra clase desde nuestro programa. Por ejemplo si tenemos un programa con un botón de comenzar y otro de parar tendríamos algo como lo siguiente:

public class MainActivity extends ActionBarActivity {
   
    private Button btnStart;
   
    private Button btnStop;
   
    MySchedule sd = new MySchedule();

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

        btnStart = (Button) findViewById(R.id.button1);
       
        btnStart.setOnClickListener(new OnClickListener() {
              
            // Acción a ejecutar cada vez que se pulse el botón
            @Override
            public void onClick(View v) {
                sd.start();           
            }
        });    
       
        btnStop = (Button)findViewById(R.id.button2);
        btnStop.setOnClickListener(new OnClickListener() {
              
            // Acción a ejecutar cada vez que se pulse el botón
            @Override
            public void onClick(View v) {
                sd.stop();           
            }
        });    
       
    }
 .........
}

Android - Bases de Datos - SQLite

Cuando trabajamos con Android normalmente usaremos como base de datos SQLite. Para ello usaremos las clases incluidas con las librerías de Android del paquete android.database.sqlite.

Lo primero que tenemos que hacer es crear un clase que extenderá de la clase SQLiteOpenHelper.En esta clase debemos sobreescribir los métodos onCreate y onUpdate. Estos dos métodos se van a ejecutar cuando se crea la base de datos y cuando se actualiza.

A continuación tenemos un ejemplo en el cual se crea una tabla de usuarios y se inserta un usuario al crear la base de datos.

package com.ljlg.programandoblog;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;

public class DBHelper extends SQLiteOpenHelper {


    private static final String DATABASE_CREATE = "create table usuarios (" +
            "id integer primary key autoincrement, login text not null," +
            "password text not null);";
   
    public DBHelper(Context context, String name, CursorFactory factory,
            int version) {
        super(context, name, factory, version);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // Aquí generamos las tablas necesarias      
        db.execSQL(DATABASE_CREATE);
        db.execSQL("INSERT INTO usuarios (login, password) values ('usr1', 'pwd1');");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }   
}

Una vez que tenemos la clase creada veamos como usarla.

// Instanciamos la clase creada con anterioridad
DBHelper helper = new DBHelper(this, "blogDatabase", null, 1);      
// Recuperamos una instancia de la clase SQLiteDatabaseque nos va servir para operar sobre la base de datos
SQLiteDatabase db = helper.getReadableDatabase();

Para realizar consultas podemos realizarlas con la función rawQuery y pasando una sentencia sql o mediante la función query indicando la tabla, los campos y el filtro a aplicar.


rawQuery sin parámetros:

Cursor result = db.rawQuery(" SELECT id, login, password FROM Usuarios", null);

rawQuery con parámetros:

String[] parametros = new String[] {"usr1"};
Cursor result = db.rawQuery(" SELECT id, login, password FROM Usuarios where login = ?", parametros);

query con parámetros: 

String[] campos = new String[] {"id", "login", "password"};
String[] parametros = new String[] {"usr1"};        
Cursor result = db.query("Usuarios", campos, "login=?", parametros, null, null, null);

A continuación vemos como recorrer los resultados

while (result.moveToNext()) {
  Long id = result.getLong(0);
  String login= result.getString(1);
  String password = result.getString(2);
  System.out.println("[" + id + "][" + login + "][" + password + "]");
 }      

Android - Primeros Pasos - Mostrando listados 2

En el artículo anterior vimos como usar el componente ListView. Sin embargo sólo mostrabamos en cada elemento un string, vamos a ver como mostrar item mas complejos.

Para el ejemplo vamos a crear una lista que muestre fichas de personas con el nombre y la foto de la persona.

Lo primero es crear un layout en la carpeta res/layout, ya sea mediante el asistente de eclipse o creando un archivo xml con el código correspondiente. Este layout será el que indicará que elementos y como se va a mostrar cada uno de los items de la lista.

Vamos a añadir al layout dos elementos un ImageView para mostrar la foto y un TextView para el nombre de la persona.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal" >

    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="wrap_content"
        android:layout_height="94dp"
        android:layout_weight="0.80"
        android:src="@drawable/ic_launcher" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="214dp"
        android:layout_height="46dp"
        android:text="Medium Text"
        android:textAppearance="?android:attr/textAppearanceMedium" />

</LinearLayout>

Ahora vamos a crear dos clases, una que representa al objeto persona y otra que extenderá de la clase ArrayAdapter y que se va a encargar de generar cada uno de los items que se van a mostrar en el ListView.

Clase Persona:

package com.ljlg.programandoblog;

import android.graphics.Bitmap;

public class Persona {   
    private String nombre;   
    private Bitmap foto;
  
    public Persona(String nombre, Bitmap foto)
    {
        this.nombre = nombre;
        this.foto = foto;       
    }
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public Bitmap getFoto() {
        return foto;
    }
    public void setFoto(Bitmap foto) {
        this.foto = foto;
    }
}

Clase PersonaAdapter

package com.ljlg.programandoblog;

import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;


public class PersonaAdapter extends ArrayAdapter<Persona>
{
   
    Context context;
    int layoutResourceId;
    private List<Persona> datos;


    public PersonaAdapter(Context context, int layoutResourceId, List<Persona> datos) {
        super(context, layoutResourceId, datos);
        this.context = context;
        this.layoutResourceId = layoutResourceId;
        this.datos = datos;
    }
   
   
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
       
        View row = convertView;
       
        if (row == null) {
            // Si la fila que se está mostrando no ha sido creada con anterioridad
            LayoutInflater inflater = (LayoutInflater) getContext()
                    .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            row = inflater.inflate(R.layout.persona, null);
        }
       
        Persona persona = datos.get(position);
       
        if (persona != null)
        {
            // rellenamos
            TextView nombre = (TextView) row
                    .findViewById(R.id.textView1);
            nombre.setText(persona.getNombre());
           
            ImageView foto = (ImageView) row.findViewById(R.id.imageView1);           
            foto.setImageBitmap(persona.getFoto());
        }       
        return row;       
    }
}

Finalmente sólo tendremos que hacer la craga de los valores en nuetra actividad de manera similar a como se vió en el artículo anterior:

package com.ljlg.programandoblog;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ListView;

public class MainActivity extends Activity {

    ListView listView;

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

        // listView definido en el layout
        listView = (ListView) findViewById(R.id.listView1);

        List<Persona> valores = new ArrayList<Persona>();

        // Cargar la lista de personas
        Bitmap foto = cargarFoto();
        valores.add(new Persona("Luis", foto));
        valores.add(new Persona("Juan", foto));

        // Adaptador
        PersonaAdapter adaptador = new PersonaAdapter(this, R.layout.persona,
                valores);

        // Asignar el adaptador al listview
        listView.setAdapter(adaptador);

    }

    private Bitmap cargarFoto() {
        try {
            // Para el ejemplo cargamos una foto desde la carpeta assets
            InputStream archivo = getAssets().open("foto.png");
            Bitmap bitmap = BitmapFactory.decodeStream(archivo);
            return bitmap;
        } catch (IOException e1) {

            e1.printStackTrace();
        }
        return null;
    }

}

Android - Primeros Pasos - Mostrando listados

Para mostrar una lista en nuestra aplicación Android debemos usar el componente ListView.

Lo primero que debemos hacer es añadir  un elemento ListView al layout donde se desea que aparezca el listado. Si estamos trabajando con el editor gráfico de eclipse podemos encontrar el componente en el apartado Composite de la paleta, tal y como se ve en la siguiente imagen.

En código nuestro layout quedará algo como lo siguiente:

<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" >

    <ListView
        android:id="@+id/listView1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:layout_alignParentTop="true" >

    </ListView>
</RelativeLayout>

Ahora lo siguiente es añadir contenido al componente, el código sería el siguiente:

    ListView listView;

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

        // listView definido en el layout
        listView = (ListView) findViewById(R.id.listView1);

        // Definir lista de valores a mostrar
        String[] valores = new String[] { "Android - Primeros Pasos",
                "Android - Depurando", "Android - Botones",
                "Android - Layouts", "Android - ListView" };

        // Adaptador
        ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this,
                android.R.layout.simple_list_item_1, android.R.id.text1,
                valores);

        // Asignar el adaptador al listview
        listView.setAdapter(adaptador);
      
        // Añadir evento
        addOnClickView();

    }

    private void addOnClickView() {
        listView.setOnItemClickListener( new OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> adview, View v,
                    int posicion, long id) {
                // Mostrar texto
                Toast.makeText(
                        getApplicationContext(),
                        "Valor :"
                                + (String) listView.getItemAtPosition(posicion),
                        Toast.LENGTH_LONG).show();
            }});
    }

El código es bastante sencillo, aunque es necesario explicar que es el adaptador y cuáles son los parámetros que se le pasan. El adaptador se encarga de pasar a la lista cada una de la filas con el formato indicado en un layout (en este caso se trata de un layout ya predefinido android.R.layout.simple_list_item_1). Podemos crear nuestro propio adaptador, que muestre varios elementos por fila, por ejemplo podríamos tener un adaptador que en cada fila mostrará los datos de una persona, incluyendo su foto, su nombre, etc. Como veremos en un futuro artículo que añadiré.

Para este ejemplo se ha usado un adaptador ya existe que permite mostrar una lista de valores. A su constructor se le pasan los siguientes parámetros:

• Context.
• Layout a aplicar para mostrar cada fila.
• Lista de valores.

Con esto ya podemos mostrar nuestra lista. Ahora fijémonos en la función addOnClickView. En esta función se está registrando un escuchador sobre los ítems del listView de modo que cuando se pulse sobre uno de ellos podremos acceder a la información del mismo y realizar el tratamiento que queramos, para el ejemplo se muestra un mensaje.

Android - Primeros Pasos - Moviéndonos entre pantallas

Cada pantalla está asociada a una Actividad, así pues cada vez que creemos una nueva pantalla debemos crear una nueva actividad, esto lo podemos hacer a través del asistente de eclipse.

Cuando se crea una actividad en nuestro proyecto se llevan a cabo las siguientes modificaciones:

• Se crea una clase java asociada a la actividad.
• Se crea el correspondiente archivo de definición layout en res/layout.
• Se añade el nombre de la pantalla en el archivo res/values/strings.xml.
• Se modifica el archivo AndroidManifest.xml quedando registrada la nueva actividad.

En el manifiesto aparecerá algo similar a lo siguiente:

         <activity
            android:name="com.ljlg.programandoblog.Nueva"
            android:label="@string/title_activity_nueva"
            android:parentActivityName="com.ljlg.programandoblog.MainActivity" >
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value="com.ljlg.programandoblog.MainActivity" />
        </activity>

Una vez que tenemos nuestra nueva actividad definidad, para cargarla usaremos la clase Intents. Esta clase nos proporciona un mecanismo para invocar componentes.

Ya hemos visto como añadir acciones a los botones. Así pues vamos a añadir la carga de una nueva pantalla al pulsar un botón. Para ello vamos a añadir el siguiente código al listener asociado al botón.

        button.setOnClickListener(new OnClickListener() {          
            @Override
            public void onClick(View v) {               
                Intent intent = new Intent(v.getContext(), SegundaActivity.class);
                startActivity(intent);
            }
        });

Con esto se nos cargará la nueva pantalla al pulsar sobre el botón.
Ahora vamos a añadir en la nueva actividad un botón para volver a la pantalla desde la que se realizó la llamada. Para ello el código de la clase asociada a nuestra nueva actividad será el siguiente:

package com.ljlg.programandoblog;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class SegundaActivity extends Activity {

    Button button;
   
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_segunda);
        addListenerButtonVolver();
    }

    private void addListenerButtonVolver() {               button = (Button) findViewById(R.id.button1);              
        button.setOnClickListener(new OnClickListener() {           
            @Override
            public void onClick(View v) {               
                finish();                              
            }
        });       
    }   
}

Como vemos tan sólo es necesario añadir al listener del botón la llamada a la función finish().