Bienvenidos a mi segunda entrega del tutorial para android espero que les guste, si te perdiste la primer entrega te dejo el link,
1 - Almacenamiento de datos en un archivo de texto en la memoria interna.
Otra posibilidad de almacenar datos en nuestro dispositivo Android es el empleo de un archivo de texto que se guardará en el almacenamiento interno del equipo (la otro posibilidad es almacenarlo en una tarjeta SD Card)
Problema:
Confeccionar un programa que permita almacenar notas en un control EditText y cuando se presione un botón almacenar los datos del EditText en un archivo de texto llamado "notas.txt".
Cada vez que se ingrese al programa verificar si existe el archivo de textos "notas.txt" proceder a su lectura y almacenamiento de datos en el EditText.
Crear un proyecto en Eclipse de tipo "Android Project" y definir como nombre: proyecto013 y localizarlo en el paquete com.androidya.proyecto013.
La interfaz visual, los controles y sus ID son los siguientes:
El código fuente de la aplicación:
package com.javaya.proyecto013;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import android.app.Activity;import android.os.Bundle;import android.view.Menu;import android.view.View;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends Activity { private EditText et1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1 = (EditText) findViewById(R.id.et1); String[] archivos = fileList(); if (existe(archivos, "notas.txt")) try { InputStreamReader archivo = new InputStreamReader( openFileInput("notas.txt")); BufferedReader br = new BufferedReader(archivo); String linea = br.readLine(); String todo = ""; while (linea != null) { todo = todo + linea + "n"; linea = br.readLine(); } br.close(); archivo.close(); et1.setText(todo); } catch (IOException e) { } } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } private boolean existe(String[] archivos, String archbusca) { for (int f = 0; f < archivos.length; f++) if (archbusca.equals(archivos[f])) return true; return false; } public void grabar(View v) { try { OutputStreamWriter archivo = new OutputStreamWriter(openFileOutput( "notas.txt", Activity.MODE_PRIVATE)); archivo.write(et1.getText().toString()); archivo.flush(); archivo.close(); } catch (IOException e) { } Toast t = Toast.makeText(this, "Los datos fueron grabados", Toast.LENGTH_SHORT); t.show(); finish(); }}
Veamos primero como grabamos datos en un archivo de texto. Esto se hace en el método grabar que se ejecuta cuando presionamos el botón "grabar" (recordemos de inicializar la propiedad "OnClick" del botón):
public void grabar(View v) { try { OutputStreamWriter archivo = new OutputStreamWriter(openFileOutput("notas.txt",Activity.MODE_PRIVATE));
Creamos un objeto de la clase OutputStreamWriter y al constructor de dicha clase le enviamos el dato que retorna el método openFileOutput propio de la clase Activity que le pasamos como parámetro el nombre del archivo de texto y el modo de apertura.
Seguidamente si el archivo se creó correctamente procedemos a llamar al método write y le pasamos el String a grabar, en este caso extraemos los datos del EditText:
archivo.write(et1.getText().toString());
Luego de grabar con el método write llamamos al método flush para que vuelque todos los datos que pueden haber quedado en el buffer y procedemos al cerrado del archivo:
archivo.flush(); archivo.close();
Todo esto está cerrado en un try/catch para verificar si sucede algún error en la apertura del archivo.
Finalmente mostramos un mensaje temporal en pantalla utilizando la clase Toast:
Toast t=Toast.makeText(this,"Los datos fueron grabados", Toast.LENGTH_SHORT); t.show(); finish();
Para crear un objeto de la clase Toast llamamos al método makeText de la clase Toast y le pasamos la referencia del Activity actual, el String a mostrar y el tiempo de duración del mensaje. Con el objeto devuelto por el método makeText procedemos a llamar seguidamente al método show para que se muestre el mensaje.
Es común llamar al método show de la clase Toast en una sola línea como esta:
Toast.makeText(this,"Los datos fueron grabados", Toast.LENGTH_SHORT).show();
El método onCreate tiene por objetivo verificar si existe el archivo de texto, proceder a su lectura y mostrar su contenido en el EditText.
Primero obtenemos la lista de todos los archivos creados por la Activity. En nuestro ejemplo puede ser cero o uno:
String []archivos=fileList();
Llamamos a un método que verifica si en el vector de tipo String existe el archivo "notas.txt":
if (existe(archivos,"notas.txt"))
En el caso que me retorne true procedemos a crear un objeto de la clase InputStreamReader y al constructor de dicha clase le pasamos el dato devuelto por el método openFileInput:
InputStreamReader archivo=new InputStreamReader(openFileInput("notas.txt"));
Creamos un objeto de la clase BufferedReader y le pasamos al constructor la referencia del objeto de la clase InputStreamReader:
BufferedReader br=new BufferedReader(archivo);
Leemos la primer línea del archivo de texto:
String linea=br.readLine();
Inicializamos un String vacío:
String todo="";
Mientras el método readLine de la clase BufferedReader devuelva un String:
while (linea!=null) {
Lo concatenamos al String junto a un salto de línea:
todo=todo+linea+"n";
Leemos la próxima línea:
linea=br.readLine(); }
Llamamos al método close de la clase BufferedReader y al del InputStreamReader:
br.close(); archivo.close();
Cargamos el EditText con el contenido del String que contiene todos los datos del archivo de texto:
et1.setText(todo);
El método existe llega un vector de tipo String y otro String a buscar. Dentro de un for verificamos el String a buscar con cada uno de los String del vector, si lo encontramos retornamos true. Si recorre todo el for sin encontrarlo fuera del for retornamos false:
private boolean existe(String[] archivos,String archbusca) { for(int f=0;f<archivos.length;f++) if (archbusca.equals(archivos[f])) return true; return false; }
[size=24]2- Almacenamiento de datos en un archivo de texto localizado en una tarjeta SD[/size]
[size=16]
[/size]
En el Concepto anterior VIMOS Como Crear y leer sin archivo de texto en la memoria interna del Equipo Android. En algunas Situaciones Podria Ser Útil Almacenar los Datos En Una Tarjeta SD, ESTO debido a Do Mayor capacidad o la facilidad de compartir los Archivos con Otras Personas entregando la Tarjeta SD.
[size=16]Problema:[/size]
Sin confeccionar Programa Que permita ingresar el Nombre de la ONU archivo y el Contenido. Permitir grabar los Datos ingresados al presionar sin Button.Enajenante ONU Segundo Button Que permita Recuperar los Datos del archivo de texto.
Hacer ¡Que los Archivos sí graben En Una Tarjeta SD.
La Interfaz visual a implementar es la siguiente:
[img]http://www.javaya.com.ar/androidya/imagentema/foto056.jpg[/img]
El Primer Paso es Modificar el archivo AndroidManifest.xml párr permitir el Acceso a la Tarjeta SD from our application ESTO lo HACEMOS desde el editor visual del archivo AndroidManifest.xml:
[img]http://www.javaya.com.ar/androidya/imagentema/foto057.jpg[/img]
Debemos presionar El Botón "Añadir" select "Usos Permision" y LUEGO en nombre select "android.permission.WRITE_EXTERNAL_STORAGE".
El Codigo fuente es:
[code]paquete com.javaya.proyecto014;java.io.BufferedReader importación;importar java.io.File;importar java.io.FileInputStream;importar java.io.FileOutputStream;java.io.IOException importación;java.io.InputStreamReader importación;importar java.io.OutputStreamWriter;importar android.app.Activity;android.os.Bundle importación;importar android.os.Environment;importar android.view.Menu;importar android.view.View;importar android.widget.EditText;importar android.widget.Toast;MainActivity public class Actividad { EditarTexto et1; EditarTexto et2; @ Override protected void onCreate (Bundle savedInstanceState) { super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); et1 = (EditarTexto) findViewById (R.id.editText1); et2 = (EditarTexto) findViewById (R.id.editText2); } @ Override onCreateOptionsMenu public boolean (menu Menu) { / / Inflar el menú, lo que añade elementos a la barra de acción, si está presente. . getMenuInflater () inflar (R.menu.activity_main, menú); return true; } public void grabar (View v) { Cadena nomarchivo = et1.getText () toString ().; Cadena contenido = et2.getText () toString ().; try { Archivo Tarjeta = Environment.getExternalStorageDirectory (); File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); OutputStreamWriter osw = new OutputStreamWriter ( nueva FileOutputStream (archivo)); osw.write (Contenido); osw.flush (); osw.close (); Toast.makeText (this, "Los Datos were Grabados correctamente", . Toast.LENGTH_SHORT) mostrar (); et1.setText (""); et2.setText (""); } Catch (IOException ioe) { } } public void Recuperar (View v) { Cadena nomarchivo = et1.getText () toString ().; Archivo Tarjeta = Environment.getExternalStorageDirectory (); File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); try { FileInputStream Fin = nueva FileInputStream (archivo); InputStreamReader archivo = new InputStreamReader (fin); BufferedReader br = new BufferedReader (archivo); Cadena linea = br.readLine (); Cadena del todo = ""; while (linea! = null) { TODO TODO = + linea + ""; linea = br.readLine (); } br.close (); archivo.close (); et2.setText (del todo); } Catch (IOException e) { } }}
El Método párr grabar los Datos En Un archivo de texto localizado en Una Tarjeta SD Comienza obteniendo el Directorio raiz de la Tarjeta a Través del Método getExternalStorageDirectory (), el Mismo Retorna sin Objeto de la Clase del archivo.
public void grabar (View v) { Cadena nomarchivo = et1.getText () toString ().; Cadena contenido = et2.getText () toString ().; intentar { Archivo Tarjeta = Environment.getExternalStorageDirectory ();
Creamos Un Nuevo Objeto de la Clase del archivo indicando el camino de la Unidad SD y el Nombre del archivo de Crear:
File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo);
Por ÚLTIMO similares al Acceso de la ONU archivo interno Creamos sin Objeto de la Clase OutputStreamWriter:
OutputStreamWriter osw = new OutputStreamWriter (nueva FileOutputStream (archivo));
Grabamos el Contenido del EditarTexto:
osw.write (Contenido);
Cerramos el archivo:
osw.flush (); osw.close (); Toast.makeText (this, "Los Datos were Grabados correctamente", Toast.LENGTH_SHORT) mostrar ().; et1.setText (""); et2.setText (""); } catch (IOException OIE) { } }
Para la Lectura del archivo NuevaMente obtenemos la Referencia de la Tarjeta SD párrafo Obtener el sendero de la Unidad de Almacenamiento, el resto del Algoritmo es parecido al de Visto ONU de la estafa archivo interno:
public void Recuperar (View v) { Cadena nomarchivo = et1.getText () toString ().; Archivo Tarjeta = Environment.getExternalStorageDirectory (); File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); try { FileInputStream Fin = nueva FileInputStream (archivo); InputStreamReader archivo = new InputStreamReader (fin); BufferedReader br = new BufferedReader (archivo); Cadena linea = br.readLine (); Cadena del todo = ""; while (linea! = null) { TODO TODO = + linea + " n"; linea = br.readLine (); } br.close (); archivo.close (); et2.setText (del todo); } Catch (IOException e) { }
[font= 'LucidaGrande][size=16] }[/size][/font]
3- Almacenamiento en una base de datos SQLite
Hemos visto hasta ahora dos modos de almacenar datos en forma permanente (archivos de texto y la clase SharedPreferences), ahora veremos otra herramienta nativa de Android para almacenar datos en una base de datos llamada SQLite.
SQLite es una base de datos Open Source, es muy popular en muchos dispositivos pequeños, como Android.
Las ventajas que presenta utilizar SQLite es que no requiere configuración, no tiene un servidor de base de datos ejecutándose en un proceso separado y es relativamente simple su empleo.
Problema:
Confeccionar un programa que permita almacenar los datos de votantes de una elección. Crear la tabla votantes y definir los campos dni (documento de identidad), nombre del votante, colegio donde vota y número de mesa donde vota.
El programa debe permitir:
1 - Carga de personas.2 - Consulta por el dni (para saber donde vota)3 - Borrado de personas4 - Modificación de datos.
[size=16][font=arial]Primero implementamos una interfaz visual similar a esta:[/font][/size]
[img]http://www.javaya.com.ar/androidya/imagentema/foto058.jpg[/img]
Lo primero que haremos es crear una clase que herede de SQLiteOpenHelper. Esta clase nos permite crear la base de datos y actualizar la estructura de tablas y datos iniciales.
Debemos implementar el constructor y sobreescribir los métodos onCreate y onUpgrade.
El método onCreate se le llama cuando la base de datos se crea por primera vez. Aquí es donde se define la estructura de las tablas y se cargan eventualmente los datos iniciales
En el método onUpgrade se llama cuando la base de datos debe ser actualizada. Tiene por objetivo eliminar tablas, añadir tablas, o hacer cualquier otra cosa que necesita para actualizarse.
[size=16][font=arial]En nuestro problema implementaremos una nueva clase llamada AdminSQLiteOpenHelper que herede de la clase SQLiteOpenHelper:[/font][/size]
package com.javaya.proyecto015;import android.content.Context;import android.database.sqlite.SQLiteDatabase;import android.database.sqlite.SQLiteDatabase.CursorFactory;import android.database.sqlite.SQLiteOpenHelper;public class AdminSQLiteOpenHelper extends SQLiteOpenHelper { public AdminSQLiteOpenHelper(Context context, String nombre, CursorFactory factory, int version) { super(context, nombre, factory, version); } @Override public void onCreate(SQLiteDatabase db) { db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)"); } @Override public void onUpgrade(SQLiteDatabase db, int versionAnte, int versionNue) { db.execSQL("drop table if exists votantes"); db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)"); }
[size=1]}[/size]
En el constructor solo llamamos al constructor de la clase padre pasando los datos que llegan en los parámetros:
public AdminSQLiteOpenHelper(Context context, String nombre, CursorFactory factory, int version) {super(context, nombre, factory, version);}
En el método onCreate procedemos a crear la tabla votantes con los cuatro campos respectivos y definiendo el campo dni como primary key:
public void onCreate(SQLiteDatabase db) {db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)");}
En el método onUpgrade procedemos a borrar la tabla votantes y crear nuevamente la tabla (en este caso con la misma estructura pero podría ser otra en un caso más real:
public void onUpgrade(SQLiteDatabase db, int versionAnte, int versionNue) {db.execSQL("drop table if exists votantes");db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)");}
[size=16][font=arial]Ahora veamos la otra clase que implementará las altas, bajas, modificaciones y consultas:[/font][/size]
package com.javaya.proyecto015;import android.app.Activity;import android.content.ContentValues;import android.database.Cursor;import android.database.sqlite.SQLiteDatabase;import android.os.Bundle;import android.view.Menu;import android.view.View;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends Activity { private EditText et1, et2, et3, et4; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1 = (EditText) findViewById(R.id.editText1); et2 = (EditText) findViewById(R.id.editText2); et3 = (EditText) findViewById(R.id.editText3); et4 = (EditText) findViewById(R.id.editText4); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void alta(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); String nombre = et2.getText().toString(); String colegio = et3.getText().toString(); String nromesa = et4.getText().toString(); ContentValues registro = new ContentValues(); registro.put("dni", dni); registro.put("nombre", nombre); registro.put("colegio", colegio); registro.put("nromesa", nromesa); bd.insert("votantes", null, registro); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); Toast.makeText(this, "Se cargaron los datos de la persona", Toast.LENGTH_SHORT).show(); } public void consulta(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); Cursor fila = bd.rawQuery( "select nombre,colegio,nromesa from votantes where dni=" + dni, null); if (fila.moveToFirst()) { et2.setText(fila.getString(0)); et3.setText(fila.getString(1)); et4.setText(fila.getString(2)); } else Toast.makeText(this, "No existe una persona con dicho dni", Toast.LENGTH_SHORT).show(); bd.close(); } public void baja(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); int cant = bd.delete("votantes", "dni=" + dni, null); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); if (cant == 1) Toast.makeText(this, "Se borró la persona con dicho documento", Toast.LENGTH_SHORT).show(); else Toast.makeText(this, "No existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); } public void modificacion(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); String nombre = et2.getText().toString(); String colegio = et3.getText().toString(); String nromesa = et4.getText().toString(); ContentValues registro = new ContentValues(); registro.put("nombre", nombre); registro.put("colegio", colegio); registro.put("nromesa", nromesa); int cant = bd.update("votantes", registro, "dni=" + dni, null); bd.close(); if (cant == 1) Toast.makeText(this, "se modificaron los datos", Toast.LENGTH_SHORT) .show(); else Toast.makeText(this, "no existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); }
[size=1]}[/size]
1 - Alta de datos.
Cuando se presiona el botón alta se ejecuta el método "alta" recordemos inicializar la propiedad "OnClick" del botón desde la ventana de visualización del archivo XML.
Lo primero que hacemos en este método es crear un objeto de la clase que planteamos anteriormente y le pasamos al constructor this (referencia del Activity actual), "administracion" (es el nombre de la base de datos que crearemos en el caso que no exista) luego pasamos null y un uno indicando que es la primer versión de la base de datos (en caso que cambiemos la estructura o agreguemos tablas por ejemplo podemos pasar un dos en lugar de un uno para que se ejecute el método onUpgrade donde indicamos la nuestra estructura de la base de datos)
Luego de crear un objeto de la clase AdminSqLiteOpenHelper procedemos a crear un objeto de la clase SQLiteDataBase llamando al método getWritableDatabase (la base de datos se abre en modo lectura y escritura).
Creamos un objeto de la clase ContentValues y mediante el método put inicializamos todos tos campos a cargar.
Seguidamente llamamos al método insert de la clase SQLiteDatabase pasando en el primer parámetro el nombre de la tabla, como segundo parámetro un null y por último el objeto de la clase ContentValues ya inicializado (este método es el que provoca que se inserte una nueva fila en la tabla votantes en la base de datos llamada administracion)
Borramos seguidamente los EditText y mostramos un mensaje para que conozca el operador que el alta de datos se efectuó en forma correcta:
public void alta(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); String nombre=et2.getText().toString(); String colegio=et3.getText().toString(); String nromesa=et4.getText().toString(); ContentValues registro=new ContentValues(); registro.put("dni",dni ); registro.put("nombre",nombre ); registro.put("colegio",colegio ); registro.put("nromesa",nromesa ); bd.insert("votantes", null, registro); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); Toast.makeText(this, "Se cargaron los datos de la persona", Toast.LENGTH_SHORT).show(); }
2 - Consulta de datos.
Cuando se presiona el botón "Consulta por DNI" se ejecuta el método consulta:
public void consulta(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); Cursor fila=bd.rawQuery("select nombre,colegio,nromesa from votantes where dni="+dni+"",null); if (fila.moveToFirst()) { et2.setText(fila.getString(0)); et3.setText(fila.getString(1)); et4.setText(fila.getString(2)); } else Toast.makeText(this, "No existe una persona con dicho dni", Toast.LENGTH_SHORT).show(); bd.close(); }
En el método consulta lo primero que hacemos es crear un objeto de la clase AdminSQLiteOpenHelper y obtener una referencia de la base de datos llamando al método getWritableDatabase.
Seguidamente definimos una variable de la clase Cursor y la inicializamos con el valor devuelto por el método llamado rawQuery.
La clase Cursos almacena en este caso una fila o cero filas (una en caso que hayamos ingresado un dni existente en la tabla votantes), llamamos al método moveToFirst() de la clase Cursos y retorna true en caso de existir una persona con el dni ingresado, en caso contrario retorna cero.
Para recuperar los datos propiamente dichos que queremos consultar llamamos al método getString y le pasamos la posición del campo a recuperar (comienza a numerarse en cero, en este ejemplo la columna cero representa el campo nombre, la columna 1 representa el campo colegio y la columna 2 representa el campo nromesa)
3 - Baja o borrado de datos.
Para borrar uno o más registros la clase SQLiteDatabase tiene un método que le pasamos en el primer parámetro el nombre de la tabla y en el segundo la condición que debe cumplirse para que se borre la fila de la tabla. El método delete retorna un entero que indica la cantidad de registros borrados:
public void baja(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); int cant=bd.delete("votantes", "dni="+dni+"",null); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); if (cant==1) Toast.makeText(this, "Se borró la persona con dicho documento", Toast.LENGTH_SHORT).show(); else Toast.makeText(this, "No existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); }
4 - Modificación de datos.
En la modificación de datos debemos crear un objeto de la clase ContentValues y mediante el método put almacenar los valores para cada campo que será modificado. Luego se llama al método update de la clase SQLiteDatabase pasando el nombre de la tabla, el objeto de la clase ContentValues y la condición del where (el cuanto parámetro en este ejemplo no se lo emplea)
public void modificacion(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); String nombre=et2.getText().toString(); String colegio=et3.getText().toString(); String nromesa=et4.getText().toString(); ContentValues registro=new ContentValues(); registro.put("nombre",nombre); registro.put("colegio",colegio); registro.put("nromesa",nromesa); int cant = bd.update("votantes", registro, "dni="+dni, null); bd.close(); if (cant==1) Toast.makeText(this, "se modificaron los datos", Toast.LENGTH_SHORT).show(); else Toast.makeText(this, "no existe una persona con dicho documento", Toast.LENGTH_SHORT).show();
[font= 'LucidaGrande][size=16] }[/size][/font]
[size=24]4- Instalación del programa Android en un dispositivo real[/size]
[size=1][font=courier]
[/font][/size]
Normalmente uno cuando desarrolla aplicaciones en Android hace toda la programación, depuración y pruebas en un dispositivo virtual en la pc.
Ahora vamos a ver los pasos para probar la aplicación en un dispositivo Android real.
La primera forma que veremos de probar nuestra aplicación es copiar el archivo con extensión APK a nuestro dispositivo.
Primero en el ícono de configuración de nuestro teléfono o tablet android seleccionamos la opción "Aplicaciones" -> y marcamos la opción "Origen desconocido (Permitir la instalación de aplicaciones no pertenecientes al mercado)"Desde nuestro equipo de escritorio enviamos un mail a nuestro celular adjuntando el archivo con extensión apk que se encuentra en el directorio bin de nuestro proyecto (por ejemplo adjuntemos el archivo proyecto015.apk)Abramos el mail desde nuestro celular y seleccionemos el archivo adjunto. Confirmamos que queremos instalarlo.[img]http://www.javaya.com.ar/androidya/imagentema/foto058a.jpg[/img][size=18]
[/size]
[size=16][font=arial]Ya podemos probar nuestra aplicación:[/font][/size]
[img]http://www.javaya.com.ar/androidya/imagentema/foto058b.jpg[/img][size=16][font=arial]
[/font][/size]
[/code]