Desarrollo de aplicaciones de Android para Cientificos

Noticia en CANALUGR
Jueves, 15 de Diciembre de 2011

Curso “Desarrollo de aplicaciones de android para científicos”

• El sistema operativo Android, con apenas tres años de existencia y avalado por Google, está revolucionando la telefonía móvil

La Universidad de Granada, a través de la Escuela de Posgrado, a propuesta del Departamento de Física Atómica, Molecular y Nuclear, organiza por primera vez un curso dirigido a científicos sobre “Desarrollo de aplicaciones de android”.
Según explican los organizadores, el sistema operativo Android, con apenas tres años de existencia y avalado por Google, está revolucionando la telefonía móvil. La creciente aparición de smartphones, tablets y otros dispositivos equipados con Android permite escribir programas en Java para que se ejecuten en cualquier teléfono o dispositivo compatible.
Este curso enseña a programar desde cero aplicaciones para Android usando el Android Software Development Kit (SDK) en el entorno de desarrollo integrado (IDE) Eclipse. Se proporcionarán las técnicas y herramientas imprescindibles para que el alumno aprenda a escribir programas útiles en sus disciplinas científicas o técnicas, incluyendo gráficos, y que puedan ser ejecutados en sus dispositivos móviles con Android. Se introducirán las bases del lenguaje de programación Java indispensables para Android. No se requieren conocimientos previos de Java, aunque es recomendable conocer algún lenguaje de programación.
Material necesario: debido a las características del software de desarrollo se requiere que el alumno acuda a las clases con su ordenador portátil (con cualquier sistema operativo).
Contenido académico:

• Instalación y configuración de las herramientas de desarrollo de Android.
• Utilización del Android SDK y AVD Manager.
• Uso del entorno de desarrollo Eclipse.
• Características generales de las aplicaciones para Android, compilación e instalación.
• Interfaces de usuario.
• Elementos de Java para Android.
• Botones, listeners y acciones.
• Introducción de datos.
• Persistencia de datos.
• Actividades.
• Manejo de ficheros.
• Gráficos.

Datos de interés

• Dirección y Coordinación: José Enrique Amaro Soriano. Dpto. de Física Atómica, Molecular y Nuclear.
• Fecha de realización: Desde 20/02/2012 hasta 23/04/2012.
• Lugar de realización: Facultad de Ciencias. Seminario del Dpto. de Física Atómica, Molecular y Nuclear.
• Plazas: 25
• Horario: lunes y martes de 16 a 18 horas.30 horas presenciales.
• Horas: 75.
• Fecha de inscripción: Desde 10/01/2012 hasta 15/02/2012
• Requisitos: Alumnos/as de cualquier titulación universitaria. Titulados/as Universitarios/as. PDI de la UGR

Más información: Facultad de Ciencias. Dpto. de Física Atómica, Molecular y Nuclear. Teléfono: 958 240028. Correo elec: amaro@ugr.es

Mi libro ANDROID: PROGRAMACION DE DISPOSITIVOS MOVILES A TRAVES DE EJEMPLOS

 

ANDROID: PROGRAMACIÓN DE DISPOSITIVOS MÓVILES A TRAVÉS DE EJEMPLOS

• AMARO SORIANO, JOSÉ ENRIQUE, (aut.)
• MARCOMBO S.A.
• 1(20/10/2011)
• 268 páginas
• Idiomas: Español
• ISBN: 8426717675 ISBN-13: 9788426717675

Comprar el libro en CIAO:



Ir a pagina del libro en ciao.es

Página del libro en editorial Marcombo

---

