curso android 2014 completo

PROGRAMACIÓN ANDROID CON ECLIPSE

DESARROLLADO POR: FREDDY BENDEZÚ FIGUEROA

CONTENIDO

crear un proyecto en eclipse ............................................................................................................................ 3

Estructura básica de un proyecto Android ................................................................................................ 7

Archivo de recursos de dimensiones ............................................................................................................ 8

Uso de colores desde XML ................................................................................................................................. 9

Colores ..................................................................................................................................................................... 10

Valores literales .............................................................................................................................................. 10

Archivo de recursos de colores ................................................................................................................ 10

Uso de colores desde XML .......................................................................................................................... 13

Ejemplo de uso de botones y campos de texto ....................................................................................... 15

Archivo AndroidManifest.xml ........................................................................................................................ 16

Pestaña Manifest ............................................................................................................................................ 17

Pestaña Application ...................................................................................................................................... 18

Pestaña Permissions ..................................................................................................................................... 19

Pestaña Instrumentation ............................................................................................................................ 19

Pestaña AndroidManifest.xml ................................................................................................................... 20

manejo de controles (Edittext, textview, button) .................................................................................. 21

CÓDIGO PARA EL FUNCIONAMIENTO DE LA CALCULADORA ........................................................ 26

Paso de datos entre actividades ................................................................................................................... 28

USO DEL CONTROL SPINNER ........................................................................................................................ 34

CREACIÓN de MENÚS ....................................................................................................................................... 43

Manejo de Clases y uso del control RadioGroup .................................................................................... 47

Manejo del control checkbox ......................................................................................................................... 51

Listas ........................................................................................................................................................................ 53

ListView ............................................................................................................................................................. 53

Obtener la posición seleccionada ............................................................................................................ 55

Manejo de base de datos SQLite ................................................................................................................... 56

Registrar, eliminar, modificar y consultar SQLite ................................................................................. 60

Uso de GPS ............................................................................................................................................................. 68

Obtener el IMEI del dispositivo. .................................................................................................................... 72

Uso de GoogleMaps ............................................................................................................................................ 74

CURSO PROGRAMACIÓN ANDROID CON ECLIPSE

3 | P á g i n a F R E D D Y B E N D E Z U F I G U E R O A

CREAR UN PROYECTO EN ECLIPSE

Presionar Ctrl + N Para Crear un nuevo proyecto en Eclipse, seleccionar la opcion Android Application Project y luego clic en Next

Escribir “Calculadora” en el cuadro de Application Name que será el nombre del Proyecto y luego presionar Next.



Presionar el botón Next.





Seleccionar Blank Activity y presionar el botón Next.



En el cuadro de Activity Name escribir “Inicio”, que será el nombre de la primera actividad, luego presionar el botón Finish

De esa manera acabamos de crear un proyecto en eclipse para android.



ESTRUCTURA BÁSICA DE UN PROYECTO ANDROID

Lo primero que debemos tener claro para comenzar a desarrollar una aplicación Android es la estructura de carpetas de un proyecto estándar. Para ello, se muestra la estructura de un proyecto.

src:

En ella se almacenan las clases java que contienen la lógica de nuestra aplicación.

gen:

Clases autogeneradas por el entorno de desarrollo. Contienen referencias a los elementos que definamos en la zona de recursos, como veremos más adelante.

assets:

Aquí va todo lo que no encaja en ninguna otra carpeta. Básicamente es una estructura de carpetas y archivos que nuestra aplicación puede indexar, recorrer y utilizar sin necesidad de acceder a ellos como recursos.

bin:

Aplicación compilada.

res:

En ella se almacenan todos los recursos de nuestra aplicación, ya sean imágenes, estructura de pantallas, estilos de la aplicación, vídeos, etc.

En las carpetas drawable se guardarán las imágenes que utiliza la aplicación. Cada dispositivo android tiene una resolución de pantalla y una densidad en píxeles por pulgada. Por ello es necesario crear imágenes con resolución distinta para pantallas distintas. Estas tres carpetas distinguen qué imágenes se utilizarán para pantallas de alta densidad (hdpi),

media (mdpi) y baja (ldpi).

Layout:

Guarda ficheros XML que contienen la estructura de los componentes que vamos a mostrar en nuestra aplicación, ya sean pantallas completas o controles personalizados.



