Foro de elhacker.net

tools/android

SDK Setup.exe

• drawable-hdpi, drawable-mdpi, drawable-ldpi en donde se almacenan las imágenes que va a utilizar nuestra aplicación. La diferencia entre ellas es que debemos colocar las imágenes que aparecerán según el tipo de pantalla del dispositivo. En drawable-hdpi se colocarán las imágenes para dispositivos con alta resolución (High) y en drawable-ldpi (Low) pondremos las imágenes para dispositivos con pantallas pequeñas.
• values contiene inicialmente el archivo strings.xml, que es donde declaramos las cadenas de texto que usará nuestra aplicación. No es obligatorio definir todas las cadenas de texto allí, pero es bastante recomendable hacerlo. En este caso simplemente contiene la definición de una cadena de texto (llamada hello), que es la que se muestra al ejecutar la aplicación:

<?xml version="1.0" encoding="utf-8"?>
<resources>
 <string name="hello">Hello World, HolaParce!</string>
 <string name="app_name">Hola Parce</string>
</resources>

• layout contiene los archivos XML que representan interfaces gráficas. Si echamos un vistazo al archivo generado (main.xml) veremos algo como esto:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:orientation="vertical"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent"
 >
<TextView
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:text="@string/hello"
 />
</LinearLayout>
 

• Los layouts son XML estrictos, así que deben comenzar con el encabezado <?xml version="1.0" encoding="utf-8"?> y todas las etiquetas abiertas deben ser debidamente cerradas.
  
• Los LinearLayout representan contenedores de widgets (algo similar al JPanel de swing en Java). Es decir, es la manera de organizar cada grupo de elementos de la interfaz gráfica.
  
• En este caso, dentro del contenedor solo tenemos un TextView (que sería algo así como un JLabel de swing en Java).
  
• Sea cual sea el elemento que pongamos en el layout, debemos especificar su anchura (android:layout_width) y altura (android:layout_height). Para cada parámetro podemos usar el valor fill_parent o wrap_content. fill_parent hará que el widget ocupe todo el tamaño posible, mientras que wrap_content hará que ocupe el menos posible.
  
• El parámetro android:text permite asignar un texto al TextView. En este caso se usa @string/hello que indica que se usará una variable llamada hello. Esta variable puede ser encontrada en el archivo strings.xml dentro del directorio values. También podríamos especificar el texto directamente, por ejemplo: android:text="Hola parcero!"
  

• Como tal vez se dio cuenta, es posible editar los archivos XML gráficamente o con el editor de textos de Eclipse.
  
  Dentro del directorio gen se encuentra un archivo llamado R.java. Este archivo NO debemos modificarlo ya que es Eclipse quien se encarga de poner el código allí dentro. Este archivo sirve básicamente para enlazar las cosas que hagamos en XML con la programación en Java. Por ejemplo, se crea una referencia a la variable hello creada en el archivo strings.xml. Esto permite que podamos referenciar dicha variable desde Java (esto se explica con más detalle abajo).
  
  Bajo el directorio src se creó un paquete y dentro de él un archivo en Java que es nuestra primera actividad (fíjese cómo la clase creada extiende la clase Activity del paquete android.app):

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

• Línea 1 define el nombre del paquete.
• Líneas 2 y 3 importamos las clases que necesitamos para correr la actividad.
• En la línea 4 podemos ver que la clase exitiende a Activity.
• En la línea 7 redefinimos el método onCreate de la clase Activity, el cual es ejecutado al momento de iniciar la aplicación. Note que no es necesario tener un método main; en Android se define una actividad principal que será ejecutada al iniciar la aplicación (más adelante veremos donde se configura esto).
• En la línea 9 se usa el método setContentView que define cual de las interfaces gráficas creadas en el directorio layout serán usadas. Como parámetro usamos la variable R.layout.main. Esto es algo confuso al principio así que lea atentamente: R, como vimos anteriormente, es una clase generada por Eclipse automáticamente cada vez que creamos nuevos componentes para la aplicación; dentro de ella se crean clases estáticas con variables enteras que representan cada uno de estos componentes (main.xml es entonces una variable entera llamada main, dentro de la clase estática layout, que a su vez se encuentra dentro de la clase R.java). Por ejemplo, para usar la variable hello desde Java, tendríamos que usar una referencia de tipo R.values.hello.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="net.casidiablo.holaparce"
 android:versionCode="1"
 android:versionName="1.0">
 <application android:icon="@drawable/icon" android:label="@string/app_name">
 <activity android:name=".HolaParce"
 android:label="@string/app_name">
 <intent-filter>
 <action android:name="android.intent.action.MAIN" />
 <category android:name="android.intent.category.LAUNCHER" />
 </intent-filter>
 </activity>