Android es el sistema operativo de Google para smartphones, tablets, y otros dispositivos móviles. En este libro se presentan, de una forma práctica, comprensible y concisa, los conceptos esenciales para desarrollar sus propias aplicaciones de Android, programando en lenguaje Java. El lector aprenderá a programar interfaces de usuario, entrada y salida de datos, lectura y escritura de ficheros, herramientas gráficas, gráficos interactivos, visualización de imágenes, reproducción de sonido, temas, recursos, procesos en background, diálogos de progreso, notificaciones, animaciones gráficas y simulaciones. Se incluye un apéndice Elementos de Java para el lector que no conozca el lenguaje de programación Java. Para lectores más avanzados, el libro se complementa con otro apéndice donde se introduce una completa aplicación científica para Android.
Todos los conceptos se introducen con ejemplos que consisten en programas sencillos ilustrando algún aspecto concreto de Android o de Java. Todos los ejemplos se acompañan con capturas de pantalla.
Este libro está dirigido a estudiantes, profesores y en general al principiante con escasos o nulos conocimientos de Java que quiere escribir rápidamente sus propios programas. También al profesional que quiere iniciarse de forma rápida en el desarrollo de aplicaciones para Android.
José Enrique Amaro Sorinano es Doctor en Ciencias Físicas y Profesor Titular de la Universidad de Granada. Desarrolla su docencia e investigación en el departamento de Física Atómica, Molecular y Nuclear. Es investigador responsable del Grupo de Física Nuclear a Energías Intermedias y miembro del Instituto Carlos I de Física Teórica y Computacional. Actualmente imparte un curso de Programación de Android para Científicos en la Escuela de Posgrado de la Universidad de Granada.
1. INTRODUCCIÓN
1.1. Acerca de este libro
1.2. A quién va dirigido
1.3. Resumen de los contenidos
1.4. Requerimientos
1.5. Créditos y Agradecimientos
2. ESCRIBIR Y MANIPULAR TEXTO
2.1. Actividad básica: Hola Android
2.2. Color de fondo y formato del texto
2.3. Modificando el texto desde Java
2.4. Modificando el color desde Java
2.5. Añadir texto adicional con addView
2.6. Definir un método print()
2.7. Escribiendo resultados de operaciones
2.8. Ejemplo: una tabla del seno
2.9. Añadir texto con Append()
2.10. Extendiendo la pantalla con ScrollView
3. BOTONES
3.1. Definición de un botón en el layout
3.2. Caso de dos botones
3.3. Uso de Toast para mostrar un mensaje emergente
3.4. Cambiar el texto de un botón
3.5. Cambiar el color de los botones
3.6. Calculadora
4. INTRODUCCIÓN DE TEXTOS
4.1. TextField
4.2. OnKeyListener
4.3. Forma alternativa de implementar OnKeyListener
5. GUARDAR DATOS CON SharedPreferences
6. ACTIVIDADES
6.1. Uso de Intent para iniciar actividades
6.2. Pasar valores numéricos entre actividades
7. MANEJO DE FICHEROS
7.1. Escribir datos en un fichero en la tarjeta SD
7.2. Leer un fichero en el directorio res
8. GRÁFICOS
8.1. Dibujando en un Canvas
8.2. Formato del texto
8.3. Altura del canvas
8.4. Dimensiones del canvas
8.5. Formas geométricas
8.6. Curvas
8.7. Traslaciones y rotaciones
8.8. Texto siguiendo una curva
8.9. Caracteres Unicode
8.10. LayoutParams
9. GRÁFICOS INTERACTIVOS
9.1. Evento ACTION_DOWN
9.2. Evento ACTION_UP
9.3. Evento ACTION_MOVE
9.4. Dibujar en la pantalla
9.5. Mover objetos
10. IMÁGENES
10.1. Insertar una imagen en el layout
10.2. Controlando las imágenes en Java
10.3. Botones con imágenes
10.4. Insertar imágenes en un canvas
10.5. Ajustar imagen a las dimensiones de la pantalla
11. REPRODUCIR SONIDO
11.1. Uso de MediaPlayer
11.2. Reproducir efectos de sonido
12. APLICANDO TEMAS
12.1. Tema por defecto
12.2. Tema NoTitleBar
12.3. Tema Dialog
12.4. Tema Light
13. RECURSOS
13.1. El recurso string
13.2. El recurso color
13.3. Usando recursos en un Layout
14. HILOS Y CONTROLADORES
14.1. Ejecuciones en background con Thread
14.2. Diálogos de progreso
14.3. Interfaz Runnable
14.4. Notificaciones
15. ANIMACIONES
15.1. Movimiento uniforme. La bola botadora
15.2. Movimiento acelerado. La bola botadora II
15.3. Conservación de la energía
15.4. Simulación de caída con ligadura
APÉNDICE A
ELEMENTOS DE JAVA
A.1. Programa básico de Java con Android
A.2. Variables
A.3. Conversión de variables
A.4. Operaciones con variables
A.5. Funciones matemáticas
A.6. Bloque if-else
A.7. Bucles for
A.8. Bucle while
A.9. Bloques switch
A.10. Métodos
A.11. Clases y objetos
A.12. Sub-clases
A.13. Variables y métodos estáticos y finales
A.14. Arrays
A.15. Arrays 2D
A.16. Cadenas
A.17. Formato numérico
A.18. Manejo de Excepciones
A.19. Interfaces
A.20. Clases anónimas
A.21. Otras características de Java
A.21.1. Paquetes
A.21.2. Clases públicas
A.21.3. Privilegios de acceso de los métodos y variables
A.21.4. Clases y métodos abstractos
APÉNDICE B
HERRAMIENTAS DE DESARROLLO DE ANDROID
B.1. Eclipse
B.1.1. Problemas en la instalación
B.1.2. Importar una clase Java de otro proyecto
B.1.3. Importar un proyecto completo ya existente
B.2. Android Virtual Device (AVD)
B.3. Dalvik Debug Monitor Server (DDMS)
B.4. Instalar driver dispositivo Android de Samsung en Linux (Ubuntu
Jaunty)
APÉNDICE C
APLICACIONES
C.1. Interacción neutrón-protón
C.2. Ajuste por mínimos cuadrados
C.3. Energía del Helio-4
BIBLIOGRAFÍA

