Para aquellos que les gusta programar en Java en cualquier momento, aquí les dejo un tutorial sobre como programar en java en tu iPhone ó iPod Touch.

Elementos con los que se realizaron este tutorial.

• iPod Touch 4.
• JailBreak
• Cydia

Bién, vamos a instalar los componentes para poder Crear, Compilar y Ejecutar nuestros archivos .java.

Entramos a Cydia y nos vamos a la opción “Manage”, seleccionamos “Settings” y seleccionamos la opción “Developer (No Filters)”.

Seleccionamos "Settings"

Seleccionamos "Developer (No Filters)"

Ahora nos vamos a la opción “Sections” y buscamos “Java”, una vez dentro instalamos Classpath, JamVM y Jikes.

Seleccionamos "Java"

Instalamos Classpath y JamVM

Instalamos Jikes

Ahora vamos a instalar el iEdit que es el que nos va a servir para crear nuestros archivos desde el iPod/iPhone y también instalaremos MobileTerminal que es donde vamos a ejecutar nuestros programas. Abrimos el “Search” de Cydia y buscamos cada programa y los instalamos.

Programa para crear los archivos .java

Terminal para compilar y ejecutar nuestros programas

Una vez instalado Todo, vamos a entrar al iEdit para empesar a programar.

Cuando abrimos el iEdit nos posiciona en la carpeta Documents de nuestro dispositivo, vamos a crear una carpeta llamada “Java” donde crearemos nuestros programas. Para ello solo tocamos el simbolo de “+” y cuando nos pida el nombre seleccionamos la opción “Folder” que indicará que crearemos una carpeta.

Seleccionamos la opción "+"

Activamos la opción "Folder"

Carpeta "Java" Creada

Ahora seleccionamos “Java” para acceder a la carpeta y crear nuestro programa.

En esta ocación vamos a crear un programa para calcular el factorial de un número. Lo haremos en dos archivos, uno se llamará Operations.java que contendrá la función para calcular el factorial y el otro se llamará Factorial.java que será nuestro programa principal.

Para crear un archivo lo hacemos de la misma manera que creamos la carpeta, solo que activamos la opción File.

Creamos el archivo Operations.java

Seleccionamos la opción File

Seleccionamos el archivo para abrirlo

Código del archivo Operations.java

Creamos el archivo Factorial.java

Activamos la opción File

Código del archivo Factorial.java

Ya que tenemos los archivos creados vamos a compilarlos y ejecutarlos. Para ellos abrimos el programa Terminal y nos vamos a desplazar hasta la carpeta Java que creamos dentro de documents.

Nos desplazamos hasta la carpeta Java

Ahora compilamos nuestros archivos con el comando jikes archivo.java

Compilamos los archivos

Y finalmente ejecutamos el programa con el comando java archivo

Compilamos nuestro programa

Listo!!

Espero sea de grán ayuda..

Dudas, comentarios y/ó sugerencias no duden en hacerlas llegar..

Saludos!!

Hace un par de meses publiqué como Geolocalizar con C# y GoogleMaps, ahora aquí está otra alternativa para hacerlo, se trata de Java y YahooMaps.

El método es realmente simple.. Vámos a ello..

Para realizar la aplicación separé el código en cinco archivos difentes, uno por cada clase..

Clase Address: Esta clase se encagará de almacenar la dirección que querramos geolocalizar.

public class Address {
	private String address;
 
	public Address() {}
	public Address(String address){ this.address = address;	}
	public void setAddress(String address){ this.address = address;}
	public String toString(){ return this.address;}
}

Clase Coordinates: Esta clase se encargará de almacenar el nombre completo de la ciudad, la longitud y la latitud de la dirección que querramos geolocalizar.

public class Coordinates {
	private String latitude = "", longitude = "", city = "";
 
	public void setCity(String city) { this.city = city; }
	public String getCity() { return city; }
	public String getLongitude() { return longitude; }
	public void setLongitude(String longitude) { this.longitude = longitude; }
	public String getLatitude() { return latitude; }
	public void setLatitude(String latitude) { this.latitude = latitude; }
}