Values

Consiste en un conjunto de recursos definidos en XML, como son la declaración de las pantallas de nuestra aplicación, o las cadenas de textos que se mostrarán en la misma. Estas últimas también tienen un archivo generado desde el principio: strings.xml. Es muy recomendable que desde el principio todas las cadenas de texto se almacenen en él, porque facilitarán en gran medida la traducción a otros idiomas.

AndroidManifest.xml:

Almacena la información general de la aplicación, como el nombre, la versión de Android, las pantallas que tiene, el tema, etc.

ARCHIVO DE RECURSOS DE DIMENSIONES

Las dimensiones pueden almacenarse en un archivo de recursos XML como cualquier otro recurso en las aplicaciones Android. También en este caso, el archivo debe almacenarse en la carpeta res/values. El archivo puede tener cualquier nombre aunque es habitual nombrarlo como dimens.xml.

Si no existe ese archivo en tu proyecto, puedes crearlo desde Eclipse usando el menú File o el menú contextual del proyecto, seleccionando la opción New > Android XML File. En la primera ventana del asistente para la creación del archivo XML selecciona o comprueba que está seleccionado el tipo de recurso Values, y en el nombre del archivo indica, como se recomienda, dimens.xml.

A continuación puedes ver un ejemplo de dicho archivo con dos dimensiones declaradas:

Desde el editor visual puedes gestionar también las dimensiones declaradas. Desde ahí puedes añadir nuevas dimensiones, editar, eliminar y ordenarlas. Para añadir nuevas dimensiones, tan sólo debes usar el botón Add y elegir en la lista la opción Dimension.



En la parte derecha aparece el detalle de la dimensión que se está añadiendo o editando, donde se debe indica un nombre para la dimensión, y su valor asociado siguiendo uno de los formatos comentados anteriormente.

Recuerda guardar los cambios usando la combinación de teclas Ctrl+S o el menú File > Save.

USO DE COLORES DESDE XML

Puedes asignar un valor literal a cualquier propiedad de un objeto View que admita una dimensión. Por ejemplo, el tamaño de texto o el tamaño de los márgenes. Si quieres establecer una dimensión usando su valor literal, tan sólo debes indicar dicho valor en la propiedad adecuada. Por ejemplo, en la siguiente imagen se ha establecido la dimensión 10dp a la propiedad TextSize

Para hacer referencia a una dimensión declarada en el archivo de recursos dimens.xml desde otro fichero XML (por ejemplo, desde un layout), debes usar el formato habitual para hacer referencia a un recurso desde XML, indicando en este caso que es un recurso de tipo dimen:



@dimen/nombre_dimensión

Por ejemplo, si se quiere cambiar el tamaño del texto de un TextView debes indicar la referencia a la dimensión en la propiedad Text Size.

COLORES

A diferentes objetos View de los layouts se les puede asignar colores. Por ejemplo, a un TextView se le puede asignar un color para el texto o un color para el fondo.

Al igual que ocurre con muchos otros elementos utilizados en el desarrollo de aplicaciones para Android, los valores se pueden asignar literalmente (indicando directamente el valor numérico correspondiente al color), o hacer referencia a un recurso declarado previamente.

VALORES LITERALES

Para indicar un valor de manera literal, se puede usar uno de los siguientes formatos:

#RGB

#ARGB

#RRGGBB

#AARRGGBB

Donde R hace referencia al valor para el color rojo, G para el color verde, B para el color azul y A para el canal alfa (opacidad). Cada valor se indica con un dígito hexadecimal (0 a F). Por ejemplo, el color rojo puro se puede indicar como #F00, o el color rosa intenso como #FF1493. En la página de Wikipedia Colores HTML puedes ver los códigos correspondientes a multitud de colores.

ARCHIVO DE RECURSOS DE COLORES

En el archivo res/values/colors.xml (el nombre del archivo puede ser otro, pero se recomienda colors.xml) del proyecto puedes almacenar colores a los que les asignas un nombre que utilizarás desde el código Java o desde otros archivos XML.

http://javiergarbedo.es/index.php/desarrollo-android/80-primeros-pasos/282-colores