Noticias de prensa sobre mi libro de ANDROID: PROGRAMACION DE DISPOSITIVOS MOVILES A TRAVES DE EJEMPLOS

Las notas de prensa sobre mi libro se han propagado a diversas medios informativos online.
He aquí algunos links. Se pueden encontrar muchos más en google.

El profesor Jose Enrique Amaro Soriano sostiene su Samsung Galaxy Tab que utiliza para depurar sus aplicaciones de Android

Portada del libro ANDROID: PROGRAMACIÓN DE DISPOSITIVOS

MÓVILES A TRAVÉS DE EJEMPLOS

Platform Versions

Cupcake, Froyo? Cansado de esa jerga usada por los informáticos?
Todo se explica en este artículo de Android Developers.
He aquí la traducción de esos nombres aparentemente estúpidos, infantiles  y que no dicen nada.
Como si le hubieran puesto boquerón, sardina y mero.
Se ve que el nombre está relacionado con lo que habian desayunado esa mañana.

Aquí la traducción que hace google translator de los nombres:

Cupcake: Magdalena   (android 1.5)

Donut:  buñuelo (android 1.6)

Eclair: eclair (android 2.1)

Froyo: froyo (android 2.2)

Gingerbread: pan de gengibre (android 2.3)

Honeycomb: panal (android 3)

Y aquí la explicación proporcionada por la wikipedia:

Las versiones de Android reciben nombre de postres en inglés. En cada versión el postre elegido empieza por una letra distinta siguiendo un orden alfabético:

Oficiales:

• C: Cupcake (v1.5), magdalena glaseada.
• D: Donut (v1.6), rosquilla.
• E: Éclair (v2.0/v2.1), pastel francés conocido en España como pepito o canuto.
• F: Froyo (v2.2), (abreviatura de «frozen yogurt») yogur helado.
• G: Gingerbread (v2.3), pan de jengibre.
• H: Honeycomb (v3.0/v3.1), panal.
• I: IceCream Sandwich (4.0), sandwich de helado.
• J: Jelly Bean (¿¿??) Frijol de gelatina(referencia a las gomitas de gelatina)⁷³