Clase YahooXmlReader: Cuando nosotros geolocalizamos una dirección, esta se extrae en formato XML, y se requiere cierto proceso para extraer los datos que necesitamos (Ciudad, Longitud y Latitud), en esta clase tenemos una función llamada readConfig que se encarga de analizar el código XML y extraer los datos (Ciuda, Logitud y Latitud) y almacenarlos en un objeto de tipo Coordinates.

import java.io.InputStream;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.XMLEvent;
 
public class YahooXmlReader
{
	public static Coordinates readConfig(InputStream in)
	{
		Coordinates coordinates = new Coordinates();
		try {
			XMLInputFactory inputFactory = XMLInputFactory.newInstance();
			XMLEventReader eventReader = inputFactory.createXMLEventReader(in);
 
			//Leer el XML
			while (eventReader.hasNext())
			{
				XMLEvent event = eventReader.nextEvent();
				if (event.isStartElement())
				{
					if (event.asStartElement().getName().getLocalPart() == ("City"))
					{
						event = eventReader.nextEvent();
						coordinates.setCity(event.asCharacters().getData());
						continue;
					}
					if (event.asStartElement().getName().getLocalPart() == ("Latitude"))
					{
						event = eventReader.nextEvent();
						coordinates.setLatitude(event.asCharacters().getData());
						continue;
					}
					if (event.asStartElement().getName().getLocalPart() == ("Longitude"))
					{
						event = eventReader.nextEvent();
						coordinates.setLongitude(event.asCharacters().getData());
						continue;
					}
				}
			}
		} catch (XMLStreamException e)
		{
			e.printStackTrace();
		}
		return coordinates;
	}
}

Clase Geocoder: En esta clase se hace la geolocalización, en el método geocode se pasa como parametro la dirección a geolocalizar, se extrae el código XML y se manda a llamar al método readConfig de la clase YahooXmlReader la cual regresa un objeto de tipo Coordinates ya con los datos almacenados. Tambien cuenta con un método llamado createLocation que reemplaza los espacios en blanco ” ” por simbolos de “más” (+).

import java.net.URL;
 
public class Geocoder
{
	private final static String YAHOOURL = "http://local.yahooapis.com/MapsService/V1/geocode";
 
	public Coordinates geocode(Address address)
	{
		Coordinates geocoordinates = null;
		String web = YAHOOURL + "?appid=1&location="+ createLocation(address);
		URL url;
		try
		{
			url = new URL(web);
			InputStream in = url.openStream();
			geocoordinates = YahooXmlReader.readConfig(in);
			in.close();
		} catch (MalformedURLException e)
		{
			e.printStackTrace();
		} catch (IOException e)
		{
			e.printStackTrace();
		}
		return geocoordinates;
	}
 
	private String createLocation(Address address)
	{
		String adrs=address.toString();
		if (adrs.endsWith("+"))
		{
			adrs = adrs.substring(0, adrs.length() - 1);
		}
		adrs = adrs.replace(" ", "+");
		return adrs;
	}
}