Si no existe ese archivo en tu proyecto, puedes crearlo desde Eclipse usando el menú File o el menú contextual del proyecto, seleccionando la opción New > Android XML File. En la primera ventana del asistente para la creación del archivo XML selecciona o comprueba que está seleccionado el tipo de recurso Values, y en el nombre del archivo indica colors.xml.

La siguiente pantalla te permite elegir los cualificadores que marcarán la configuración sobre la que quieres aplicar los colores que vas a declarar en este archivo XML. Como en otros casos, si no indicas ningún cualificador, crearás definiciones de colores para la configuración por defecto.



Una vez creado podrás acceder a él desde la carpeta res/values.

El formato del archivo XML es el habitual del utilizado en los demás recursos. Por ejemplo:

Desde el editor visual puedes gestionar también los colores declarados. Desde ahí puedes añadir nuevos colores, editar, eliminar y ordenarlos. Para añadir nuevos colores, tan sólo debes usar el botón Add y elegir en la lista la opción Color.



En la parte derecha aparece el detalle del color que se está añadiendo o editando, donde se debe indica un nombre para el color, y su valor asociado siguiendo uno de los formatos comentados anteriormente.

Guardar los cambios usando la combinación de teclas Ctrl+S o el menú File > Save.

USO DE COLORES DESDE XML

Puedes asignar un valor literal a cualquier propiedad de un objeto View que admita un color. Por ejemplo, el color de texto o el color de fondo. Si quieres establecer un color usando su valor literal, tan sólo debes indicar dicho valor en la propiedad adecuada. Por



ejemplo, en la siguiente imagen se ha establecido el color #00FF00 a la propiedad TextColor.

Para hacer referencia a un color declarado en el archivo de recursos colors.xml desde otro fichero XML (por ejemplo, desde un layout), debes usar el formato habitual para hacer referencia a un recurso desde XML, indicando en este caso que es un recurso de tipo color:

@color/nombre_color

Por ejemplo, si se quiere cambiar el color del texto de un TextView debes indicar la referencia al color en la propiedad Text Color.



EJEMPLO DE USO DE BOTONES Y CAMPOS DE TEXTO

El siguiente ejemplo es una sencilla aplicación que permite al usuario copiar el texto que introduce en el primer campo de texto en otro campo de texto usando un botón.

La estructura visual de la pantalla es la siguiente:

Que corresponde al siguiente layout en XML:



Para que el botón realice la copia del texto que se encuentre en el primer campo de texto al segundo campo de texto, puedes usar un código similar al siguiente en la Activity:

ARCHIVO ANDROIDMANIFEST.XML

El fichero AndroidManifest.xml que debe tener cualquier aplicación Android en su carpeta principal, contiene información que debe conocer el sistema sobre la aplicación. Entre otras cosas contiene lo siguiente:

Nombre del paquete Java para la aplicación. Este nombre sirve como un identificador único de la aplicación.

Describe los componentes de la aplicación (activities, services, broadcast receivers y content providers). Se nombran las clases que los implementan y se publican sus capacidades. Así el sistema puede conocer los componentes que hay y bajo qué condiciones se iniciarán.

Declara los permisos que la aplicación debe tener para poder acceder a determinadas parter protegidas de la API o para interactuar con otras aplicaciones.

Lista las clases Instrumentation que permiten monitorizar la interacción de la aplicación con el sistema. Estas declaraciones sólo se usarán mientras la aplicación está en la fase de desarrollo, y se eliminarán antes de publicarla.

Declara el nivel mínimo de la API Android que requiere la aplicación.

Lista las bibliotecas con las que la aplicación debe estar enlazada.

Eclipse permite modificar los valores de este fichero de una forma gráfica, separando la información en varias pestañas que puedes ver en la parte inferior de la ventana que aparece al abrir este fichero.



PESTAÑA MANIFEST

En una aplicación básica contiene información sobre la versión de la misma y algunos extras como la versión mínima de SDK requerida y hacia la que va dirigida la aplicación.



PESTAÑA APPLICATION

Inicialmente contiene el tema o plantilla que va a utilizar la aplicación en sus pantallas, el nombre de la aplicación y su icono. Además refleja que contiene la activity llamada MainActivity a la que se le aplica el filtro de activity principal (main) y el filtro de launcher que informa al sistema que dicha activity debe ser incluida en la lista de lanzadores de aplicaciones.



PESTAÑA PERMISSIONS