Esta explicación de la inicial parece más lógica, y una regla memotécnica para recordar y asociar la palabra a la versión de Android.

Otra regla para acordarse sería la siguiente: A cada versión de android le asociamos una nota musical Do, Re, Mi, Fa, Sol, pero en notación  inglesa o alemana, es decir, C, D, E, F, G, y al llegar aquí continuamos por orden alfabético, aunque ya no son notas, H, I, J, K,...

Sabiendo que la primera versión comercial es la 1.5, esta correspondería a la nota Do, en inglés C, inicial de Cupcake. 

La segunda versión 1.6 sería Re, en inglés D, inicial de Donut.

La tercera versión 2.1, sería Mi, en inglés E, inicial de Eclair.

La cuarta versión 2.2, sería Fa, en inglés F, inicial de Froyo.

La quinta versión 2.3, sería Sol, en inglés G, inicial de Gingerbread.

La sexta versión 3.x, sería H, inicial de Honeycomb

 

Platform Versions

This page provides data about the relative number of active devices running a given version of the Android platform. This can help you understand the landscape of device distribution and decide how to prioritize the development of your application features for the devices currently in the hands of users. For information about how to target your application to devices based on platform version, see API Levels.

Current Distribution

The following pie chart and table is based on the number of Android devices that have accessed Android Market within a 14-day period ending on the data collection date noted below.

Platform	Codename	API Level	Distribution
Android 1.5	Cupcake	3	1.0%
Android 1.6	Donut	4	1.8%
Android 2.1	Eclair	7	13.3%
Android 2.2	Froyo	8	51.2%
Android 2.3 - Android 2.3.2	Gingerbread	9	0.6%
Android 2.3.3 - Android 2.3.4		10	30.7%
Android 3.0	Honeycomb	11	0.2%
Android 3.1		12	0.7%
Android 3.2		13	0.5%

Data collected during a 14-day period ending on September 2, 2011

Historical Distribution

The following stacked line graph provides a history of the relative number of active Android devices running different versions of the Android platform. It also provides a valuable perspective of how many devices your application is compatible with, based on the platform version.
Notice that the platform versions are stacked on top of each other with the oldest active version at the top. This format indicates the total percent of active devices that are compatible with a given version of Android. For example, if you develop your application for the version that is at the very top of the chart, then your application is compatible with 100% of active devices (and all future versions), because all Android APIs are forward compatible. Or, if you develop your application for a version lower on the chart, then it is currently compatible with the percentage of devices indicated on the y-axis, where the line for that version meets the y-axis on the right.
Each dataset in the timeline is based on the number of Android devices that accessed Android Market within a 14-day period ending on the date indicated on the x-axis.

Last historical dataset collected during a 14-day period ending on September 2, 2011

Painless threading

Painless threading

Posted by Romain Guy on 06 May 2009 at 9:30 AM

Whenever you first start an Android application, a thread called "main" is automatically created. The main thread, also called the UI thread, is very important because it is in charge of dispatching the events to the appropriate widgets and this includes the drawing events. It is also the thread you interact with Android widgets on. For instance, if you touch the a button on screen, the UI thread dispatches the touch event to the widget which in turn sets its pressed state and posts an invalidate request to the event queue. The UI thread dequeues the request and notifies the widget to redraw itself.
This single thread model can yield poor performance in Android applications that do not consider the implications. Since everything happens on a single thread performing long operations, like network access or database queries, on this thread will block the whole user interface. No event can be dispatched, including drawing events, while the long operation is underway. From the user's perspective, the application appears hung. Even worse, if the UI thread is blocked for more than a few seconds (about 5 seconds currently) the user is presented with the infamous "application not responding" (ANR) dialog.
If you want to see how bad this can look, write a simple application with a button that invokes Thread.sleep(2000) in its OnClickListener. The button will remain in its pressed state for about 2 seconds before going back to its normal state. When this happens, it is very easy for the user to perceive the application as slow.
Now that you know you must avoid lengthy operations on the UI thread, you will probably use extra threads (background or worker threads) to perform these operations, and rightly so. Let's take the example of a click listener downloading an image over the network and displaying it in an ImageView:

public void onClick(View v) {
  new Thread(new Runnable() {
    public void run() {
      Bitmap b = loadImageFromNetwork();
      mImageView.setImageBitmap(b);
    }
  }).start();
}

At first, this code seems to be a good solution to your problem, as it does not block the UI thread. Unfortunately, it violates the single thread model: the Android UI toolkit is not thread-safe and must always be manipulated on the UI thread. In this piece of code, the ImageView is manipulated on a worker thread, which can cause really weird problems. Tracking down and fixing such bugs can be difficult and time-consuming.
Android offers several ways to access the UI thread from other threads. You may already be familiar with some of them but here is a comprehensive list:

• Activity.runOnUiThread(Runnable)
• View.post(Runnable)
• View.postDelayed(Runnable, long)
• Handler

Any of these classes and methods could be used to correct our previous code example:

public void onClick(View v) {
  new Thread(new Runnable() {
    public void run() {
      final Bitmap b = loadImageFromNetwork();
      mImageView.post(new Runnable() {
        public void run() {
          mImageView.setImageBitmap(b);
        }
      });
    }
  }).start();
}

Unfortunately, these classes and methods also tend to make your code more complicated and more difficult to read. It becomes even worse when your implement complex operations that require frequent UI updates. To remedy this problem, Android 1.5 offers a new utility class, called AsyncTask, that simplifies the creation of long-running tasks that need to communicate with the user interface.
AsyncTask is also available for Android 1.0 and 1.1 under the name UserTask. It offers the exact same API and all you have to do is copy its source code in your application.
The goal of AsyncTask is to take care of thread management for you. Our previous example can easily be rewritten with AsyncTask:

public void onClick(View v) {
  new DownloadImageTask().execute("http://example.com/image.png");
}
private class DownloadImageTask extends AsyncTask {
     protected Bitmap doInBackground(String... urls) {
         return loadImageFromNetwork(urls[0]);
     }

     protected void onPostExecute(Bitmap result) {
         mImageView.setImageBitmap(result);
     }
 }

As you can see, AsyncTask must be used by subclassing it. It is also very important to remember that an AsyncTask instance has to be created on the UI thread and can be executed only once. You can read the AsyncTask documentation for a full understanding on how to use this class, but here is a quick overview of how it works:

• You can specify the type, using generics, of the parameters, the progress values and the final value of the task
• The method doInBackground() executes automatically on a worker thread
• onPreExecute(), onPostExecute() and onProgressUpdate() are all invoked on the UI thread
• The value returned by doInBackground() is sent to onPostExecute()
• You can call publishProgress() at anytime in doInBackground() to execute onProgressUpdate() on the UI thread
• You can cancel the task at any time, from any thread

In addition to the official documentation, you can read several complex examples in the source code of Shelves (ShelvesActivity.java and AddBookActivity.java) and Photostream (LoginActivity.java, PhotostreamActivity.java and ViewPhotoActivity.java). I highly recommend reading the source code of Shelves to see how to persist tasks across configuration changes and how to cancel them properly when the activity is destroyed.
Regardless of whether or not you use AsyncTask, always remember these two rules about the single thread model: do not block the UI thread and make sure the Android UI toolkit is only accessed on the UI thread. AsyncTask just makes it easier to do both of these things.
If you want to learn more cool techniques, come join us at Google I/O. Members of the Android team will be there to give a series of in-depth technical sessions and answer all your questions.