Clase jMain: Esta clase es la que contruye la pantalla principal, tiene una clase interna la cual maneja los eventos del botón, dentro de la clase managerButton está el método actionPerformed que es donde vamos a mandar a llamar nuestro métodos de geolocalización.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class jMain extends JFrame
{
	private JButton btnSearch;
	private JTextField txtSearch;
	private JTextArea txtResult;
 
	// Configurar GUI
	public jMain()
	{
		super( "Geocoding con Java y YahooMaps" );
 
		// Cbtener panel de contenido y establecer su esquema
		Container content = getContentPane();
		content.setLayout(null);
 
		// Crear botones y cajas de texto
 
		txtSearch=new JTextField();
		txtResult=new JTextArea();
		Icon quake1 = new ImageIcon( "quake1.png" );
		Icon quake2 = new ImageIcon( "quake2.png" );
		btnSearch = new JButton(" Search ", quake1 );
		btnSearch.setRolloverIcon( quake2 );
		btnSearch.setBounds(500,40,100,20);
		txtSearch.setBounds(90,40,400,20);
		txtResult.setBounds(90,70,400,100);
 
		content.add(btnSearch);
		content.add(txtSearch);
		content.add(txtResult);
 
		// Crear una instancia de la clase interna managerButton
		// a usar para el manejo de eventos de botones
 
		managerButton manager = new managerButton();
		btnSearch.addActionListener(manager);
 
		//Damos medidas y visibilidad a nuestra pantalla
		setSize(700,250);
		setVisible(true);
	}
 
	//Método principal de nuestro programa
	public static void main( String args[] )
	{
		JFrame.setDefaultLookAndFeelDecorated(true);
		JDialog.setDefaultLookAndFeelDecorated(true);
		jMain aplicacion = new jMain();
		aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
	}
 
	// Clase interna para el manejo de eventos de botón
	private class managerButton implements ActionListener
	{
		// Manejar evento de botón
		public void actionPerformed( ActionEvent event )
		{
			try{
				txtResult.setText(""); //Limpiamos la caja donde vaciaremos los resultados
 
				Geocoder geocoder = new Geocoder();
 
				//Hacemos el geocóding con la dirección establecida
				Address address = new Address(txtSearch.getText());
				Coordinates coordinates = geocoder.geocode(address);
 
				String city=coordinates.getCity();
				String longitude=coordinates.getLongitude();
				String latitude=coordinates.getLatitude();
 
				if(city!="")
				{
					//Mostramos el resultado en pantalla
					txtResult.setText("Ciudad = "+city+"\nLongitud = "+longitude+"\nLatitud = "+latitude);
				}
				else
				{
					JOptionPane.showMessageDialog(jMain.this,"No se encontró la dirección");
				}
			}catch(Exception e)
			{
				JOptionPane.showMessageDialog(jMain.this,"No se encontró la dirección");
			}
		}
	}
}

Eh aquí una muestrá de como queda la aplicación:

Pueden descargar el código de aquí:

geocoderjavayahoo.zip

Espero sea de grán ayuda!..

Dudas, comentarios, sugerencias y/ó saludos!, son bién recibidos..

Saludos!!

En el presente tutorial mostraremos como reconstruir una imagen con Processing, para eso utilizaremos una obra del gran Leonardo Da Vinci la bella Mona Lisa, sin mas que agregar comencemos.

PImage imagen; // Declaramos una variable de tipo PImage esto es para poder cargar una imagen
void setup(){
  size(375,525);
  imagen = loadImage("monalisa.jpg"); //Cargamos la imagen en nuestro caso utilizamos la Mona Lisa pero ustedes pueden ocupar la que mas le guste
  noStroke();
  rectMode(CENTER);
  background(255);
}
//Bueno aqui viene la magia.
void draw(){
  float des = (height-mouseY) / 20; // Determina el nivel de desenfoque en función de la posición vertical del mouse
  color este; // Declaramos una variable de tipo color en mi caso le puse este
  int x = int( random(154) ); //Aquí toma una posición horizontal al azar de la imagen.
  int y = int( random(240) ); //Aquí toma una posición vertical al azar de la imagen.
  este = imagen.get(  x , y ); // Toma el color del pixel elegido al azar
  fill( red(este) , green(este) , blue(este) , 100 ); // Usa ese color como relleno dándoles cierta transparencia
  stroke(este); //Usa ese mismo color en el contorno
  float lado = random(3,20); //Elige el tamaño del cuadrado a dibujar
  rect( x * 2+25 , y * 2+25, lado , lado ); //Pinta el cuadrado duplicando el tamaño del dibujo
}
void mousePressed(){
  background(255); //Pinta de Blanco
}

En el Presente tutorial mostraremos como crear un árbol en Processing, sin mas que agregar comencemos:

float ramas;
void setup()
{
  smooth();
  size(700,500);
  background(255);
  // Vamos a escoger un ángulo de 0 a 90 grados y convertir
  // Nuestra variable ramas a Radianes
  ramas= radians(30);
  // Inicia el árbol desde la parte inferior de la pantalla
  translate(width /4,height);
  strokeWeight(40);
  // Dibuja una línea de 50 píxeles
  line(160,160,160,-50);
  strokeWeight(30);
  // Dibuja una línea de 100 píxeles
  line(160,160,160,-100);
  // Mueve la funcion arbol al final de la linea
  translate(160,-100);
  // Inicia la funcion arbol
  arbol(150,20);
}
 