</application>
 <uses-sdk android:minSdkVersion="4" />
</manifest>

tools/adb -s emulator5554 shell

funtoo@larry tools % ./adb -s emulator-5554 shell
# ls
sqlite_stmt_journals
cache
sdcard
etc
system
sys
sbin
proc
init.rc
init.goldfish.rc
init
default.prop
data
root
dev

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class EjemploInvertir extends Activity {
	@Override
	public void onCreate(Bundle b) {
		super.onCreate(b);
		setContentView(R.layout.interfaz_grafica);
		String x = null;
		try {
			x.length();
		} catch (Exception e) {
			Log.d("Al inicio", "El error es: "+e.toString());
		}
	}
}

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
public class EjemploInvertir extends Activity{
    @Override
    public void onCreate(Bundle b){
        super.onCreate(b);
        setContentView(R.layout.main);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="net.casidiablo.ejemplo" android:versionCode="1"
    android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name="EjemploInvertir">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER"></category>
            </intent-filter>
        </activity>
    </application>
    <uses-sdk android:minSdkVersion="4" />
</manifest>

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

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World!</string>
    <string name="app_name">Ejemplo</string>
    <string name="texto_boton">Invertir!</string>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="fill_parent" android:layout_height="fill_parent"
     android:orientation="vertical">
    <LinearLayout android:orientation="horizontal"
     android:layout_width="fill_parent" android:layout_height="wrap_content">
        <TextView android:text="Palabra: " android:layout_width="wrap_content"
         android:layout_height="wrap_content" />
        <EditText android:id="@+id/cajaTexto" android:layout_width="fill_parent"
         android:layout_height="wrap_content" />
    </LinearLayout>
    <Button android="@+id/btnInvertir" android:layout_width="fill_parent"
     android:layout_height="wrap_content" android:text="@string/texto_boton"/>
</LinearLayout>

• En la línea 3 podemos ver que cambiamos el ancho y alto del LinearLayout principal de tal manera que utilice toda la pantalla (usando fill_parent).
  
• Puesto que el LinearLayout contendrá otros objetos, debemos indicarle el sentido en el que los irá poniendo. En este caso se deben poner verticalmente (android:orientation="vertical").
  
• En las líneas 5 y 6 creamos un nuevo LinearLayout que contendrá el label y la caja de texto. Puesto que queremos que estos dos objetos aparezcan en una sola línea, ponemos el parámetro android:orientation="horizontal". Además, le indicamos que ocupe toda la pantalla a lo ancho, pero que la altura sea la más pequeña posible.
  
• En las líneas 7 y 8 creamos un nuevo TextView (un label) con el texto "Palabra: "; esto lo indicamos con la propiedad android:text. Además queremos que ocupe el menor espacio posible tanto en alto como en ancho (wrap_content para layout_width y layout_height).
  
• En las líneas 9 y 10 creamos un EditText (una caja de texto), que es donde el usuario pondrá la palabra que desea invertir. Intentará ocupar el mayor ancho posible en la pantalla. Además, puesto que este es un objeto del cual necesitaremos datos, debemos asignarle un ID para que podamos acceder a él desde el programa en Java que crearemos en breve.
  
• En la línea 11 cerramos el LinearLayout que contiene el label y la caja de texto.
  
• En las líneas 12 y 13 creamos un objeto Button. Este objeto también tiene un ID puesto que debemos obtener una referencia del mismo desde el programa en Java. Además, a la propiedad android:text se está asignando @string/texto_boton que es la referencia a la variable que creamos en el strings.xml
  

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
public class EjemploInvertir extends Activity{
    @Override
    public void onCreate(Bundle b){
        super.onCreate(b);
        setContentView(R.layout.interfaz_grafica);
    }
}

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
public class EjemploInvertir extends Activity{
    //declarar objetos
    private EditText texto;
    private Button boton;
    @Override
    public void onCreate(Bundle b){
        super.onCreate(b);
        setContentView(R.layout.interfaz_grafica);
        //iniciar los objetos
        texto = (EditText) findViewById(R.id.cajaTexto);
        boton = (Button) findViewById(R.id.btnInvertir);
    }
}

• En las líneas 4 y 5 importamos las clases Button y EditText del paquete android.widget.
  
• En las líneas 9 y 10 declaramos objetos de tipo EditText y Button, los cuales los usaremos para manipular los que hemos creado en la interfaz gráfica.
  
• En la líneas 17 iniciamos el objeto EditText usando el método findViewById, a la cual le enviamos como parámetro el ID de la caja de texto (¿recuerdas? pusimos esto dentro del XML: android:id="@+id/cajaTexto").
  
• De igual manera creamos el objeto botón usando el ID btnInvertir que definimos en el XML.
  

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
public class EjemploInvertir extends Activity{
	//declarar objetos
	private EditText cajaDeTexto;
	private Button boton;
	@Override
	public void onCreate(Bundle b){
		super.onCreate(b);
		setContentView(R.layout.interfaz_grafica);
		//iniciar los objetos
		cajaDeTexto = (EditText) findViewById(R.id.cajaTexto);
		boton = (Button) findViewById(R.id.btnInvertir);
		boton.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				invertir();
			}
		});
	}
	//metodo para invertir el texto
	private void invertir(){
		//obtener el string de la caja de texto
		String txt = cajaDeTexto.getText().toString();
		//verificar que haya texto por invertir
		if(!txt.equals("")){
			//invertir texto
			String resultado = "";
			for (int i = txt.length()-1; i>=0; i--)
				resultado += txt.charAt (i);
		    //asignamos el string invertido a la caja de texto
			cajaDeTexto.setText(resultado);
		}
		else Toast.makeText(this, "No hay nada que invertir", Toast.LENGTH_LONG).show();
	}
}