Inicialmente se muestra vacía y puede contener los permisos que debe aceptar el usuario para que la aplicación pueda ejecutarse.

PESTAÑA INSTRUMENTATION

Inicialmente vacía y en la que se pueden indicar una serie de clases que permiten monitorizar la interacción de la aplicación con el sistema.



PESTAÑA ANDROIDMANIFEST.XML

Muestra y permite editar el contenido del fichero. Sólo contiene las etiquetas que han sido configuradas, lo que en ocasiones permite una visión más sencilla que usando las ventanas anteriores.



MANEJO DE CONTROLES (EDITTEXT, TEXTVIEW, BUTTON)

Arrastrar el control TextView hacia el Layout

Arrastrar el control EditText (Number Decimal) hacia el Layout



Repetir los pasos hasta logar el siguiente diseño:

Seleccionar el primer TextView y buscar la propiedad Text, luego hacer clic en los puntos suspensivos.

Hacer clic en el botón New String



En el cuadro New R.string escribir “titulo1” y en el cuadro String escribir “Ingresar un Número”.

Nota: La propiedad Text se maneja igual Para todo los controles.

Seleccionar el primer EditText y buscar la propiedad ID, luego hacer clic en los puntos suspensivos.



En el cuadro de New Name, escribir el nombre de identificador “txtNumero1” y clic en Ok.

El nombre de todos los EditText debe quedar de la siguiente manera.

Seleccionar el primer botón y en la propiedad On Click Digitar “cSumar”, el segundo botón “cMultiplicar” y el tercero “cDividir”



El diseño debe quedar de la siguiente manera.



CÓDIGO PARA EL FUNCIONAMIENTO DE LA CALCULADORA

Doble clic en el archivo “Inicio.java”

Se muestra la siguiente codificación:



Para el funcionamiento de nuestra aplicación debemos escribir la siguiente codificación.



PASO DE DATOS ENTRE ACTIVIDADES

Una de las cosas más habituales cuando desarrollamos una aplicación para Android, es poder “enviar” datos (variables, objetos, etc.) desde una Activity a otra. En términos generales, una Activity es una “pantalla” de nuestra aplicación.

Para realizar esta tarea, Android pone a nuestra disposición los llamados “Intent“. En general, utilizaremos un Intent cuando queramos movernos de una actividad a otra, permitiéndonos a su vez pasar datos desde la Activity en la que estamos hacia la nueva.

Esta vez crearemos una aplicación escribiendo todo el código e incluso la interfaz lo crearemos mediante código. Tenemos una aplicación donde el usuario tiene que introducir su nombre y contraseña y cuando le da a “Acceder”, el sistema comprueba si ese usuario está registrado o no.

En la primera actividad, definimos la interfaz y donde el usuario introduce los datos de registro (activity_main.xml)

En la segunda actividad, el sistema comprueba si el usuario está registrado, y muestra un mensaje.

Para enviar y recibir datos entre la 1ªactividad y la 2ª actividad utilizamos los objetos Bundle e Intent.

La interfaz sería de la siguiente manera:



Esta sería la primera actividad cuyo nombre es activity_main.xml, y el código es el siguiente:



La segunda actividad (actividad_validar.xml) (donde se muestra si el usuario está registrado o no) sólo tendrá un textview donde se mostrará un mensaje:

Por otro lado, están los recursos que se definen en strings.xml, donde se declaran los títulos de los textview, button, etc. Además los usuarios registrados en el sistema, y que después recogerermos en un array de strings:

Ya están todos los recursos y controles definidos (lo que sería la interfaz), ahora vamos a la programación en Java, en el MainActivity.java recogeremos los datos introducidos por el usuario y usaremos Bundle para enviarlos a la otra actividad.



Estos datos serán enviados a la actividad, actividad_validar, que será gestionada por Validar.java, que comprobará si el usuario está registrado en la aplicación, y mostrará un mensaje. Para obtener los datos también se usará el objeto Bundle, como se ve en el código.



Comprobamos nuestra aplicación.



USO DEL CONTROL SPINNER

Veremos cómo navegar por medio de diferentes pantallas al hacer clic sobre un botón y a la vez pasar datos de una actividad a otra.