void arbol(float h,float s)
{
  // Cada Rama creada sera mas delgada que la anterior en cuanto a largo y grueso
  h *=0.7;
  s *=0.6;
 
  // Todas las funciones deben tener una condición de salida!!
  // Aquí, la nuestra es cuando la longitud de la rama es de 1 píxeles o menos
 
  if(h > 1)
  {
 
    pushMatrix(); // Guardar el estado actual de transformación (es decir, donde estamos ahora)
    strokeWeight(s*0.5); // Se adelgaza la linea a la mitad
    rotate(-ramas); // Rotar por ramas
    line(0,0,0,-h); // Dibuja la rama
    translate(0,-h); // Ir al final de la rama
    arbol(h,s); // Ok, ahora se llaman arbol para dibujar dos nuevas ramas!
    popMatrix(); // Cada vez que volvamos aquí, se restaura el estado anterior de la matriz
 
    // Repetir lo mismo, sólo se ramificara hacia la izquierda esta vez y eh cambiado algunos valores para que el lado izquierdo no sea igual al derecho!
    pushMatrix();
    strokeWeight(s*0.6);
    rotate(ramas);
    line(0,0,0,-h-10);
    translate(0,-h-10);
    arbol(h,s);
    popMatrix();
 
  }
}

El resultado seria el siguiente:

Para instalar Gnokii en nuestro servidor usamos el administrador de paquetes apt con la siguiente linea: apt-get install gnokii Si estamos sobre Ubuntu recuerden anteponer la linea sudo

Una vez instalado Gnokii tenemos que configurarlo, el primer paso es  entrar a la carpeta etc  con la siguiente línea de comando: cd /etc
Cuando estemos dentro de etc el siguiente paso será editar el archivo gnokiirc para esto utilizamos el siguiente comando: nano gnokiirc