• En la línea 5 se importan la interfaz OnClickListener. Dicha interfaz es usada en la línea 20 al crear un objeto que se enviará como parámetro al método setOnClickListener. Dentro, es necesario implementar el método onClick en donde pondremos las instrucciones que serán ejecutadas al momento de hacer clic en el botón (en este caso una llamada a la función invertir(), líneas 28 a 41).
  
• El método invertir inicia una variable String con los datos que contenga la caja de texto, usando el método getText de la clase EditText.
  
• En las líneas 35 y 36 se invierte la cadena, que posteriormente se pone de nuevo en la caja de texto usando el método setText (línea 38).
  
• En la línea 40 mostramos un mensaje usando la clase Toast. Este mensaje aparece cuando no hay datos en la caja de texto. Lo he colocado puesto que es bastante sencillo de implementar. Basta con usar el método estático makeText pasándole como parámetros el contexto en el que se mostrará (se usa this, puesto que se mostrará en la Actividad actual), el texto a mostrar y cuanto tiempo durará el mensaje.
  

android create project -t 1 -p /tmp/ejemplo -k net.casidiablo.ejemplo -a Ejemplo

aapt p -m -J src -M AndroidManifest.xml -S res -I $ANDROID_DIR/android.jar

• p = package
• -m -j src indicar el directorio de los archivos fuente
• -M indicar la ubicación del manifiesto
• -S indicar la ubicación del directorio de recursos
• -I $ANDROID_DIR/android.jar añade el paquete android.jar al classpath del proyecto. Importante: en mi caso $ANDROID_DIR apunta a /opt/android/platforms/android-4/ y en el path del sistema se encuentra incluido /opt/android/platforms/android-4/tools/ Es importante tener en cuenta que NO se usa la base del SDK como antiguamente se hacía, sino el correspondiente directorio bajo platforms.

javac -encoding ascii -target 1.5 -d bin -bootclasspath $ANDROID_DIR/android.jar src/net/casidiablo/ejemplo/*.java

dx –dex –output=bin/classes.dex bin # si existieran librerías externas se añade libs/*.jar

aapt p -f -M AndroidManifest.xml -S res/ -I $ANDROID_DIR/android.jar -F bin/ejemplo.ap_

apkbuilder bin/ejemplo.apk -z bin/ejemplo.ap_ -f bin/classes.dex -rf src -rj libs

adb install bin/ejemplo.apk