La aplicación consiste en registrar los datos de tareas asignadas a un determinado profesional informáticos las cuales pueden ser tareas de Soporte, Desarrollo y Diseño, aparte de eso se debe de registrar el nombre de la persona asignada para dicha tarea y finalmente se debe registrar la descripción de la tarea asignada.

Creamos un nuevo proyecto de Android (Ctrl + N) con el nombre “PasarDatos”

Presionar Next hasta finalizar

Creamos una actividad (Ctrl + N) llamada DatosEenviados

Presionar Siguiente hasta finalizar



Diseñar la interfaz de la primera actividad.

Para que podamos tener la posibilidad de elegir un tipo de tarea asignada a registrar necesitamos insertar en este layout un control Spinner (combobox o dropdownlistbox) en otros lenguajes de programación, pero para que este control tenga la lista de tipos de tarea a asignar debemos de llenar de alguna manera esos valores hacía el control Spinner.

Presionar (Ctrl +N) / Entrar a la Carpeta Android /Seleccionar Android XML Values File y Presionar Next



Digitar el nombre del archivo “tareas” y presionar “Finish”

Presionar el botón Add

Seleccionar String Aray y Presionar Ok



Presionar el botón Add para agregar elementos al String Array

Presionar el Boton Ok para crear un Item

Ingresar el primer dato del Array en el cuadro de Value “Soporte”

Repetir los pasos para agregar “Desarrollo” y “Diseño”



Relacionamos el Spinner con el recurso creado “tareas.xml”, hacemos clic derecho sobre el Spinner / Edit Entiries.

Seleccionar Array / Tareas.

Diseñar la interfaz de la segunda actividad



Ahora programaremos la primera actividad doble clic en el MainActivity.java

Escribimos el siguiente Código:



Explicando el código:

En primer lugar necesitamos definir las variables que se utilizarán para pasar los respectivos valores a la ventana de confirmación de tarea registrada.

En el método onCreate de la actividad seteamos las variables descritas en el código anterior a los controles de la actividad principal:

Creamos el método que nos permitirá enviar los datos de la primera actividad (registro de tarea asignada) a la actividad de confirmación de registro de tarea asignada:



Las variables valor1, valor2 y valor3 son las que van a permitir enviar sus correspondientes valores a la otra ventana.

Ahora programamos la funcionalidad de la ventana DatosEnviados (ventana de confirmación de registro de tarea asignada), para acceder al código hacemos doble clic en DatosEnviados.java

Escribimos el siguiente Código:



Probamos la aplicación:



CREACIÓN DE MENÚS

Un docente de una determinada Universidad Desea tener un registro completo de todas las diferentes calificaciones que un alumno a obtenido en la asignatura que el enseña, en este caso tomaremos el caso de que la Asignatura es el Curso de Matemáticas I.

Las opciones que debe de contemplar el Sistema de Notas son:

Registro de Calificaciones.

Búsqueda de Calificaciones.

Edición de Calificaciones.

Creamos un nuevo proyecto Android con el nombre “UsoMenu”

Agregamos un nuevo archivo (Ctrl + N) de tipo Android XML File



Seleccionar Menu en Resource Type, digitar el nombre del archivo “menuprincipal” y luego clic en Finish.

Presionar el botón Add para agregar un elemento al menú.

Seleccionar Item y presionar Ok.



Digitar en Identificador y el título del menú tal como se muestra en la imagen

Nuevamente presionar el botón Add para agregar otro elemento al menú

Digitar en Identificador y el título del menú tal como se muestra en la imagen, repetir el proceso para agregar un tercer elemento



Revisar el código de la actividad principal y corregir el nombre del menú “menuprincipal”.

Comprobamos nuestra aplicación. Presionar el botón menú del dispositivo Android



MANEJO DE CLASES Y USO DEL CONTROL RADIOGROUP

El concepto clave de la POO es la clase. Una clase no es más que un concepto (como mesa o perro), que a la hora de implementarlo se compone de conjunto de variables (que conforman su estado) junto con un conjunto de funciones que se aplican sobre ellas (que conforman su comportamiento). Un ejemplo de clase puede ser la clase Persona cuyos datos internos son por ejemplo: nombre, peso, altura, sexo, edad, y cuyos métodos son:

anda(); come(); habla(); crece();