Una vez que nos encontremos en el editor en la parte [global]  agregaremos las líneas correspondientes al tipo de cable que usa nuestro teléfono  en este caso quedara de la siguiente manera  (recuerda que esta configuración es para un Nokia 5610 que utiliza un cable tipo CA-101 para  ver las configuraciones de otro tipo de cables consulta http://wiki.gnokii.org/index.php/Cables)

[global]
model = AT
port = /dev/ttyACM0
connection = serial

Una vez que hayamos editado y guardado el archivo gnokiirc conectamos nuestro teléfono al equipo y elegimos la opción PC Suite y ejecutamos el siguiente comando: gnokii –identify

Una vez que hayamos editado y guardado el archivo gnokiirc conectamos nuestro teléfono al equipo y elegimos la opción PC Suite y ejecutamos el siguiente comando: gnokii –identify
Nos tendrá que mostrar  todos los datos de nuestro teléfono

Nota: Por razones de seguridad edite la parte del IMEI

Ahora está configurado y listo para enviar mensajes

Para probar la funcionalidad del envió de mensajes la sentencia a ejecutar es la siguiente:

echo “Hola mundo” | gnokii –sendsms numerocelular

Nota: por razones de seguridad he editado la pare correspondiente al numero telefónico

Una vez que se halla enviando el mensaje correctamente aparecerá un mensaje de que todo ha salido bien en caso contrario nos mostrara el mensaje failed

con esto damos por concluido este tutorial , cualquier duda o sugerencia estamos para ayudarles

La instalación de Processing es muy sencilla si se cuanta con los materiales necesarios, solo es cuestión de seguir unos simples pasos:

Paso 1: Descargar Processing

Descargamos el Processing de la pagina oficial y nos aseguramos que sea la versión para Mac OS X http://www.processing.org/download/, y se guarda donde sea mas conveniente.

Paso 2: Ejecutar el Archivo Descargado

Cuando la descarga se complete ejecutamos el archivo .dmg y aparecerá una ventana como la siguiente.

Paso 3: Instalación en Mac OS X

Arrastramos el icono de Processing encima de la carpeta Aplicaciones, cuando esta se habrá soltamos el icono dentro y esperamos que termine de copiarse.

Paso 4: Final de la Instalación

Una vez hecho lo anterior desmontamos el archivo .dmg, con clic derecho expulsar, luego nos dirigimos a nuestra carpeta de aplicaciones y ejecutamos el Processing.

Nota:

Lo que se utilizo para este tutoríal fue el Processing 1.0 y una MacBook Pro con Mac Os X

La instalación de geoserver resulta relativamente fácil, solo hay que seguir unos cuantos sencillos pasos para lograrlo.

Paso 1: Descargar Geoserver

Nos descargamos el geoserver del siguiente enlace: http://sourceforge.net/projects/geoserver/files/ y lo guardamos donde nosotros queramos.

Paso 2: Descomprimir el archivo

Descomprimimos el archivo con el comando unzip en este caso el archivo lo tenemos guardado en la capeta de Descargas.

Descomprimir el archivo

Paso 3: Copiar el Geoserver

Antes de copiar el geoserver, necesitamos logearnos como “root” para poder tener los permisos necesarios para hacerlo. Seguido de esto copiaremos nuestra carpeta extraída de geoserver a la dirección /usr/local/.

Copiar la carpeta de Geoserver

Paso 4: Agregar variables

Antes de ejecutar nuestro geoserver, es necesario establecer dos variables (JAVA_HOME y GEOSERVER_HOME), normalmente hay que definirlas siempre que queramos ejecutar el programa, para evitarnos esta molestia, la vamos a definir para que cuando cargue nuestro sistema se inicialicen.

En modo “root” abrimos el archivo .bashrc ubicado en nuestra carpeta personal, y agregamos las siguientes lineas.

export JAVA_HOME=/usr/lib/jvm/java-6-sun-1.6.0.20/jre
export GEOSERVER_HOME=/usr/local/geoserver-2.0.1

Donde JAVA_HOME es la ruta donde tenemos instalado java (recordemos que geoserver trabaja con java) y GEOSERVER_HOME es la ruta donde tenemos instalado el geoserver.

Abriendo el archivo .bashrc

Añadiendo variables al .bashrc

Paso 5: Ejecutar el programa

Una vez agregadas las variables, procedemos a ejecutar el geoserver, nos dirigimos a la carpeta donde lo instalamos, acedemos a la carpeta /bin y ejecutamos el archivo startup.sh (recuerden que todo en modo “root”).

Iniciando Geoserver

Iniciando Geoserver

Una vez iniciado Geoserver, abrimos nuestro navegador y accedemos a la dirección http://localhost:8080/geoserver/web/

Página principal de Geoserver

Listo!! tenemos instalado Geoserver en Ubuntu!

Nota: para este tutoríal se utilizó Geoserver2.0.1 y Ubuntu9.10.

Dudas, comentarios o sugerencias estamos para servirte, espero les sea de gran ayuda!!

Saludos!

Android es una plataforma de software para dispositivos móviles que incluye un sistema operativo, middleware y aplicaciones. Para desarrollar aplicaciones en esta plataforma, es necesario contar con el kit de desarrollo de software (SDK) para Android, el cual contiene las herramientas y las APIs necesarias para desarrollar aplicaciones usando el lenguaje de programación Java.

Aquí dejo los pasos para los impacientes:

1.- Instalación del JDK:

sudo apt-get install sun-java6-jdk

2.- Instalación de Eclipse:
Http://www.eclipse.org/downloads/

3.- Instalación del SDK de Android:
Http://developer.android.com/sdk/index.html
Exportar las herramientas del SDK en el PATH:

PATH=$PATH:~/android-sdk-linux_86/tools
export PATH

source ~/.bashrc

4.- Instalar el plugin ADT para Eclipse
Eclipse: Help->Software Updates o Help-> Install New Software
Nuevo plugin con dirección : https://www.dl-ssl.google.com/android/eclipse
En la sección de Available Software debemos seleccionar el paquete Developer Tools.

5.- Configuar nuestro plugin para que trabaje con el SDK.
Abrimos Windows->Preferences vamos a la parte de Android.
En SDK Location, damos clic en Browse y localizamos el directorio donde previamente se descomprimió el SDK.

6.- Agregando la plataforma Android y otros componentes:
Eclipse: Window-> Android SDK and AVD Manager
Clic en Available Packages y seleccionamos los paquetes que desamos instalar.

7.- Creación de un Dispositivo Virtual Android AVD
Eclipse: Window-> SDK and AVD Manager.
En Virtual Devices, clic en (New . . .) crear un nuevo AVD .
Escribimos un nombre y seleccionamos el platform Target adecuado.

A continuación se describen cada uno de los pasos a detalle, además se presenta el típico ejemplo Hola Mundo en Android.

1.- Instalación de JDK.
En primer lugar debemos saber que Android no soporta las versiones JDK 1.4 o anteriores, ni tampoco soporta la distribución del compilador GNU para Java (gcj) que tienen instalado algunas distribuciones Linux por defecto. Por tanto se recomienda instalar una versión JDK 1.5 o superior, en este caso vamos a instalar el JDK 1.6:

sudo apt-get install sun-java6-bin

Para el entorno de desarrollo completo instalamos:

sudo apt-get install sun-java6-jdk

En caso de tener una arquitectura de 64 bits debemos instalar el paquete ia32-libs.

2.- Instalación de Eclipse.

Se recomienda tener un entorno de desarrollo (IDE) para trabajar con Android. El más recomendado es Eclipse:

Http://www.eclipse.org/downloads/

Las versiones recomendadas para Android son:

• Eclipse Classic 3.5.1
• Eclipse 3.5 Galileo
• Eclipse for Java EE
• Eclipse RCP/Plug-in Developers
• Eclipse IDE for Java Developers

3.- Instalando el SDK de Android.
El SDK no es un entorno de desarrollo completo, solo incluye las herremientas necesarias para descargar el resto de los componentes SDK. Se puede obtener de la siguiente dirección:

Http://developer.android.com/sdk/index.html

Una vez descargado, se debe descomprimir en algún sitio del sistema, por defecto el nombre de la carpeta descomprimida es android-sdk-[plataforma del sistema].

Opcionalmente podemos agregar las herramientas del SDK a nuestra variable del entorno del sistema (PATH), para no tener que escribir la ruta completa al ejecutar dichas herramientas en la línea de comandos. Para ello, primero debemos modificar el archivo ~/.bashrc (donde el prefijo “~” significa la ruta de usuario dentro de /home) con cualquier editor de textos.

Agregamos al final del archivo las siguientes dos líneas:

PATH=$PATH:~/android-sdk-linux_86/tools
export PATH

Donde ahora el prefijo “~” significa la ruta donde se descomprimió la carpeta del SDK.
Salvalo y después ejecuta:

source ~/.bashrc

4.- Instalando ADT Plugin para Eclipse
Android ofrece un plugin para Eclipse llamado ADT, el cual está diseñado para brindar soporte en el desarrollo de aplicaciones con Android. Es ampliamente recomendado y es la manera más sencilla de iniciar con Android.

Para descargarlo e instalarlo vamos a hacer uso de Eclipse:
1.- Arrancar Eclipse y seleccionar:
Help->Software Updates o Help-> Install New Software
2.- En la sección de Software Available:
Add Site . . . o Add . .
3.- Debemos agregar un sitio de descarga y un nombre para nuestro plugin, el nombre puede ser cualquiera, por ejemplo “Android Plugin”, pero el sitio debe ser:
https://www.dl-ssl.google.com/android/eclipse

Si te causa problemas la descarga puedes probar con http://.

4.- Regresando a la sección de Available Software debemos seleccionar el paquete Developer Tools, el cual contiene Android DDMS y android Development Tools.

Damos clic en Next, aceptamos la licencia, esperamos su instalación y damos clic en Finish.

5.- Reinciamos Eclipse.

5.- Configurar el plugin para que trabaje con el SDK.
Ahora debemos configuar nuestro plugin para que trabaje con el SDK de nuestro equipo. Para ello vamos al Eclipse:

1.- Abrimos Windows->Preferences
2.- Seleccionamos Android de la parte izquierda del Panel.
3.- En el panel Principal aparece SDK Location, damos clic en Browse y localizamos el directorio donde previamente se descomprimió el SDK que descargamos.
4.- Damos clic en Apply y en OK.

6.- Agregando la plataforma Android y otros componentes:
Debemos tener al menos una plataforma en nuestro entorno de desarrollo de Android, para poder compilar nuestra aplicación y poder emularla con un AVD (Android Virtual Device). Primero vamos a Eclipse:

1.- Damos clic en Window-> Android SDK and AVD Manager
2.- Damos clic en Available Packages y seleccionamos los paquetes que desamos instalar.

EL SDK Tools debe estar instalado y al menos una Plataforma SDK. La documentación y los ejemplos son muy recomendables pero no son necesarios. Existen plataformas y APIs adicionales que nos brindan una manera más completa de desarrollar y correr nuestra aplicación.

Una vez terminada nuestra instalación podemos verificar los componentes instalados en nuestra directorio SDK.

Add-ons/ : contiene los complementos y las APIs que se hayan instalado en el entorno de desarrollo.

• Docs/: contiene la guía de desarrolladores y la documentación completa, en caso de no contar con una conexión a internet podemos abrir el archivo offline.html.
• Platforms/: Contiene las versiones de las plataformas en las cuales es posible desarrollar aplicaciones.
• Samples/: Contiene códigos de ejemplo.
• Tools/: Contiene las herramientas necesarias para desarrollar aplicaciones tal como el emulador, la herramienta android, adb, etc.

Una vez completada la instalación y comprobado que los archivos de instalación se encuentren en los directorios adecuados, estamos listos para comenzar a desarrollar aplicaciones.

7.- Creación de un Dispositivo Virtual Android AVD
Ahora debemos crear un Dispositivo Virtual de Android (AVD):

• Selecionamos window-> SDK and AVD Manager.
• En el panel de Virtual Devices podemos ver la lista de AVDs disponibles, damos clic en (New . . .) crear un nuevo AVD .
• Escribimos un nombre para nuestro AVD y seleccionamos el platform Target adecuado para nuestro proyecto. La imagen para la tarjeta SD es opcional.
• Damos clic en Create AVD.

Salvamos nuestro proyecto y ahora está listo para ser ejecutado. Debemos asegurarnos que el AVD creado tiene un target que satisface el Build Target de la aplicación, de lo contrario la aplicación será abortada antes de ser lanzada.

Para verificar que nuestro AVD ha sido creado correctamente:
1.- Damos clic en Window-> Android SDK and AVD Manager
2.- Damos clic en Virtual Devices.

Nuestro dispositivo Virtual debe aparecer como un AVD válido y disponible.

Hola Mundo con Android

En caso de tener instalado el plugin ADT, podemos crear fácil y rápidamente un nuevo proyecto:

1.- File->New->Project
2.- Seleccionamos Android-> Android Porject
3.- Nos aparece una ventana para seleccionar las características del nuevo proyecto:

• Project Name: Nombre de la carpeta del proyecto.
• Contents: Permite crear un nuevo proyecto en nuestro espacio de trabajo o en otra ubicación, también se puede crear uno a partir de un ejemplo.
• Build Target: Selecciona la plataforma para la cual será construido el proyecto, en caso de no conocer cual plataforma se debe seleccionar, se recomienda utilizar la mínima versión posible. Es importante recordar cual plataforma seleccionamos, ya que será la misma que usaremos para crear nuestro AVD más adelante.

• Properties:
  - Application Name: es el nombre de la aplicación es el título que aparecerá en la aplicación.
  - Package Name: es el nombre del paquete en el cual se guardarán nuestras aplicaciónes del proyecto, utiliza las mismas reglas del lenguaje de programación Java.
  - Create activity: es el nombre de la actividad principal de la clase.
  - Min SDK version: Indica el mínimo nivel API requerido para nuestra aplicación, en caso de no saber cual escribir se debera poner el mismo que en la plataforma SDK seleccionada en el Build Target.
  Dar clic en Finish.

El código de nuestro proyecto debe parecer algo así:

package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Para ejecutar nuestra aplicación debemos dar clic en el botón Run que se encuentra en la barra de herramientas de Eclipse, debe aparecer una cuadro de diálogo que permita seleccionar que tipo de aplicación queremos ejecutar y seleccionamos Android application.

En caso de no aparecer dicha ventana debemos crear una configuración de ejecución:

1.- Seleccionamos Run-> run Configurations o run-> open run dialog.
2.- Abrimos el menú Android application que aparece del lado izquierdo de la ventana, en caso de tener una configuración podemos seleccionarla, en caso contrario aparecerá una ventana de nueva configuración.
3.- Aparece una nueva configuaración en blanco con las siguientes tres pestañas:

• Android: Debemos seleccionar el proyecto que deseamos ejecutar y la acción por defecto que deseamos ejecutar en el proyecto, se recomiendo selecionar Launch default activity.
• Target: Selecionamos la plataforma que seleccionamos anteriormente en nuestro proyecto, se recomienda seleccionar Automatic y activar el AVD previamente creado.
• Common: En este apartado podemos dejar las opciones marcadas por defecto, pero adicionalmente podemos especificar que nuestra nueva configuración se muestre en los menús de Run o Debug.

4.- Por último damos un nombre a nuestra nueva configuración y damos clic en Run.

El emulador de dispositivos debe crear todo lo necesario para que nuestra aplicación se ejecute en nuestro dispositivo virtual, lo cual lleva un poco de tiempo. La primer pantalla que debe aparecer es:

El lado izquierdo representa la pantalla del dispositivo virtual, el lado derecho representa una interfaz genérica de comunicación con el dispositivo, en este caso solo nos interesa la salida de pantalla, que después de unos segundos de carga, deberá verse así:

Una vez finalizada la carga del dispositivo virtual ya podemos interactuar con la plataforma Android.

Ahora vamos al código de nuevo y lo modificamos para que se vea algo así:

package examples.HelloAndroid;
 
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
 
 
public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TextView tv = new TextView(this);
        tv.setText("Hola Mundo ! ! ! ");
        setContentView(tv);
 
    }
}

