Cuando abrí el blog lo menos que espere fue que la primera entrada fuera sobre programación en Android, mucho menos que la primera entrada se hiciera 6 meses después de que abrí el blog.
Algo que comenzó como un uso que le di a parte (la plantilla para ser más exactos) de un proyecto que tuvo un futuro más brillante ahora yace junto a otra gran pila de proyectos inconclusos por los cuales perdí el interés, tantas buenas ideas. Todas tan aburridas.
En fin, la plantilla del blog ni siquiera esta terminada, así que vamos con esta entrada, como programar con android tratare de cubrir todo lo que he visto en diferentes tutoriales y unirlos en uno solo.
En fin, la plantilla del blog ni siquiera esta terminada, así que vamos con esta entrada, como programar con android tratare de cubrir todo lo que he visto en diferentes tutoriales y unirlos en uno solo.
Contenido:
- Instalacíon y primeros pasos
- Diseño de inferfaz
- El Programa
En fin comencemos por el principio, algo que nunca antes se ha visto en la web: Como desarrollar para Android. Todos se preguntaran “¿Pero que necesitamos?” tras muchas largas horas de investigación profunda que por nada del mundo se consigue en la primera página de resultados de Google he llegado a la conclusión de que los requisitos mínimos para desarrollar en Android (en cuanto a software al menos) son los siguientes:
- El SDK de Java
- El IDE Eclipse para desarrolladores de Java (por eso necesitamos el SDK de Java ¿Ven como todo comienza a tener sentido?
- El SDK de Android Pues porque vamos a desarrollar para Android ¿No?
- Un Coeficiente Intelectual mayor a 75 (Sí están buscando como descargar este último, por favor presionar Control+W)
Yo como ya descargue dichos elementos no podré demostrarles por medio de capturas como instalarlos, pero siempre que tengan el 4to requisito estarán bien. Aunque les recomiendo descomprimir el Eclipse en su ruta de programas predeterminada (C:\Archivos de programa\ en Windows o donde quieran pero recuerden donde lo dejaron) y crear un acceso directo al ejecutable (eclipse.exe), en cuanto al Android SDK simplemente ejecuten, instalen y luego que les abra el SDK manager, pongan a descargar todo lo que haya por descargar (Pues porque sí) el peso, al menos instalado, es de aproximadamente 4 gigas.
Una vez que tengamos todo instalado y en orden podemos proceder a de… configurar el Eclipse para posteriormente comenzar a desarrollar, lo hacemos de la siguiente manera:
- Abrimos el Eclipse
- Vamos a Help->Install new Software
- Presionamos Add
- En “Name” ponemos Android (Porque estamos instalando el Android en Eclipse, y si es Android le ponemos Android y no gato ¿Tiene sentido, verdad?) y en “Location” ponemos https://dl-ssl.google.com/android/eclipse/ (¿Por qué? La verdad no sé)
- Marcamos “Developer Tools” damos un par de veces siguiente para que se nos presente la opción de leer cuidadosamente los términos y condiciones, una vez leídos los mismos marcamos la casilla y damos “Finish” y Eclipse se reiniciara
- Una vez que Eclipse ha abierto de nuevo vamos a Window->Preferences y vamos a donde dice Android y donde dice “SDK Location” ponemos la ruta donde está el Android (en mi caso es C:\Program Files (x86)\Android\android-sdk). Bajamos el Scroll y precionamos Apply y luego OK
- Ahora debemos configurar nuestro dispositivo Android virtual, para hacer esto nos dirigimos una vez más a Window->AVD manager damos click (izquierdo) y se nos abrirá una ventana, dentro de esa ventana llenaremos los siguientes campos:
- En “Name” pondremos el nombre de nuestro dispositivo (Esto no tiene mayor importancia, pero es recomendable que al menos distingan la versión de Android con la cual lo crearan, por ejemplo pueden colocar: “Pedrito2.3” para distinguir que ese es un dispositivo que trabaja con Android 2.3
- En “Target” pondremos la versión de Android que correrá el dispositivo, en nuestro caso trabajaremos con 2.3.3
- En “SD Card” dispondremos el tamaño de nuestra tarjeta SD virtual, la mía la he puesto de 100MB porque soy exagerado, pero cualquier tamaño está bien realmente (OJO no vayan a poner 2 megas).
- “Skin” lo dejaremos tal cual (Porque sí)
- Ahora “Hardware” es el segundo campo más importante ya que este será el hardware del dispositivo virtual (obviamente). Me explico: Si nuestra aplicación tiene pensado utilizar la cámara y nuestro dispositivo virtual no tiene cámara… Obviamente algo andará mal, así que le damos “New” y agregamos lo que creamos necesario.
- Presionamos “créate AVD” y listo, ya podemos programar para Android.
Nuestra primera aplicación:
¿Qué aprenderemos con esta aplicación?
- Manejo de objetos Android, como definirlos declararlos y trabajarlos
- Diseño de la plantilla por código y de manera visual
- Lanzar actividades (pantallas) de Android
- Permisos y privilegios de la aplicación y como declarar las actividades en el manifiesto de la aplicación
- Y otras cosas que veremos en el camino por efectos de la aplicación que estamos por crear
Antes de crear una aplicación es un problema, y nuestro problema es el siguiente: Necesitamos crear una aplicación para android que nos permita leer y crear archivos de texto Y SOLO DE TEXTO (Por qué no queremos a un usuario por ahí creando .apk’s ¿Verdad?) ¿Qué es lo que necesitamos para esto?
- Un campo de texto para el título del archivo
- Un campo de texto para el contenido del archivo
- Un botón para crear y un otro para ver los archivos.
Básicamente todo eso mencionado anteriormente son objetos y por ahora estamos bien en cuanto al diseño mental de nuestra aplicación ¿Pero cómo podemos crear semejantes objetos? Muy simple, podemos hacerlo mediante nuestro amigo el Drag&Drop o podemos hacerlo por código como los hombres de antaño (Es mucho más aburrido de lo que parece, realmente).
Primero que pensar en crear los objetos debemos crear un nuevo proyecto asi que vamos a ello.
- Vamos a File->New->Project (Por nada del mundo presionen Java Project, es algo completamente distinto)
- Presionamos donde dice Android y seleccionamos “Android Project” luego “Next” (Voy a asumir que si han llegado hasta aquí es porque tienen un C.I. mayor a 75 y ya tienen su WorkSpace) y en el campo “Name” ponemos el nombre del proyecto una vez hecho esto presionamos “Next”
- Seleccionamos Android 2.3.3
- Dejamos “Application Name” tal cual como esta porque no nos importa.
- En “Package Name” pondremos lo que queramos, yo por lo menos pongo “gabriel.app#” donde el # es un numero cualquiera, pero el punto es que debe ser en minúsculas y llevar un punto, ya más adelante explicare por qué, una vez hecho eso damos finish y tenemos nuestro proyecto.
Como ya tenemos nuestro proyecto creado podemos ir a crear nuestros objetos ¿Cómo? Muy fácil: A la Izquierda del programa tenemos una barra llamada “Package Explorer” que es el… explorador de paquetes. Bueno buscamos nuestro proyecto (Sí recuerdan el nombre todo está bien, no hay porque alarmarse) presionamos la fecha y desplegaremos una lista que más bien es un árbol, en dicho árbol desplegaremos la carpeta “res” y luego “layout” una vez que despleguemos esta última podremos ver un archivo llamado “main.xml” esa es la interfaz de nuestra aplicación por decirlo de alguna forma (pues porque eso mismo es), bueno le damos doble Click para abrirlo.
Si nos decidimos a explorar detenidamente el archivo podemos darnos cuenta que se nos da la opción de ver una vista grafica (“Graphical Layout”) y la vista por código (“main.xml”) explicare ambas vistas pero por ahora vamos con “Graphical Layout” aquí trabajaremos a base de clicks, clicks derechos y Drag&Drop (recuerdan lo que les dije ahí arriba) una vez dicho esto vamos a crear nuestros objetos con el método grafico que llamaremos Drag&Drop.
Vista Drag&Drop
¿Recuerdan lo que necesitábamos? Dos botones y dos campos de texto, sí han trabajado con HTML quizá estén familiarizados con lo que estamos a puntos de hacer, porque básicamente es un formulario, pero vamos a ello, ubiquémonos en el centro de Eclipse, tenemos la barra de la paleta de elementos y junto al lado de ella tenemos la vista previa de lo que hemos hecho (por ahora nuestra aplicación solo se verá decentemente con una vista vertical ya luego desarrollaremos, ya luego haremos aplicaciones que se vean bien horizontal o verticalmente) a esa vista previa es a donde arrastraremos los elementos que requerimos así que comencemos:
- Antes que nada borremos lo que se haya podido crear automáticamente, simplemente seleccionamos cualquier elemento que haya ahí y presionamos suprimir.
- Vamos a la paleta y en “Form Widget” buscamos un “TextView” y lo ponemos a la cabeza de todo (el equivalente a un label).
- Desplegamos “Text Fields” y agreamos un campo de texto normal (el que dice ABC) estos campos se llaman “EditText” (vendrían a ser un input text).
- Repetimos los pasos 2 y 3 y los ponemos uno debajo del otro.
- Desplegamos “Layouts” y agregamos un “LinearLayout (Horizontal)” al final de todo.
- Creamos dos botones y lo ponemos dentro del LinearLayout que creamos en el paso 5.
¡Felicidades! Casi hemos terminado la primera parte de crear una aplicación en Android, lo siguiente que debemos hacer es configurar estos elementos, esto básicamente se hace con click derecho, así que vamos a ello.
- Al primer TextView le daremos Click derecho y buscaremos Edit Text en mi caso sale al recién presionar Click derecho, pero de no ser así iremos a Other Properties->Defined By TextView->Text y ahí escribiremos “Titulo del archivo”.
- Con el mismo TextView, ahora editaremos la ID, buscamos la opción Edit ID y le pondremos tv1 (t de text, v de view y 1 de uno, en el caso de esta aplicación no estaremos utilizando los TextView para programar pero es muy útil seguir un código a la hora de asignar objetos y/o elementos de algún formulario).
- Repetimos los dos pasos anteriores con el otro TextView pero esta vez en el texto pondremos “Contenido del archivo” y el ID será tv2 (porque es el segundo TextView).
- Ahora vamos con los EditText, antes de hacer nada debo decir que no es recomendable editarles el texto a estos elementos ya que se supone que es algo que el usuario puede editar y sería muy fastidioso para el mismo el tener que borrar el contenido que ya está ahí para poner lo que el quiera (ya que no hay un placeholder como en html que al dar click se borra el contenido predispuesto) una vez dicho esto cambiaremos los ID, los llamaremos et1 y et2 (EditText1 y EditText2).
- A nuestros pequeños botoncitos les cambiaremos el texto (con la propiedad text, que se accede buscando edit text o text… en las propiedades) a uno le pondremos “crear” y a otro le pondremos “ver”.
- Nuevamente con nuestros botones, ahora haremos algo muy importante sin lo cual nuestra aplicación no funcionara daremos click derecho->Other Properties->Inherited From View->onClick y en el dialogo que se abrirá para el botón que se llama crear: pondremos “crear” (así en minúsculas y sin las comillas, por favor) y para el que se llama ver le pondremos “ver”.
Ahora sí, hemos terminado de explicar los objetos de una manera visual, ahora vamos con el código el cual nos facilitara muchas cosas.
Vista Codigo
Quizás para muchos el código sea la vista más útil, pero a la hora de disponer los objetos lo mejor es simplemente arrastrarlos de la paleta y luego si se los edita por código, explicare las líneas de la manera más simple que pueda. Pero no garantizo nada.
Antes que nada vamos a donde dice “main.xml” está justo al lado de “Graphical Layout” podremos ver lo siguiente:
<?xml version="1.0" encoding="utf-8"?> //una simple declaracion de un archive xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" //Se abre un element del tipo Linear layout
android:layout_width="fill_parent" //estamos defiendo el ancho del elemento, en este caso le decimos que sea el mismo ancho que su elemento padre.
android:layout_height="fill_parent" //Idem, pero con el alto.
android:orientation="vertical" > //la orientación del mismo.
<TextView //Se abre un element textView
android:id="@+id/tv1" //la id del mismo
android:layout_width="wrap_content" //Aqui le decimos que su ancho sea el necesario para rodear el contenido del mismo.
android:layout_height="wrap_content"//Idem, pero con el alto.
android:text="TextView" /> //El contenido del element y a su vez lo estamos cerrando
<EditText //Se abre un elemento EditText
android:id="@+id/et1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<requestFocus /> //Ponemos el focus en el elemento
</EditText>
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="TextView" />
<EditText
android:id="@+id/et2"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="0.82" //el tamaño total
android:inputType="textMultiLine" /> //Definimos el tipo del elemento, en este caso es un elemento multilinea, el equivalente a un textarea
<LinearLayout
android:id="@+id/linearLayout1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<Button //Un boton
android:id="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="crear" //Lo que hara cuando le demos onclick, es decir un eveneto.
android:text="Crear" />
<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="ver"
android:text="Ver" />
</LinearLayout>
</LinearLayout>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" //Se abre un element del tipo Linear layout
android:layout_width="fill_parent" //estamos defiendo el ancho del elemento, en este caso le decimos que sea el mismo ancho que su elemento padre.
android:layout_height="fill_parent" //Idem, pero con el alto.
android:orientation="vertical" > //la orientación del mismo.
<TextView //Se abre un element textView
android:id="@+id/tv1" //la id del mismo
android:layout_width="wrap_content" //Aqui le decimos que su ancho sea el necesario para rodear el contenido del mismo.
android:layout_height="wrap_content"//Idem, pero con el alto.
android:text="TextView" /> //El contenido del element y a su vez lo estamos cerrando
<EditText //Se abre un elemento EditText
android:id="@+id/et1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<requestFocus /> //Ponemos el focus en el elemento
</EditText>
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="TextView" />
<EditText
android:id="@+id/et2"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="0.82" //el tamaño total
android:inputType="textMultiLine" /> //Definimos el tipo del elemento, en este caso es un elemento multilinea, el equivalente a un textarea
<LinearLayout
android:id="@+id/linearLayout1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<Button //Un boton
android:id="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="crear" //Lo que hara cuando le demos onclick, es decir un eveneto.
android:text="Crear" />
<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="ver"
android:text="Ver" />
</LinearLayout>
</LinearLayout>
Bueno, pues ese es el código sin más ni menos, los que ya conozcan HTML por sus obvios parecidos se les hara más fácil, yo personalmente recomiendo como ya lo dijo que creemos los elementos con el método visual y mediante la vista código le cambiemos sus propiedades, prosigamos.
El programa:
Hasta ahora solo hemos dispuesto de la parte visual de la aplicación, por lo cual la misma aun no hará nada más que mostrar esos elementos, así que comencemos con la lógica del programa:
- Lo primero que vamos a necesitar será almacenar el título del archivo y su contenido en variables del tipo String, ya que el título y el contenido está en diferentes elementos del formularios necesitamos que los mimos sean objetos y proceder a extraer el texto de los mismos.
- Crear las funciones, una para ver documentos y otra para crearlos
- No podemos permitir que se hayan dos archivos con el mismo nombre (imagínense que el usuario cree un documento con el mismo nombre que un archivo esencial para Android) así que tenemos que crear una función que solvente esto, algo que compare el nombre del archivo que queremos crear con todos los archivos que haya en el directorio y si existe, no nos deje hacer guardarlo.
- Aprovechando la ocasión y el hecho de que no sería muy cómodo (al menos no con nuestro diseño actual) el tener que escribir el nombre del archivo para verlo, crearemos un explorador de archivos rudimentario y los archivos se abrirán con un click, para hacer esto necesitamos al menos dos actividades más.
- Los métodos y librerías necesarias para escribir y leer archivos (esos métodos fastidiosos que leer línea por línea, limpiar buffers y esas cosas engorrosas).
Ya tenemos una idea básica que lo que necesitamos, quizá no sea la mejor explicación pero explicare cada línea o cada función de la mejor manera posible en el momento que estas se presentes, por ahora vayamos a nuestro árbol de paquetes, nos ubicamos en la carpeta src, la desplegamos, desplegamos el paquete y luego abrimos el único archivo .java que debería de haber ahí en mi caso se llama App6Activiy.java (mi app se llama app6) y he aquí la parte divertida de nuestra aplicación(no dicho de una forma sarcástica), donde aplicaremos la lógica y todo lo necesario para hacer que nuestra aplicación sea 101% funcional.
En el caso de Android necesitaremos importar archivos (o librerías o clases, mientras escribo esto no recuerdo el nombre exacto) que controlaran diferentes elementos, objetos y/o comportamientos de nuestra aplicación, no sería de extrañar que una aplicación promedio tenga al menos 10 imports, ya que al menos (por lo menos por ahora para mi) no he encontrado clases que por ejemplo controlen todos los objetos relacionados con formularios.
Me explico, si en nuestra aplicación queremos trabajar o interactuar con TextView’s y con EditText’s al mismo tiempo necesitaremos importar clases que controlen estos elementos:
Por ejemplo:
import android.widget.TextView;
import android.widget.EditText;
Ah muy importante, por favor android trabaja con java (o al menos está basado en el mismo) así que la distinción entre mayúsculas y minúsculas está muy presente así que tengan mucho cuidado en ese aspecto.
Como nuestro programa guardara los archivos en la SD, debemos hacer que el mismo tenga los privilegios adecuados para poder escribir un archivo en la misma, para hacerlo buscaremos en nuestro árbol AndroidManifest.XML lo abriremos e iremos a la pestaña Permissions una vez ahí presionaremos Add…->Uses Permission luego en el campo name a la derecha del mismo buscaremos android.permission.WRITE_EXTERNAL_STORAGE, eso quiere decir que nuestra aplicación puede escribir en la memoria externa, aquí es donde añadiremos los privilegios que nuestra aplicación tendrá sobre el equipo y bueno… Ejemplo queremos que nuestra aplicación trabaje con Bluetooth le tenemos que dar un privilegio sobre este y así.
Bueno ya estamos listo así que vamos a programar:
Bueno, vamos a ello:
Primera Actividad:
package gabriel.app6; //El paquete
//importamos las clases necesarias para el manejo de archivos, por ahora más específicamente para llamarlos, buscarlos y escribir en ellos.
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import android.app.Activity;//nuestra actividad
import android.os.Bundle; //la clase más básica, la encargada que los int, char y void funcionen como deben.
import android.os.Environment; //la clase encargada en el menejo del entorno (por ejemplo la SD, muy importante para esta aplicacion).
import android.content.Intent; //La clase que nos permetira llanzar actividades.
//Las clases que controlan los elementos, aquí podemos ver el EditText y el toast (los equivalentes a un alert de javascript)
import android.widget.EditText;
import android.widget.Toast;
import android.view.View;//la clase que permite la interaccion con el usuario en las funciones.
public class App6Activity extends Activity { //la actividad, esto englobara toda lo que hagamos en esta pantalla.
private EditText et1,et2; //creamos dos objetos del tipo EditText
@Override
public void onCreate(Bundle savedInstanceState) { //aunque en este caso no hagamos nada aquí, en el onCreate es donde programaremos todo lo que ha de ser ejecutado en el momento de lanzar la aplicación (por ejemplo en el caso de las listas aquí pondríamos el contenido de las mismas)
super.onCreate(savedInstanceState);
setContentView(R.layout.main); //le especificamos que la interfaz de esta actividad es el archive main
}
public void crear(View v){ //la function crear
//En estas dos líneas estamos ubicando los objetos que recién creamos, me explico: le estamos dicendo al programa que el objeto et1, es un elemento EditText cuya id es et1.
et1=(EditText)findViewById(R.id.et1);
et2=(EditText)findViewById(R.id.et2);
//Recuperamos el contenido de ambas, transformamos el texto de ellas a un string y lo almacenamos en una variable.
String archbusca=et1.getText().toString();
String contenido=et2.getText().toString();
//Creamos un archivo llamado tarjeta y le decimos que nos de (o lo ubique) en la tarjeta de memoria (la externalstorage).
File tarjeta=Environment.getExternalStorageDirectory();
//Ya que la declaracion list() nos dara una lista de los archivos ubicados en la raíz de la tarjeta (la cual previamente se nos entregó en la línea anterior y la almacenamos en tarjeta), almacenaremos dicha lista dentro de una arreglo llamado archivos
String[] archivos=tarjeta.list();
//Una condicional, enviaremos a nuestro boolean (mira más abajo) dos variables: el arreglo archivo y el nombre del archivos (que contendra todos los archivos en el directorio) que nos disponemos a crear (archbusca).
if(existe(archivos,archbusca)){
//Si el return es true, mostraremos un toast. en esta linea estamos definiendo obviamente un toast, luego estamos creando el texto que se mostrara en el mismo "this" hace referencia a esta actividad, el texto entre comillas sera el texto que se mostrara en el mismo y el ultimo parametro es la duracion del mismo, finalmente lo mostramos con show()
Toast.makeText(this,"Ya hay un archivo con ese nombre", Toast.LENGTH_LONG).show();
//si por el contrario el return es false (es decir que el archivo NO existe, procedemos a crearlo con dentro try, catch.
}else{
try{
//creamos un nuevo objeto del tipo file llamado file que sera un nuevo archivo que se llamara con el contenido archbusca mas una terminacion .txt y lo ubicamos donde previamente ubicamos el archivo tarjeta (con la declaracion getAbsolutePath
File file=new File(tarjeta.getAbsolutePath(),archbusca+".txt");
//Esta parte es bastante engorrosa, así que intenare explicarla de la mejor manera posible partiendo de lo que comprendo
//creamos un objeto OutputStreamWriter que nos servira de puente entre lo que hay escrito actualmente y la memoria y le decimos que va a realizar sus operaciones dentro del archivo file
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(file));
//escribimos contenido dentro de file.
osw.write(contenido);
//limpiamos dicho puente, para que no ocupe espacio dentro de la memoria
osw.flush();
//cerramos dicho puente
osw.close();
//limpiamos el contenido de ambos elementos y estan listos para escribir nuevamente
et1.setText("");
et2.setText("");
//le decimos al usuario que su archivo se creo
Toast.makeText(this, "Archivo creado Correctamente", Toast.LENGTH_SHORT).show();
}catch (IOException ioe){}
}
}
//creamos nuestro boolean, una variable que nos retornara un valor verdadero o falso, en este caso la usaremos para ver si un archivo existe o no.
//partimos recibiendo dos variables, un arreglo llamado archivos y un string llamado archbusca (hasta donde sé no es escencial que se llamen igual que las creadas allá arriba)
private boolean existe(String[] archivos, String archbusca){
//Un ciclo normal de toda la vida que se repita un numero de veces igual al la longitud del arreglo.
for(int f=0 ;f < archivos.length; f++)
//Sí archbusca es igual a archivos en la posicion F (es decir sí hay dos archivos con el mismo nombre) retornara true, de lo contrario nos retornara falso.
if(archbusca.equals(archivos[f]))
return true;
return false;}
//La funcion ver, una funcion que interactua con el usuario esta funcion lanzara una nueva actividad llamda Ver y nos llevara a ella.
public void ver(View view){
startActivity(new Intent(this,Ver.class));}
}
//importamos las clases necesarias para el manejo de archivos, por ahora más específicamente para llamarlos, buscarlos y escribir en ellos.
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import android.app.Activity;//nuestra actividad
import android.os.Bundle; //la clase más básica, la encargada que los int, char y void funcionen como deben.
import android.os.Environment; //la clase encargada en el menejo del entorno (por ejemplo la SD, muy importante para esta aplicacion).
import android.content.Intent; //La clase que nos permetira llanzar actividades.
//Las clases que controlan los elementos, aquí podemos ver el EditText y el toast (los equivalentes a un alert de javascript)
import android.widget.EditText;
import android.widget.Toast;
import android.view.View;//la clase que permite la interaccion con el usuario en las funciones.
public class App6Activity extends Activity { //la actividad, esto englobara toda lo que hagamos en esta pantalla.
private EditText et1,et2; //creamos dos objetos del tipo EditText
@Override
public void onCreate(Bundle savedInstanceState) { //aunque en este caso no hagamos nada aquí, en el onCreate es donde programaremos todo lo que ha de ser ejecutado en el momento de lanzar la aplicación (por ejemplo en el caso de las listas aquí pondríamos el contenido de las mismas)
super.onCreate(savedInstanceState);
setContentView(R.layout.main); //le especificamos que la interfaz de esta actividad es el archive main
}
public void crear(View v){ //la function crear
//En estas dos líneas estamos ubicando los objetos que recién creamos, me explico: le estamos dicendo al programa que el objeto et1, es un elemento EditText cuya id es et1.
et1=(EditText)findViewById(R.id.et1);
et2=(EditText)findViewById(R.id.et2);
//Recuperamos el contenido de ambas, transformamos el texto de ellas a un string y lo almacenamos en una variable.
String archbusca=et1.getText().toString();
String contenido=et2.getText().toString();
//Creamos un archivo llamado tarjeta y le decimos que nos de (o lo ubique) en la tarjeta de memoria (la externalstorage).
File tarjeta=Environment.getExternalStorageDirectory();
//Ya que la declaracion list() nos dara una lista de los archivos ubicados en la raíz de la tarjeta (la cual previamente se nos entregó en la línea anterior y la almacenamos en tarjeta), almacenaremos dicha lista dentro de una arreglo llamado archivos
String[] archivos=tarjeta.list();
//Una condicional, enviaremos a nuestro boolean (mira más abajo) dos variables: el arreglo archivo y el nombre del archivos (que contendra todos los archivos en el directorio) que nos disponemos a crear (archbusca).
if(existe(archivos,archbusca)){
//Si el return es true, mostraremos un toast. en esta linea estamos definiendo obviamente un toast, luego estamos creando el texto que se mostrara en el mismo "this" hace referencia a esta actividad, el texto entre comillas sera el texto que se mostrara en el mismo y el ultimo parametro es la duracion del mismo, finalmente lo mostramos con show()
Toast.makeText(this,"Ya hay un archivo con ese nombre", Toast.LENGTH_LONG).show();
//si por el contrario el return es false (es decir que el archivo NO existe, procedemos a crearlo con dentro try, catch.
}else{
try{
//creamos un nuevo objeto del tipo file llamado file que sera un nuevo archivo que se llamara con el contenido archbusca mas una terminacion .txt y lo ubicamos donde previamente ubicamos el archivo tarjeta (con la declaracion getAbsolutePath
File file=new File(tarjeta.getAbsolutePath(),archbusca+".txt");
//Esta parte es bastante engorrosa, así que intenare explicarla de la mejor manera posible partiendo de lo que comprendo
//creamos un objeto OutputStreamWriter que nos servira de puente entre lo que hay escrito actualmente y la memoria y le decimos que va a realizar sus operaciones dentro del archivo file
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(file));
//escribimos contenido dentro de file.
osw.write(contenido);
//limpiamos dicho puente, para que no ocupe espacio dentro de la memoria
osw.flush();
//cerramos dicho puente
osw.close();
//limpiamos el contenido de ambos elementos y estan listos para escribir nuevamente
et1.setText("");
et2.setText("");
//le decimos al usuario que su archivo se creo
Toast.makeText(this, "Archivo creado Correctamente", Toast.LENGTH_SHORT).show();
}catch (IOException ioe){}
}
}
//creamos nuestro boolean, una variable que nos retornara un valor verdadero o falso, en este caso la usaremos para ver si un archivo existe o no.
//partimos recibiendo dos variables, un arreglo llamado archivos y un string llamado archbusca (hasta donde sé no es escencial que se llamen igual que las creadas allá arriba)
private boolean existe(String[] archivos, String archbusca){
//Un ciclo normal de toda la vida que se repita un numero de veces igual al la longitud del arreglo.
for(int f=0 ;f < archivos.length; f++)
//Sí archbusca es igual a archivos en la posicion F (es decir sí hay dos archivos con el mismo nombre) retornara true, de lo contrario nos retornara falso.
if(archbusca.equals(archivos[f]))
return true;
return false;}
//La funcion ver, una funcion que interactua con el usuario esta funcion lanzara una nueva actividad llamda Ver y nos llevara a ella.
public void ver(View view){
startActivity(new Intent(this,Ver.class));}
}
Como pudimos ver ahí arriba hemos lanzado otra actividad donde se suponía que debemos ver los archivos que ya existen, en este caso hemos escrito la función de manera que solo nos lleve a esta nueva actividad que ha lanzado, no hemos pasado ningún parámetro ni nada por el estilo. Pero ¿Cómo podemos hacer para que esta nueva actividad se ejecute? Lamentablemente no basta con solo decirle que la ejecute ya que la actividad en la que estamos ahorita (y el mismo paquete) no saben que siquiera existe la actividad “Ver” así que debemos decírselo.
Segunda Actividad:
Pero antes de decirle que existe, vamos a hacer que exista, en nuestro árbol en el directorio del paquete (que en mi caso se llama gabriel.app6) daremos click derecho->new->class y se nos abrirá una ventana con diferentes campos en el campo name pondremos el nombre, el que queramos (yo la llamare Ver), pero es recomendable que el primer carácter sea en mayúsculas y en el campo superclass (que por default contendrá java.lang.Object) pondremos android.app.Activity y ya, tenemos el código de nuestra segunda actividad, pero aún nos falta decirle a android que nuestra actividad existe.
En nuestro árbol buscaremos un archivo de nuevo a AndroidManifest.xml pero esta vez iremos a la pestaña Application y luego bajaremos el scroll hasta encontrar un cuadro llamado Application Nodes le damos add y:
- Primero que todo debemos tener marcado “Create New Level at The Top Level, in Application”
- Seleccionamos Activity (la del icono azul una A)
- A la derecha tendremos un campo que se llama name, ahí pondremos el nombre de la clase que recién creamos (la actividad)
Ahora ya podemos programar en ella ¿Qué haremos? Antes que nada necesitamos una interfaz para la misma así que vamos a nuestro árbol hasta la carpeta layout, le damos click derecho y new->other->android->Android XML file y le pondremos el nombre, preferiblemente que se llame igual a la actividad a la cual pertenece por ejemplo si nuestra actividad se llama Ver, que nuestro XML se llame ver y vamos a crear un elemento ListView, para ello vamos a la pestaña de Graphical Layout, desplegamos composite y agregamos un ListView cuyo id será lv1.
Por fin, todo listo para programar de nuevo, vemos a nuestra nueva actividad (para mí se llama Ver) y antes vamos a pensar ¿Qué haremos?
- Tenemos una lista en la cual se mostraran los archivos del directorio dinámicamente.
- Solo debemos mostrar los archivos .txt
- Cuando demos click en un elemento de esa lista se debe abrir una nueva actividad donde se verá el archivo con dicho elemento (es decir, pasaremos una variable entre actividades, en este caso el nombre del archivo que se abrirá)
package gabriel.app6;
import java.io.File; //la clase encargada del manejo de archivos, en este caso nos dara el directorio
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.widget.ListView; //la clase encargada del ListView
import android.view.View;
import android.content.Intent;
//Estas son las clases que usaremos para controlar el contenido de las listas, como las dispondremos en base a un arreglo
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
public class Ver extends Activity {
private ListView lv1; //creamos un objeto del tipo ListView
private String[] archivos;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ver);
lv1=(ListView)findViewById(R.id.lv1); //definimos el objeto
File tarjeta=Environment.getExternalStorageDirectory(); //ubicamos tarjeta en el direcotrio de la SD
archivos=tarjeta.list(); //la lista de archivos en el directorio
int y=0,x=0;
String name;
//Un ciclo para determinar la cantidad de archivos .txt
for(x=0;x<archivos.length;x++){
name=archivos[x];
if(name.endsWith(".txt"))
y++;}
//un arreglo con con el tamaño de los archivos .txt
String[] nombres=new String[y];
y=0;
//guardamos los nombres de los archivos .txt
for(x=0;x<archivos.length;x++){
name=archivos[x];
if(name.endsWith(".txt")){
nombres[y]=archivos[x];
y++;}}
//En esta linea estamos determinando el contenido de cada item de la lista mediante un arreglo, es decir haremos que cada elemento de la lista sea igual a un elemento del arreglo
lv1.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, nombres));
//Ahora cada vez que demo click en un elemento de la lista se ejecutara una funcion
lv1.setOnItemClickListener(new OnItemClickListener(){
//Esta sera la funcion a ejecutarse, que mediante la variable x nos dira que elemento de la lista es (recordemos que lo trata como un arreglo)
public void onItemClick(AdapterView<?> parent, View v, int x, long id){
//Aqui lanzamos otra actividad, la unica diferencia respecto al anterior es que estamos utilizando la declaracion putextra para enviar una parametro, en este caso una string que contiene el nombre del archivo que vamos a abrir.
startActivity(new Intent(Ver.this,Ver2.class).putExtra("archname", ""+lv1.getItemAtPosition(x)));
}
});
}
}
import java.io.File; //la clase encargada del manejo de archivos, en este caso nos dara el directorio
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.widget.ListView; //la clase encargada del ListView
import android.view.View;
import android.content.Intent;
//Estas son las clases que usaremos para controlar el contenido de las listas, como las dispondremos en base a un arreglo
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
public class Ver extends Activity {
private ListView lv1; //creamos un objeto del tipo ListView
private String[] archivos;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ver);
lv1=(ListView)findViewById(R.id.lv1); //definimos el objeto
File tarjeta=Environment.getExternalStorageDirectory(); //ubicamos tarjeta en el direcotrio de la SD
archivos=tarjeta.list(); //la lista de archivos en el directorio
int y=0,x=0;
String name;
//Un ciclo para determinar la cantidad de archivos .txt
for(x=0;x<archivos.length;x++){
name=archivos[x];
if(name.endsWith(".txt"))
y++;}
//un arreglo con con el tamaño de los archivos .txt
String[] nombres=new String[y];
y=0;
//guardamos los nombres de los archivos .txt
for(x=0;x<archivos.length;x++){
name=archivos[x];
if(name.endsWith(".txt")){
nombres[y]=archivos[x];
y++;}}
//En esta linea estamos determinando el contenido de cada item de la lista mediante un arreglo, es decir haremos que cada elemento de la lista sea igual a un elemento del arreglo
lv1.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, nombres));
//Ahora cada vez que demo click en un elemento de la lista se ejecutara una funcion
lv1.setOnItemClickListener(new OnItemClickListener(){
//Esta sera la funcion a ejecutarse, que mediante la variable x nos dira que elemento de la lista es (recordemos que lo trata como un arreglo)
public void onItemClick(AdapterView<?> parent, View v, int x, long id){
//Aqui lanzamos otra actividad, la unica diferencia respecto al anterior es que estamos utilizando la declaracion putextra para enviar una parametro, en este caso una string que contiene el nombre del archivo que vamos a abrir.
startActivity(new Intent(Ver.this,Ver2.class).putExtra("archname", ""+lv1.getItemAtPosition(x)));
}
});
}
}
Tercera Actividad:
Solo nos falta la última actividad, la crearemos y la pondremos en el manifiesto repitiendo los mismos pasos que utilizamos para el crear la actividad pasada junto a su archivo XML al cual le pondremos un EditText con un id et1.
En esta actividad lo único que haremos será recuperar el parámetro que pasamos desde la actividad pasada y leer un archivo con ese nombre.
package gabriel.app6;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import java.io.BufferedReader;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.widget.EditText;
public class Ver2 extends Activity {
private EditText et1;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ver2);
et1=(EditText)findViewById(R.id.et1);
String nombre=getIntent().getExtras().getString("archname"); //recuperamos la string que enviamos desde el otro activity
File tarjeta=Environment.getExternalStorageDirectory();
File file=new File(tarjeta.getAbsolutePath(), nombre); //buscamos el archivo con el nombre que enviamos
try{
//Otro puente, pero esta vez desde algo ya creado, a la memoria para llevarse a un elemento del formulario (xD?)
FileInputStream fis=new FileInputStream(file);
InputStreamReader archivo=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(archivo);
//leemos una linea
String linea=br.readLine();
String todo="";
//este ciclo se repetira mientras una linea no sea nula (es decir, hasta que consiga el final del archivo)
while(linea!=null){
todo=todo+linea+"\n";
linea=br.readLine();}
br.close();//cerramos el buffer
archivo.close();//y el archivo
et1.setText(todo);//mostramos lo que leimos
}
catch(IOException ioe){}
}
}
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import java.io.BufferedReader;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.widget.EditText;
public class Ver2 extends Activity {
private EditText et1;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ver2);
et1=(EditText)findViewById(R.id.et1);
String nombre=getIntent().getExtras().getString("archname"); //recuperamos la string que enviamos desde el otro activity
File tarjeta=Environment.getExternalStorageDirectory();
File file=new File(tarjeta.getAbsolutePath(), nombre); //buscamos el archivo con el nombre que enviamos
try{
//Otro puente, pero esta vez desde algo ya creado, a la memoria para llevarse a un elemento del formulario (xD?)
FileInputStream fis=new FileInputStream(file);
InputStreamReader archivo=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(archivo);
//leemos una linea
String linea=br.readLine();
String todo="";
//este ciclo se repetira mientras una linea no sea nula (es decir, hasta que consiga el final del archivo)
while(linea!=null){
todo=todo+linea+"\n";
linea=br.readLine();}
br.close();//cerramos el buffer
archivo.close();//y el archivo
et1.setText(todo);//mostramos lo que leimos
}
catch(IOException ioe){}
}
}
Y así termina nuestro programa, ya que no deberíamos tener ningún problema.
Para correrlo presionamos el botón de “Play” y si nos pregunta elegimos aplicación de Android, esperamos que nuestro dispositivo virtual inicie y podemos probar nuestra aplicación.
Como nota final debo decir que obviamente existen mejores maneras de crear y leer archivos de texto, pero ese no es el punto de esta aplicación sino por el contrario el aplicar diferentes conocimientos básicos de programación y llevarlos a Android, como pudimos ver tratamos algunos objetos, diseñamos un XML trabajamos con la ruta de la SD y otro par de cosas más.
mmmm me gustan los chicos listos.....
ResponderEliminar