La clase es el concepto. Para utilizarla tenemos que instanciarla (crear un objeto). Una clase es el correspondiente a un tipo de dato (como un entero) y un objeto el correspondiente a una variable (int a;). Por ejemplo una clase puede ser Persona y los objetos de la clase serían Pepe, Manolo, Margarita y Alejandro, que son todos Personas.

Ejemplo:

Crearemos una aplicación que simule el proceso de transacciones bancarias, nuestra aplicación permitirá realizar un depósito o un retiro de una cuenta bancaria.

Creamos un nuevo proyecto Android con el nombre “Banco” y el nombre de la actividad

“Principal”

Crear el siguiente diseño utilizando TextView, EditText, GroupBox y Button



Agregar una nueva clase con el nombre “Acciones”



Escribir el siguiente Código que vendrían a ser 2 métodos que permiten obtener un valor como resultado.

Doble en la actividad de nombre “Principal” para escribir el código necesario.



MANEJO DEL CONTROL CHECKBOX

Para probar este control, crearemos una aplicación que cambia el color de fondo y el color de texto.

Crear un nuevo proyecto y agregar 2 controles Checkbox.

Aquí se muestra el código del diseño que se acaba de crear.

Escribimos el siguiente código para el funcionamiento de nuestra aplicación.



Evento que captura cuando se modifica el control Checkbox sería:

checkbox.setOnCheckedChangeListener(new OnCheckedChangeListener() { @Override public void onCheckedChanged(CompoundButton buttonView, boolean isChecked){ });

Método que comprueba si un ckeckbox está seleccionado.

.isChecked();



LISTAS

Es muy frecuente en las aplicaciones para dispositivos móviles, el uso de listas para mostrar una serie de elementos. El usuario puede ver la lista completa de los elementos que forman la lista, pudiendo desplazarse a través de ellos. Si el usuario selecciona alguno de los elementos de la lista, la aplicación podrá realizar alguna acción relacionado con el elemento indicado

LISTVIEW

Puedes crear una lista en una Activity de la aplicación insertando un elemento ListView que encontrarás en la sección Composite de la palete.

El método setAdapter de la clase ListView permite indicar el formato que va a tener la lista, así como el contenido de la misma, todo ello utilizando un objeto ListAdapter o de sus subclases como ArrayAdapter (para asignarle un array de objetos) o CursorAdapter (para utilizar objetos obtenidos desde una base de datos).

void setAdapter (ListAdapter adapter)

La clase ArrayAdapter dispone de varios métodos constructores. Quizá el constructor más sencillo sea el que recibe como parámetro el contexto actual, el identificador de un recurso de tipo Layout que contenga un TextView donde se mostrará cada elemento, y un array con el contenido.

http://javiergarbedo.es/index.php/desarrollo-android/88-persistencia-de-los-datos/315-listas



ArrayAdapter (Context context, int textViewResourceId, T[] objects)

Si sólo deseas mostrar un String en cada elemento de la lista, puedes usar en el parámetro textViewResourceId, alguno de los layouts predefinidos en Android. Puedes ver las diferencias entre los distintos estilos en el artículo Different styles to show data in listview. El más sencillo es android.R.layout.simple_list_item_1 que únicamente muestra la cadena de texto.

Por ejemplo, puedes crear una lista de nombres ficticios con el siguiente código:

El resultado debe ser similar al siguiente:



OBTENER LA POSICIÓN SELECCIONADA

Habitualmente es necesario conocer qué elemento ha seleccionado el usuario al pulsar sobre él, para hacer alguna operación con los datos relacionados con dicho elemento.

Para ello, debes utilizar el método setOnItemClickListener con el objeto ListView creado anteriormente, al que se le debe pasar como parámetro un objeto OnItemClickListener que puedes crear directamente dentro de los paréntesis. Ahí debes sobreescribir el método onItemClick, y en su contenido indicarás las operaciones a realizar cuando el usuario haga clic en un elemento de la lista.

void onItemClick (AdapterView<?> parent, View view, int position, long id)

Para conocer cuál ha sido el elemento que se ha seleccionado, el parámetro position te ofrece el número de la posición de dicho elemento, iniciando la cuenta desde el valor 0.

Podemos probar con este ejemplo, donde se muestra en pantalla un mensaje Toast con el número de la posición seleccionada. Deberás copiar todo el código dentro del método onCreate que se ha mostrado anteriormente.

Al ejecutarlo puedes obtener un resultado como el siguiente:



MANEJO DE BASE DE DATOS SQLITE

SQLite, Base de Datos relacional para sistemas embebidos.

Ocupa únicamente unos 225KB.

Implementa la mayor parte del estándar SQL-92, pero con restricciones.

Soporte para ALTER_TABLE limitado.

Existen diferentes herramientas, como sqlite3, disponible desde sqlite.org

Lo utilizan la mayoría de las plataformas móviles (iOS, Symbian, Android, BlackBerry OS, webOS).

No existen las claves ajenas o foráneas, y en el caso de necesitarlas, debemos forzarlas “a mano”.

Es relativamente fácil conectar una base de datos a una lista.

La base de datos está protegida dentro de la memoria interna del dispositivo.

Mientras trabajamos con el emulador, podemos extraer (con DDMS) el archivo de la base de datos y visualizarlo.

SQLiteOpenHelper

o Nos permite crear, actualizar, y conectar con una base de datos SQLite o Es solo un constructor. o Métodos:

onCreate() onUpgrade()

Referencia a la Base de Datos

o Objeto de tipo SQLiteDatabase. o Actualizar, modificar, eliminar datos. o Métodos:

getReadableDatabase() getWritableDatabase()

Insertar, actualizar y eliminar registros

o Método execSQL() Permite ejecutar cualquier sentencia SQL sobre la base de datos. No devuelve resultados.

o Métodos insert(), update() y delete() Uso de parámetros. Separa tablas, valores y condiciones en parámetros independientes.

Selección y recuperación de datos

o Método rawQuery(). Único parámetro, comando SQL. Resultado de la consulta en forma de Cursor.

o Método query().

Varios parámetros:

Nombre de la tabla.

Array campos, cláusula WHERE.



Array con argumentos variables incluidos en el WHERE (si los hay, null caso contrario).

Cláusula GROUP BY si existe.

Cláusula HAVING si existe.

Cláusula ORDER BY si existe.

Parámetro opcional con el número de registros a obtener.

Resultado de la consulta en forma de Cursor.

Recorrer y manipular un cursor

o Métodos: moveToFirst(): mueve el puntero del cursor al primer registro

devuelto. moveToNext(): mueve el puntero del cursor al siguiente registro

devuelto.

Creamos un nuevo proyecto Android con el nombre Ejemsqlite, agregamos una clase con el nombre Datos y escribimos el siguiente código.

Agregar los controles necesarios para tener el siguiente diseño:



Escribimos el siguiente código en el archivo Inicio.java



Agregar el siguiente código en la clase Datos.java, que es un método que permite agregar información a la tabla Usuarios.



REGISTRAR, ELIMINAR, MODIFICAR Y CONSULTAR SQLITE

Desarrollar 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:

Registrar de personas.

Consultar por el DNI (para saber dónde vota).

Eliminar registros.

Modificación de datos.

Se debe implementar la siguiente interfaz

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.



En nuestro problema implementaremos una nueva clase llamada AdminSQLiteOpenHelper que herede de la clase SQLiteOpenHelper, Escribir el siguiente código en la actividad principal.

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

}

Escribimos el siguiente código en la actividad principal.



Registrar datos.

Cuando se presiona el botón registrar 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 los 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();

}



Consulta de datos.

Cuando se presiona el botón "Consulta por DNI" se ejecuta el método consulta:

public void consulta(View v) {




Cursor fila=bd.rawQuery("select nombre,colegio,nromesa from votantes where dni="+dni+"",null);

if (fila.moveToFirst())

{

et2.setText(fila.getString(0));



}

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)

Eliminar 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) {




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();

}

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) {




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();

}

USO DE GPS

Diseñar la siguiente aplicación con la interfaz que se muestra.



Código principal de la aplicación.



Modificamos el AndroidManifest.xml



OBTENER EL IMEI DEL DISPOSITIVO.

Diseñar la siguiente interfaz.

Código principal del Imei.java



Agregamos los permisos en el archivo AndroidManifest.xml



USO DE GOOGLEMAPS

Codigo del Layout principal mimapa.xml

Codigo del activity Mimapa.java



Agregamos los permisos en el archivo AndroidManifest.xml

curso android 2014 completo

Documents