Una interface de usuario en Android está compuesta por objetos llamados Views. Cada view puede ser un botón, una eqtiqueta, una imagen, etc. Todos ellos son una subclase de View, la clase TextView también es una subclase de View.

Con la función setText() definimos el texto del contenido. Por último la función setContentView() muestra el contenido de la actividad en la interfaz de usuario, si no se invoca esta función aparece una pantalla negra.

Nuevamente ejecutamos nuestra aplicación. Ahora el texto se deberá mostrar en panatalla una vez que el emulador ha dejado de cargar el dispositivo virtual.

Algunas veces es necesario oprimir un botón para desbloquear la pantalla, en este caso es el botón menú, es necesario desbloquearla para poder observar nuestra aplicación.

Si nos encontramos en el ambiente Android, podemos encontrar nuestra aplicación directamente en el menú de la plataforma, basta con dar clic en el icono para ejecturala.

De esta forma tenemos nuestra aplicación Hola Mundo en Android.

Hoy la histórica página de Sun Microsystems (uno de los sitios más antiguos de la www) ha dejado de aparecer y en su lugar existe una redirección hacia la página web de Oracle (http://www.oracle.com), esperemos que los proyectos libres que Sun apoyaba no se encuentren descobijados bajo la nueva administración.

Es curioso, muchas personas nunca pensarón que pasaría algo, así e incluso si vemos en la línea del tiempo, uno podría haber apostado que hubiera ocurrido lo contrario, son tiempos de cambio y espero de crecimiento, para la plataforma Java.

Vía Twitter, me llegó un enlace muy interesante sobre respaldos automatizados de bases de datos mysql utilizando Groovy (que es un lenguaje dinámico que se ejecuta en la máquina virtual de Java).

Está muy bien explicado, la dirección es:
Respaldos de MySql con Groovy, Amazon S3 y Grape