Guia de Aprendizaje de Programacion M3S2

MODULO III “DESARROLLA APLICACIONES WEB Y MOVILES”

Mapa curricular: Submódulo 1 - Desarrolla aplicaciones web Submódulo 2 - Desarrolla aplicaciones móviles

Índice Introducción al submódulo Objetivo General Mapa Curricular Mapa de Contenidos Cronograma Ponderaciones Desarrollo de las Esferas de Competencia Cierre del Submódulo Bibliografía Glosario Anexos Plan de Evaluación Guía del Portafolio Instrumentos de Evaluación Proyecto Integrador Elaboraron: Lic. Esteban Angeles Molina Ing. Susana Hernández Ramírez Lic. Renán Abreu Guerrero Ing. Lorena Ramírez Campoy

Introducción al submódulo Es indudable el vertiginoso avance de las posibilidades que tiene los dispositivos móviles actuales en la comunicación por diversas vías, el acceso a servicios de forma remota y móvil y el manejo de aplicaciones hasta hace poco tiempo sólo reservadas a plataformas fijas.

El curso tiene, como primer objetivo, dar una panorámica general de la tecnología que soporta estos avances y la que hay para el desarrollo de aplicaciones y el soporte de servicios mediante dispositivos móviles, profundizándose en las plataformas de programación, lenguajes y entornos de ejecución y de desarrollo más usados en la actualidad.

Finalmente se propondrán desarrollos sencillos de programación de aplicaciones adaptados a los conocimientos de cada alumno para poner en práctica lo visto de forma teórica y para reafirmar al alumno en las posibilidades de desarrollo que tienes estas plataformas.

Cuando hablamos de desarrollar software para dispositivos móviles, lo primero que se nos viene a la mente es el desarrollo para teléfonos celulares, pero, en muchas ocasiones, no tenemos claro qué debemos hacer; ¿Un sitio Web? ¿Una aplicación para el celular? Lo cierto es que, un dispositivo móvil no es solo un celular, y que además, el software a desarrollar, puede ser, tanto un sitio Web, como una aplicación nativa para el dispositivo. Los celulares no son los únicos dispositivos móviles para los cuales podemos desarrollar. Podríamos programar para otros dispositivos como Palm, Pocket PC, Ipod Touch. En fin, dispositivos de mano pequeños con ciertamente, una gran potencia.

Objetivo general.

El alumno será capaz de desarrollar aplicaciones móviles sobre plataformas abiertas y cerradas utilizando diferentes SDKs ejecutándolas tanto en tablets como en smartphones.

Mapa curricular Mapa de competencias profesionales de la carrera de Técnico en programación

Mapa de Contenidos Modulo 3 “Desarrolla aplicaciones web y móviles” Submódulo 2 “Desarrolla aplicaciones móviles”

Competencia 1 “Desarrolla aplicaciones para dispositivos móviles sobre plataformas abiertas” Atributos de la competencia 1. 2. 3. 4. 5.

Conceptos básicos Conocer una plataforma abierta Conocer los dispositivos móviles de plataforma abierta Conocer la programación del móvil Desarrollo de aplicaciones

Saberes: 1) 2) 3) 4) 5) 6)

Conceptos básicos de programación orientado a objetos POO Java Entorno de Eclipse Conocimientos básicos de XML SDK Entorno de Android (AVD) Desarrollo de aplicaciones

Actitudes: 1. Limpieza 2. Responsabilidad 3. Orden

Competencia 2 “Desarrolla aplicaciones para dispositivos móviles sobre plataformas cerradas” Atributos de la competencia: 1. Conocer una plataforma cerrada

2. Conocer los dispositivos móviles de plataforma cerrada 3. Conocer las características, ventajas y desventajas de las plataformas cerradas.

Saberes:

1. Actitudes: 1. Limpieza 2. Responsabilidad 3. Orden Cronograma (ANEXO ARCHIVO M3S1 Excel)

Ponderaciones

En el Submódulo 2

Evidencia de Producto Evidencia de Desempeño Evidencia de Actitud Evidencia de Conocimiento

Desarrollo de las Esferas de Competencia Competencia 1 “Desarrolla aplicaciones para dispositivos móviles sobre plataformas abiertas”.

Saberes 1. Conceptos básicos 2. Conocer tipos de plataformas 3. Conocer los dispositivos móviles de plataforma abierta 4. Conocer la programación del móvil 5. Desarrollo de aplicaciones Ejemplos: 1. Antecedentes 2. Te presento a Android 3. Instalando Android 4. Mi primer programa 5. Conociendo más de Java en Eclipse

Ejercicios:

1. Tabla comparativa de sistemas operativos para plataformas libres 2. Usando Edith Text 3. Edith Text 4. Radio Group 5. Radio Button 6. Check box 7. Spinner 8. Image Button 9. Un segundo Activity 10. Paso de parámetros. 11. Almacenamiento de datos en un archivo de texto en memoria interna , y en tarjetas SD 12. Layouts

Práctica Integradora: 1. Programando mi pone

Introducción a la Competencia 1 Las plataformas abiertas son aquellas que permiten adaptarlas a las necesidades creando ventajas competitivas para la empresa. Las Tecnologías de la Información juegan hoy en día un factor determinante en la competitividad de las empresas. El seleccionar y mantener una cartera tecnológica competitiva es uno de los grandes retos, en especial para las PyMEs. La evolución acelerada de la tecnología presenta un enorme reto, desde el punto de vista de gestión del conocimiento, lograr soluciones competitivas con fuertes diferenciales y alternativas correctas. Adoptar un producto abierto, como una plataforma para desarrollar diferenciales de negocio positivos, es una alternativa altamente competitiva que permite reducir sustancialmente los costos asociados a la innovación.

¿Cómo se ofrecen las plataformas libres?

Las plataformas abiertas son aquellas que permiten adaptarse a las necesidades creando ventajas para la empresa, negocio, o simplemente mejorar la manera en que se realizan diferentes actividades importantes para las organizaciones. Este tipo de plataformas no tienen un costo de licenciamiento, pero la mayoría tienen un costo implícito asociado a la adaptación, según los requerimientos de cada empresa. La mayoría de las veces la adaptación se tiene que hacer por un profesional que conozca la tecnología y plataforma. Hoy en día se puede decir que hay muy pocas soluciones que se puedan considerar netamente comerciales o totalmente abiertas. En la mayoría de los casos, se pueden realizar acuerdos o convenios con los diferentes proveedores para que den acceso al código fuente para poder modificarlo. El principal modelo de negocio con el que se ofrecen las plataformas libres se denomina “gift economy” o economía del regalo. El regalo en las plataformas abiertas es una licencia, generalmente sin costo que permite usar y modificar las soluciones según las necesidades. Pero, ¿qué ganan las empresas al regalar el software? “Los principales ingresos están en los servicios de soporte para adaptarse a necesidades específicas, en lugar de cuotas para el uso (licencias), los servicios que se ofrecen deben ser de gran valor para la competitividad”, El mejor ejemplo de tecnologías abiertas hoy en día es Android que tiene la mayor penetración en el mercado de móviles. Android es un producto abierto (Linux) adaptado a una necesidad específica como lo es el mercado de los smartphones. Es capaz de ser instalado en múltiples dispositivos móviles creados por diferentes marcas y al mismo tiempo cuenta con una amplia variedad de aplicaciones que en su mayoría son gratuitas.

Iniciamos………….

Atributos de la Competencia 1. Conceptos básicos 2. Conocer una plataforma abierta 3. Conocer los dispositivos móviles de plataforma abierta 4. Conocer la programación del móvil 5. Desarrollo de aplicaciones

Resultado de Aprendizaje Una vez que se logren adquirir las habilidades necesarias a través del dominio de la competencia y sus atributos, podrá realizar aplicaciones móviles que podrás traer en el bolsillo..

(No. 1)

Saberes TITULO

1. 2.

Recordando la POO Sentencias básicas de Java

Instrucciones para el alumno: El alumno analizara los tres métodos o estrategias para el desarrollo de sistemas; los cuales le darán la pauta de elegir el que le convenga para generar la solución mas optima a sus problemas. Actitudes: 1. Orden. 2. Puntualidad. 3. Responsabilidad.

Saberes a adquirir Competencias Genéricas: . Se expresa y comunica.

 Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de medios, códigos y herramientas apropiados. Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta la investigación sustenta con acervo bibliográfico.

Instrucciones para el alumno| 1. Realiza un mapa conceptual de los principales conceptos de la programación orientada a objetos, como: clase, objeto, método, encapsulamiento, atributo, herencia, etc.

Saberes a adquirir Recordar los conceptos básicos que se manipularan de forma cotidiana durante el desarrollo del submódulo, así como nuevos conceptos que se deban adquirir. Método didáctico Por medio de un mapa conceptual se definirán los conceptos básicos utilizados en la programación orientada a objetos, escribiendo la fuente bibliográfica utilizada. Ejemplo

(No. 1)

TABLA DE SENTENCIAS BÁSICAS DE JAVA Titulo:

Instrucciones para el alumno: En la siguiente tabla, escribe en cada uno de los cuadros la información que hace falta.

Sentencia

Uso

int i=1;

Declaración entero

de

variable

i

tipo

System.out.println("Mi primer programa");

...

Actitudes: 1. 2. 3. 4. 5.

Limpieza. Orden. Respeto. Puntualidad. Responsabilidad.

Competencias Genéricas: Escucha, interpreta y emite mensajes Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta la investigación sustentada con acervo bibliográfico.

Ejemplo

(No. 2)

TABLA COMPARATIVA DE SISTEMAS OPERATIVOS MOVILES EN PLATAFORMAS ABIERTAS. Titulo:

Instrucciones para el alumno: Realiza una tabla comparativa de los diferentes sistemas operativos móviles, tomando en cuenta el nombre del sistema operativo, principales características como su capacidad de procesamiento, ventajas, desventajas, aplicaciones existentes, etc..

Actitudes: 1. 2. 3. 4. 5.

Limpieza. Orden. Respeto. Puntualidad. Responsabilidad.

Competencias Genéricas: Escucha, interpreta y emite mensajes Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta la investigación sustentada con acervo bibliográfico.

(No. 2)

Saberes TITULO

1.

Antecedentes de la programación móvil

Instrucciones para el alumno: El alumno conocerá los orígenes de la programación móvil, los cuales le darán la pauta de elegir el que le convenga para generar la solución más óptima a sus problemas. Actitudes:   

Orden. Puntualidad. Responsabilidad.

Saberes a adquirir Competencias Genéricas: . Se expresa y comunica.  Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de medios, códigos y herramientas apropiados. Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta la investigación sustenta con acervo bibliográfico.

ANTECEDENTES: Aunque el sistema operativo Android tiene algunos años de vida, la librería Java de android consiste ya en más de 150 paquetes (APIs), que contienen miles de clases, métodos, interfaces y constantes. Para mayor información se puede verificar en la página web de Android Developers. Android es un Linux basado en sistema operativo diseñado principalmente para la pantalla táctil de los dispositivos móviles como teléfonos inteligentes y Tablet PC . Desarrollado inicialmente por Android Inc., que Google respaldada financieramente y más tarde adquirió en 2005, Android se dio a conocer en 2007 con la fundación de la Open Handset Alliance : un consorcio de hardware , software y telecomunicaciones empresas dedicadas a la promoción abierta normas para los dispositivos móviles. El primer teléfono con Android fue vendido en octubre de 2008. Android es de código abierto y Google libera el código bajo la licencia Apache . Este código fuente abierto y licencia permisiva permite que el software para ser modificado y distribuido libremente por los fabricantes de dispositivos, operadores móviles y desarrolladores entusiastas. Además, Android tiene una gran comunidad de desarrolladores que escriben aplicaciones (" apps ") que amplían la funcionalidad de los dispositivos, escrito principalmente en una versión personalizada de la Java lenguaje de programación. En octubre de 2012, había aproximadamente 700.000 aplicaciones disponibles para Android , y la estimación del número de aplicaciones descargadas de Google Play , tienda de aplicaciones de Android primaria, fue de 25 millones de dólares. Estos factores han permitido a Android para convertirse en la plataforma más utilizada teléfono inteligente y el software de elección para las empresas de tecnología que requieren un bajo costo, sistema personalizable, operativo ligero de alta tecnología, dispositivos sin desarrollar uno desde cero. Como resultado, a pesar de estar diseñado principalmente para teléfonos y tabletas, se ha visto aplicaciones adicionales en televisores , consolas de videojuegos y otros aparatos electrónicos. Naturaleza abierta de Android ha alentado una gran comunidad de desarrolladores y entusiastas de utilizar el código de fuente abierta como una base para impulsadas por proyectos comunitarios, que añaden nuevas características para usuarios avanzados o llevar Android a los dispositivos que fueron lanzados oficialmente funcionando como sistema operativo. Clasificación de los dispositivos móviles

En la década de los 90, tras la aparición de estos primeros dispositivos, se establecieron clasificaciones más o menos rigurosas era posible debido a que cada aparato estaba claramente definido para una función determinada o para un público concreto. Por ejemplo, un smartphone representa una evolución de un teléfono móvil tradicional, su cometido es ofrecer comunicación telefónica; sin embargo, cuenta con otros servicios adicionales como la conexión a Internet y aplicaciones, servicios propios de un ordenador, cámara de fotos y de vídeo o la posibilidad de reproducir películas o videojuegos. La clasificación que a aquí se propone utilizar como principal criterio la funcionalidad o servicio principal para la que ha sido diseñado bien el propio dispositivo móvil, o bien aquel dispositivo del que directamente procede y del que supone una evolución mejorada. Los dispositivos móviles pueden ser clasificados en los siguientes grupos: 

Dispositivo de comunicación: Un dispositivo de comunicación es aquel dispositivo móvil cuyo cometido principal es ofrecer una infraestructura de comunicación, principalmente telefónica. Estos dispositivos ofrecen además servicios como el envío de mensajes SMS y MMS, o acceso WAP.

Además se incluiría el tradicional teléfono móvil, precursor indiscutible dentro de los

dispositivos

móviles,

la

BlackBerry

y

el

smartphone,

que

amplía

considerablemente las prestaciones del primero mediante pantalla táctil, conexión a Internet o la ejecución de aplicaciones (por ejemplo, iPhone o HTC G1). 

Dispositivo de computación: Los dispositivos de computación son aquellos dispositivos móviles que ofrecen mayores capacidades de procesamiento de datos y cuentan con una pantalla y

teclado más cercanos a un

ordenador de sobremesa. Dentro de los dispositivos móviles son sin duda los que mayores prestaciones hardware ofrecen un mayor tamaño, peso y precio.

Smartphone: (cuya traducción en español sería “teléfono inteligente”) es una evolución del teléfono móvil tradicional que cuenta con ciertas características y prestaciones que lo acercan más a un ordenador personal que a un teléfono tradicional. Las características, se puede encontrar una mejora en la capacidad de proceso y almacenamiento de datos, conexión a Internet mediante Wi-Fi, pantalla táctil, acelerómetro, posicionador geográfico, teclado QWERTY y diversas aplicaciones de usuario como navegador web, cliente de correo, aplicaciones ofimáticas, reproductores de vídeo y audio, etc. incluyendo la posibilidad de descargar e instalar otras nuevas. Los smartphone las limitaciones se reflejan en pantallas más pequeñas, menor capacidad del procesador, restricciones de memoria RAM y memoria persistente, y necesidad de adaptar el consumo de energía a la capacidad de una pequeña batería. Funciones del emulador: El SDK de Android incluye un completo emulador que permite

probar

desarrollando.

y depurar eficientemente Este

emulador

incluye

las

aplicaciones

diferentes

skins

que

para

se van

representar

gráficamente un dispositivo móvil real, con pantalla, teclado y botones de función, así como aplicaciones de usuario preinstaladas que incluyen navegador web o visor de mapa, y una consola que permite interactuar con él a través de Telnet.

Saberes

N°3

Instalación de Android

En este apartado el profesor explicará la manera de instalar el emulador del sistema operativo, utilizando tecnologías de información para su apoyo.

Descarga de herramientas necesarios para programar para Android.

1 - Primero debemos instalar el compilador de Java y la máquina virtual. Estas herramientas las podemos descargar de: Java SE Development Kit (JDK). 2 - El segundo paso es la descarga del editor Eclipse, lo hacemos del sitio: Eclipse IDE for Java Developers. 3 - El tercer paso es descargar el SDK Android, lo podemos descargar de: SDK de Android El archivo que descargaremos es el zip: android-sdk_rxx-windows.zip (donde xx es el número de la última versión) Descomprimimos el archivo y lo ubicamos en la raiz de la unidad c\:, luego de descomprimir tenemos una carpeta llamada: c:\android-sdk-windows 4 - El cuarto paso es ejecutar el programa: c:\android-sdk-windows\SDK Manager.exe que se encuentra en la carpeta que acabamos de descomprimir el SDK de Android. Aparece esta ventana (presionamos cancelar con el objetivo de seleccionar una AVD (Android Virtual Device) y no tener que esperar una eternidad descargando todas las versiones de AVD):

Instalaremos en primera instancia la versión del SDK 2.3.3 (la línea 2 está orientada al desarrollo de aplicaciones para celulares y la línea 3 está orientada a tablet). Seleccionamos Available packages y luego del lado derecho solo dejamos tildado la versión del SDK 2.3.3 (más adelante podemos instalar otras versiones de Android) Por último procedemos a presionar el botón "Install Selected":

Aparece

un

diálogo

donde

nos

informa

el

progreso

de

instalación:

Ahora ya podemos cerrar la aplicación del SDK Manager.exe 5 - Instalación del plugin de Eclipse para trabajar con Android. Para instalar el plugin ingresamos al entorno Eclipse. Luego desde el menú de opciones: Help-> Install New Software, aparece el siguiente diálogo, presionamos el botón add y disponemos la url donde se encuentra el plugin:

En Location disponemos la url: https://dl-ssl.google.com/android/eclipse/ Tildamos "Developer Tools", presionamos seguidamente el botón "Next" dos veces hasta que aparece la ventana donde tenemos que aceptar los "Términos y Condiciones" y presionamos el botón "Finish" Al finalizar la instalación del plugin se reinicia el Eclipse para que se instale completamente. 6 - El siguiente paso que debemos efectuar para poder empezar a desarrollar aplicaciones para Android es configurar el SDK: Para esto nos dirigimos a la opción Windows -> Preferences donde aparece el siguiente diálogo:

Seleccionamos la carpeta donde descomprimimos SDK de Android y presionamos el botón "Apply" 7 - Por último debemos crear el AVD (Android Virtual Device) para ello nos dirigimos a la opción Window -> Android SDK and AVD Manager. En este diálogo debemos crear el emulador de Android (presionamos el botón New...):

En este diálogo asignamos un nombre a nuestro AVD, lo enlazamos con la versión

de

SDK

respectivo,

fijamos

un

tamaño

al

SD

Ya tenemos todo configurado para el desarrollo de aplicaciones Android.

Saberes

N°3

Mi primer programa

Card:

SABERES A ADQUIRIR

Conocer la estructura y funcionamiento de Eclipse.

Ya tenemos todo lo necesario instalado para implementar el primer proyecto. Desde el menú de opciones: File -> New -> Android Project

En este diálogo especificamos el nombre del proyecto y el nombre del paquete java donde se almacenarán los archivos java que creemos.

El plugin de Android nos genera todos los directorios y archivos básicos para iniciar nuestro proyecto:

No haremos en este momento un análisis del significado y objetivo de cada uno de estos directorios y archivos generados, sino a medida que avancemos con este curso iremos viendo en forma puntual y profunda. La interfaz visual de nuestro programa para Android se almacena en un archivo XML en la carpeta res, subcarpeta layout y el archivo se llama main.xml. En esta carpeta tenemos creada nuestra primer pantalla. Al seleccionar este archivo el plugin de Android nos permite visualizar el contenido en "vista de diseño (Graphical Layout)":

Si seleccionamos la otra pestaña podemos visualizar el archivo main.xml en formato de texto:

El plugin Android ya insertó un control de tipo LinealLayout que especifica que todos los controles visuales que se inserten se dispondrán uno debajo del otro ya que la propiedad orientation está inicializada con el valor vertical (orientation="vertical") Ya veremos que podemos modificar todo este archivo para que se adapte a la aplicación que queremos desarrollar. Luego contenido en el control LinealLayout hay otro control de tipo TextView que es básicamente una etiqueta o label que mostrará en pantalla el valor almacenado en la propiedad text. Podemos modificar directamente el archivo xml o en "vista de diseño" modificar los valores de las propiedades. Elegimos nuevamente la pestaña "Graphical Layout" y seleccionamos el TextView con el mouse y presionamos el botón derecho del mouse, buscamos la propiedad text y la cambiamos por la etiqueta: "Mi primer programa para Android":

Con esto ya podemos probar nuestra primer aplicación para un dispositivo Android. Presionamos Run desde el menú o el ícono respectivo. Seleccionamos que se ejecute como aplicación "Android Application". Ahora se abrirá el AVD(Android Virtual Device) esto tarda bastante tiempo, es muy importante recordar que luego de ver ejecutándose el programa NO debemos cerrar el AVD para que la próxima ejecución se inicie más rápido (podemos minimizar el AVD) Ahora podemos ver nuestra primer aplicación corriendo en el emulador de Android:

Como hemos visto el plugin de Eclipse nos genera en forma automática todas las carpetas y archivos básicos que necesitamos en un principio. En el siguiente concepto podremos empezar a programar verdaderamente. El único objetivo de este ejercicio es recordar los pasos para crear un proyecto.

Saberes

N°4

Conociendo más de Java en Eclipse. SABERES A ADQUIRIR

Controles:

Edith Text Radio Group Radio Button Check box

Spinner Image Button Un segundo Activity Paso de parámetros. Almacenamiento de datos en un archivo de texto en memoria interna , y en tarjetas SD Layouts

Captura del clic de un botón Problema:

Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer un Button para sumar los dos valores ingresados. Mostrar el resultado en un tercer TextView. La interfaz visual debe quedar algo semejante a esto:

Veamos paso a paso como creamos la interfaz visual de nuestro programa. Primero borramos el TextView que aparece por defecto cuando se crea un proyecto con el plugin de Android. Ahora desde la ventana "Palette" seleccionamos de la pestaña "Form Widgets" el control "TextView" y lo arrastramos a la ventana de diseño de nuestra interfaz:

Ahora lo seleccionamos y presionamos el botón derecho del mouse sobre la componente y especificamos la propiedad text (como habíamos visto anteriormente) disponemos el texto "Ingrese el primer valor:":

También vamos a especificar la propiedad "Id", la misma parece primera en el menú contextual:

Le asignaremos como nombre a este objeto: tv1 (recordemos que se trata de un objeto de la clase TextView) Ahora de la paleta de componentes seleccionamos la pestaña "Text Fields" y arrastramos el primero (el que tiene la etiqueta abc)

Presionando el botón derecho sobre el control EditText configuramos la propiedad Id... con el nombre et1 (este nombre haremos referencia posteriormente desde Java) Efectuamos los mismos pasos para crear el segundo TextView y EditText (inicializamos las propiedades respectivas) Definimos los id con los nombres tv2 y et2, el resultado visual debe ser algo semejante a esto:

De la pestaña "Form Widgets" arrastramos un control de tipo "Button":

Inicializamos la propiedad text con el texto "Sumar" y la propiedad id la dejamos con el valor ya creado llamado "button1". Para terminar con nuestra interfaz visual arrastramos un tercer objeto de tipo TextView y definimos la propiedad id con el valor "tv3" y la propiedad text con

el texto "resultado", recordemos que la interfaz final debe ser semejante a esta:

Si en este momento ejecutamos la aplicación aparece la interfaz visual correctamente pero cuando presionemos el botón no mostrará la suma. Hasta ahora hemos trabajado solo con el archivo xml (main.xml) donde se definen los controles visuales de la ventana que estamos creando. Abrimos seguidamente el archivo Proyecto002Activity.java que lo podemos ubicar en la carpeta src:

La clase Proyecto002Activity hereda de la clase Activity. La clase Activity representa una ventana de Android y tiene todos los métodos necesarios para crear y mostrar los objetos que hemos dispuesto en el archivo xml. El código fuente de la clase Proyecto002Activity.java es:

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

Como mínimo se debe sobrescribir el método onCreate heredado de la clase Activity donde procedemos a llamar la método setContentView pasando como referencia una valor almacenado en una constante llamada main contenida en una clase llamada layout que a su vez la contiene una clase llamada R (veremos más adelante que el plugin de Eclipse para Android se encarga de crear la clase R en forma automática y sirve como puente entre el archivo xml y nuestra clase Proyecto002Activity) Captura de eventos.

Ahora viene la parte donde definimos variables en java donde almacenamos las referencias a los objetos definidos en el archivo XML. Definimos tres variables, dos de tipo EditText y finalmente una de tipo TextView (estas dos clases de declaran en el paquete android.widget, es necesario importar dichas clases para poder definir las variables de dichas clases):

package androidya.proyecto002; import import import import

android.app.Activity; android.os.Bundle; android.widget.EditText; android.widget.TextView;

public class Proyecto002Activity extends Activity { private EditText et1,et2; private TextView tv3; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } } Los nombres que le dí a los objetos en este caso coinciden con la propiedad id (no es obligatorio): private EditText et1,et2; private TextView tv3;

No definimos TextView para los dos mensajes "Ingrese el primer valor" e "Ingrese el segundo valor" ya que no necesitaremos interactuar con ellos. También veremos que el objeto de la clase Button no es necesario definir un atributo sino que desde el archivo XML inicializaremos la propiedad OnClick. En el método onCreate debemos enlazar estas variables con los objetos definidos en el archivo XML, esto se hace llamando al método findViewById: public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); }

Al método findViewById debemos pasar la constante creada en la clase R (recordemos que se crea automáticamente esta clase) el nombre de la constante si debe ser igual con el nombre de la propiedad del objeto creado en el archivo XML. Como la clase findViewById retorna una clase de tipo View luego debemos utilizar el operador cast (es decir le antecedemos entre paréntesis el nombre de la clase) Ya tenemos almacenados en las variables las referencias a los tres objetos que se crean al llamar al método:setContentView(R.layout.main); . Ahora planteamos el método que se ejecutará cuando se presione el botón (el método debe recibir como parámetro un objeto de la clase View) En nuestro ejemplo lo llamé sumar:

package androidya.proyecto002; import import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.widget.EditText; android.widget.TextView;

public class Proyecto002Activity extends Activity { private EditText et1,et2; private TextView tv3; /** Called when the activity is first created. */ @Override

public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); } //Este método se ejecutará cuando se presione el botón public void sumar(View view) { } } Ahora debemos ir al archivo XML e inicializar la propiedad OnClick del objeto button1 con el nombre del método que acabamos de crear (este paso es fundamental para que el objeto de la clase Button pueda llamar al método sumar que acabamos de crear):

Finalmente implementaremos la lógica para sumar los dos valores ingresados en los controles EditText: public void sumar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); }

Extraemos el texto de los dos controles de tipo EditText y los almacenamos en dos variables locales de tipo String. Convertimos los String a tipo entero, los sumamos y el resultado lo enviamos al TextView donde se muestra la suma (previo a convertir la suma a String) La clase completa queda entonces como:

package androidya.proyecto002;

import import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.widget.EditText; android.widget.TextView;

public class Proyecto002Activity extends Activity { private EditText et1,et2; private TextView tv3; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); } //Este método se ejecutará cuando se presione el botón public void sumar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); }

} Si ejecutamos nuestro programa podemos ver ahora que luego de cargar dos valores al presionar el botón aparece en el tercer TextView el resultado de la suma de los dos EditText:

Controles RadioGroup y RadioButton El objetivo de este concepto es practicar la implementación de un programa que requiera controles de tipo RadioButton para seleccionar una actividad. Aprenderemos como agrupar un conjunto de RadioButton y verificar cual está seleccionado. Problema:

Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer dos controles de tipo RadioButton para seleccionar si queremos sumar o restar dichos valores.

Finalmente mediante un control de tipo Button efectuamos la operación respectiva. Mostramos el resultado en un TextView. El problema es similar al anterior. Para disponer los controles de tipo RadioButton debemos en realidad primero insertar un control de tipo RadioGroup (este control se encuentra en la paleta de componentes en la pestaña FormWidgets):

Cuando arrastramos el control RadioGroup al formulario se generan automáticamente 3 objetos de la clase RadioButton contenidos dentro del RadioGroup, podemos fácilmente identificar que los controles RadioButton pertenecen a dicho RadioGroup viendo la ventana de "Outline" del Eclipse (donde nos muestra todos los controles insertados hasta el momento):

Nuestro problema solo requiere dos controles de tipo RadioButton. Para borrarlo lo podemos hacer directamente del formulario seleccionándolo y presionando la tecla delete o seleccionándolo desde la ventana "Outline" y luego presionando la tecla delete . Ahora a los dos controles de tipo RadioButton definimos sus id (los llamaremos r1 y r2 respectivamente) Cambiamos sus propiedades text por los textos "sumar" y "restar". No olvidemos también cambiar los id de los controles EditText por et1 y et2 (igual que en el problema anterior) Por último agreguemos un botón y un TextView para mostrar el resultado Inicializamos las propiedades del botón con los valores: id : button1 text : operar

Y el tercer TextView con los valores: id : tv3 text : resultado

Podemos controlar en la ventana "Outline" el id definido para cada control (tv1, et1, tv2, et2, radioGroup1, r1, r2, button1, tv3) También podemos observar de que clase es cada control visual y el texto de la

propiedad text para aquellos controles que tienen sentido su inicialización.

Si nuestro problema requería más de 3 RadioButton deberíamos arrastrar dentro del RadioGroup otros controles de tipo RadioButton que se encuentran también en la pestaña de "Form Widgets" Captura del evento clic del button e identifiación del RadioButton seleccionado.

El código fuente de la clase Proyecto003Activity es:

package androidya.proyecto003; import import import import

android.view.View; android.widget.EditText; android.widget.RadioButton; android.widget.TextView;

public class Proyecto003Activity extends Activity { private EditText et1,et2; private TextView tv3; private RadioButton r1,r2;

/** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); r1=(RadioButton)findViewById(R.id.r1); r2=(RadioButton)findViewById(R.id.r2); } //Este método se ejecutará cuando se presione el botón public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); if (r1.isChecked()==true) { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (r2.isChecked()==true) { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } } }

Primero debemos enlazar el objeto button1 con el método operar. Para esto similar al problema anterior seleccionamos el control button1 y cambiamos la propiedad OnClick por el valor operar (si no hacemos esto nunca se ejecutará el método operar de la clase Proyecto003Activity) Como podemos ver el código fuente es igual al problema anterior. Tenemos dos objetos más que debemos inicializar en el método onCreate: r1=(RadioButton)findViewById(R.id.r1); r2=(RadioButton)findViewById(R.id.r2);

Las variables r1 y r2 son de la clase RadioButton y son necesarios en el método operar para verificar cual de los dos RadioButton están seleccionados. La clase RadioButton tiene un método llamado isChecked que retorna true si dicho elemento está seleccionado: public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); if (r1.isChecked()==true) { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (r2.isChecked()==true) { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } }

Control CheckBox El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el control visual CheckBox Problema:

Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer dos controles de tipo CheckBox para seleccionar si queremos sumar y/o restar dichos valores. Finalmente mediante un control de tipo Button efectuamos la operación respectiva. Mostramos el o los resultados en un TextView. Lo nuevo en este problema es la inserción de dos objetos de la clase CheckBox que se encuentra en la pestaña "FormWidgets":

Luego la interfaz gráfica final para este problema y los nombres de los controles los podemos ver en la ventana "Outline":

No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor "operar" (es el nombre del método a ejecutarse cuando se presione el botón y lo implementa la clase que hacemos) Código fuente:

package androidya.proyecto004; import import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.widget.CheckBox; android.widget.EditText;

import android.widget.TextView; public class Proyecto004Activity extends Activity { private EditText et1,et2; private TextView tv3; private CheckBox checkBox1,checkBox2; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); checkBox1=(CheckBox)findViewById(R.id.checkBox1); checkBox2=(CheckBox)findViewById(R.id.checkBox2); } //Este método se ejecutará cuando se presione el botón public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); String resu=""; if (checkBox1.isChecked()==true) { int suma=nro1+nro2; resu="La suma es: "+ suma;

} if (checkBox2.isChecked()==true) { int resta=nro1-nro2; resu=resu + " La resta es: "+ resta; } tv3.setText(resu); } } Definimos dos objetos de la clase CheckBox como atributos de la clase: private CheckBox checkBox1,checkBox2;

En el método onCreate los inicializamos con los objetos definidos en el archivo XML: checkBox1=(CheckBox)findViewById(R.id.checkBox1); checkBox2=(CheckBox)findViewById(R.id.checkBox2);

En el método operar debemos definir dos if a la misma altura ya que los dos controles de tipo CheckBox pueden estar seleccionados simultaneamente. Definimos una variable de tipo String y la inicializamos con cadena vacía para el caso en que los dos CheckBox no estén seleccionados: String resu=""; if (checkBox1.isChecked()==true) { int suma=nro1+nro2; resu="La suma es: "+ suma; } if (checkBox2.isChecked()==true) { int resta=nro1-nro2; resu=resu + " La resta es: "+ resta; } tv3.setText(resu);

Control Spinner El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el control visual Spinner El control Spinner muestra una lista de String y nos permite seleccionar uno de ellos. Cuando se lo selecciona se abre y muestra todos sus elementos para permitir seleccionar uno de ellos. Problema:

Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer un control de tipo Spinner que permita seleccionar si queremos sumar, restar, multiplicar o dividir

dichos valores. Finalmente mediante un control de tipo Button efectuamos la operación respectiva. Mostramos el resultado en un TextView. Lo nuevo en este problema es la inserción de un control de tipo Spinner que se encuentra en la pestaña "FormWidgets":

Definimos la propiedad id con el valor spinner1. En la siguiente imagen en la ventana "Outline" de Eclipse podemos observar los objetos dispuestos en el formulario, sus Id, sus textos y de que clase son cada uno:

No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor "operar" (dicho nombre es el método que debemos implementar) Código fuente:

package androidya.proyecto005; import import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.widget.ArrayAdapter; android.widget.EditText;

import android.widget.Spinner; import android.widget.TextView; public class Proyecto005Activity extends Activity { private Spinner spinner1; private EditText et1,et2; private TextView tv3; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); spinner1 = (Spinner) findViewById(R.id.spinner1); String []opciones={"sumar","restar","multiplicar","divid ir"}; ArrayAdapter adapter = new ArrayAdapter(this,android.R.layout.simple _spinner_item, opciones); spinner1.setAdapter(adapter); } //Este método se ejecutará cuando se presione el botón public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2);

String selec=spinner1.getSelectedItem().toString(); if (selec.equals("sumar")) { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (selec.equals("restar")) { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } else if (selec.equals("multiplicar")) { int multi=nro1*nro2; String resu=String.valueOf(multi); tv3.setText(resu); } else if (selec.equals("dividir")) { int divi=nro1/nro2; String resu=String.valueOf(divi); tv3.setText(resu); } } } Definimos un objeto de la clase Spinner: private Spinner spinner1;

En el método onCreate obtenemos la referencia al control visual declarado en el archivo XML: spinner1=(Spinner)findViewById(R.id.spinner1);

Definimos un vector con la lista de String que mostrará el Spinner: String []opciones={"sumar","restar","multiplicar","dividir"};

Definimos y creamos un objeto de la clase ArrayAdapter:: ArrayAdapter adapter = ArrayAdapter(this,android.R.layout.simple_spinner_item, opciones);

new

Al constructor le pasamos como primer parámetro la referencia de nuestro Activity (this), el segundo parámetro indica el tipo de Spinner, pudiendo ser las constantes: android.R.layout.simple_spinner_item android.R.layout.simple_spinner_dropdown_item

El tercer parámetro es la referencia del vector que se mostrará: Luego llamamos al método setAdapter de la clase Spinner pasando la referencia del objeto de la clase ArrayAdapter que acabamos de crear: spinner1.setAdapter(adapter);

En el método operar que se ejecuta cuando presionamos el botón procedemos a extraer el contenido seleccionado del control Spinner: String selec=spinner1.getSelectedItem().toString();

Luego mediante una serie de if anidados verificamos si debemos sumar, restar, multiplicar o dividir: if (selec.equals("sumar")) { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (selec.equals("restar")) { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } else if (selec.equals("multiplicar")) { int multi=nro1*nro2; String resu=String.valueOf(multi); tv3.setText(resu); } else if (selec.equals("dividir")) { int divi=nro1/nro2; String resu=String.valueOf(divi); tv3.setText(resu); }

Control ImageButton Hemos visto la creación de objetos de la clase Button, ahora veremos otra clase muy similar a la anterior llamada ImageButton que tiene la misma filosofía de manejo con la diferencia que puede mostrar una imagen en su superficie. Problema:

Disponer un objeto de la clase ImageButton que muestre una imagen de un teléfono. Cuando se presione mostrar en un control TextView el mensaje "Llamando". Primero crearemos un proyecto llamado proyecto007 y luego debemos buscar una imagen en formato png que represente un telefono de 50*50 píxeles. Nombre del archivo: telefono.png Ahora copiamos el archivo a la carpeta de recursos de nuestro proyecto : res\drawable-mdpi Desde el Eclipse en la ventana "Package Explorer" navegamos hasta la carpeta res y entramos al directorio drawable-mdpi y vemos que todavía no está el archivo que acabamos de copiar. Para que se actualice el proyecto presionamos el botón derecho del mouse sobre esta carpeta y seleccionamos la opción "Refresh":

Vemos que se actualizó el contenido de la carpeta y aparece la imagen que copiamos previamente. Ahora insertaremos el objeto de la clase ImageButton en el formulario de nuestra aplicación. La clase ImageButton se encuentra en la pestaña "Image & Media":

Aparece un diálogo de donde seleccionamos el archivo telefono. Luego de esto podemos ver que la superficie del objeto de la clase ImageButton muestra la imagen que almacenamos previamente en la carpeta de res. Si queremos cambiar el archivo a mostrar debemos modificar la propiedad src (aparece nuevamente el diálogo que nos permite seleccionar la imagen) Inicializamos la propiedad ID con el nombre bi1 Agreguemos un TextView a nuestra aplicación y configuremos sus propiedades ID (con tv1) y text. Luego la interfaz visual debe ser similar a:

Código fuente:

package androidya.proyecto007; import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.widget.TextView;

public class Proyecto007Activity extends Activity { private TextView tv1; private ImageButton ib1; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); tv1=(TextView)findViewById(R.id.tv1); } //Este método se ejecutará cuando se presione el ImageButton public void llamar(View view) { tv1.setText("Llamando"); } } Definimos los dos atributos: TextView tv1;

Enlazamos el control definido en el archivo XML y la variable de java: tv1=(TextView)findViewById(R.id.tv1);

Implementamos el método que se ejecutará cuando se presione el el objeto de la clase ImageButton: public void llamar(View view) { tv1.setText("Llamando"); }

No olvidemos inicializar la propiedad OnClick del objeto ib1 con el nombre del método "llamar" (recordemos que esto lo hacemos presionando el botón derecho del mouse sobre la imagen del objeto de la clase ImageButton y desde la opción properties accedemos a la propiedad OnClick)

Comentarios extras de este control.

Cuando copiamos el archivo lo hicimos a la carpeta: drawable-mdpi

Pero vimos que hay otras dos carpetas con nombres similares:

drawable-ldpi drawable-hdpi

El objetivo de estas otras dos carpetas es guardar las mismas imágenes pero con una resolución mayor si la guardamos en drawable-hdpi y con una resolución menor al guardarla en drawable-ldpi. Esto se hace si queremos que nuestra aplicación sea más flexible si se ejecuta en un celular, en un tablet, en un televisor etc. Debemos tener en cuenta estos tamaños: En la carpeta res/drawable-mdpi/ (guardamos la imagen con el tamaño original) En la carpeta res/drawable-ldpi/ (guardamos la imagen con el tamaño del 75% con respecto al de la carpeta drawable-mdpi) En la carpeta res/drawable-hdpi/ (guardamos la imagen con el tamaño del 150% con respecto al de la carpeta drawable-mdpi)

Lanzar un segundo "Activity" Hasta ahora todos los programas han tenido una sola ventana (Activity) Es muy común que una aplicación tenga más de una ventana. Para implementar esto en Android debemos plantear una segunda clase que también herede de la clase Activity (tengamos en cuenta que cuando utilizamos el plugin de Eclipse para Android automáticamente cuando creamos un proyecto nos crea el archivo XML y java de la primer Activity) Vamos a ver en este concepto los pasos que debemos dar para crear otro Activity y como activarlo desde el Activity principal. Problema:

Confeccionar un programa que muestre en la ventana principal un botón que al ser presionado muestre otra ventana (Activity) mostrando un TextView con el nombre del programador de la aplicación y un botón para cerrar la ventana. 1 - Primero creamos un nuevo proyecto que lo llamaremos proyecto008 y en la ventana principal creamos la siguiente interfaz:

Es decir que nosotros queremos que cuando se presione el botón "Acerca De" nos abra otra ventana (Activity) y nos muestre el nombre del programador. 2 - Ahora tenemos que crear el segundo Activity. Crearemos primero el archivo XML. Presionamos el botón derecho sobre la carpeta layout y seleccionaremos

la

opción

New

->

Android

XML

File

Aquí tenemos que definir el nombre del archivo XML (debe estar en minúsculas), lo llamaremos acercade:

Implementamos ahora la interfaz visual de esta segunda ventana (Activity) disponiendo un objeto de la clase TextView donde mostramos el nombre del autor de este programa y un Button para cerrar la ventana.

3 - Tenemos ahora que crear el archivo Java donde dispondremos la funcionalidad de la segunda ventana (Activity) Creamos una nueva clase al proyecto desde el menú contextual(presionamos el botón derecho del mouse sobre el paquete androidya.proyecto008):

Al nombre de la clase la llamamos AcercaDe y debemos especificar que hereda de la clase Activity:

Ahora tenemos que modificar el archivo Java generado con esto:

package androidya.proyecto008; import android.app.Activity; import android.os.Bundle; public class AcercaDe extends Activity { /** Called when the activity is first created. */

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.acercade); } } Como podemos ver la clase AcercaDe hereda de la clase Activity e implementa el método onCreate para enlazar el archivo XML que creamos anteriormente. 4 - Otro paso fundamental es registrar el Activity en el archivo "AndroidManifest.xml" que se encuentra en la raiz principal del proyecto. Seleccionamos el archivo y activamos la pestaña : "Application", presionamos el botón "add" y seleccionamos "Activity":

Por último seleccionamos en "Application Nodes" la actividad creada y definimos la propiedad Name con el nombre de la clase que la implementa (en nuestro caso se llama AcercaDe):

5 - Ahora implementaremos la funcionalidad en la actividad (Activity) principal para que se active la segunda ventana. Inicializamos la propiedad OnClick del objeto de la clase Button con el valor "lanzar", este es el método que se ejecutará cuando se presione. El código fuente de la actividad principal queda:

package androidya.proyecto008; import import import import

android.app.Activity; android.content.Intent; android.os.Bundle; android.view.View;

public class Proyecto008Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } public void lanzar(View view) { Intent i = new Intent(this, AcercaDe.class ); startActivity(i); } } En el método lanzar creamos un objeto de la clase Intent y le pasamos como parámetros la referencia del objeto de esta clase (this) y la referencia del otro Activity (Acerca.class) Llamamos posteriormente al método startActivity pasando el objeto de la clase Intent (con esto ya tenemos en pantalla la ventana del segundo Activity: public void lanzar(View view) { Intent i = new Intent(this, AcercaDe.class ); startActivity(i); }

Si ejecutamos el programa podemos ver que cuando presionamos el botón "Acerca De" aparece la segunda ventana donde se muestra el TextView con el valor "Autor de este programa: Diego" y un botón con el texto "Finalizar" (si presionamos este botón no sucede nada, esto debido a que no hemos asociado ningún evento a dicho botón) 6 - Debemos codificar el evento OnClick de la segunda actividad. Seleccionemos el botón "Finalizar" y definamos en la propiedad OnClick el nombre de método que se ejecutará al presionarse el botón (en nuestro caso lo llamaremos finalizar") : El código fuente de la actividad AcercaDe queda:

package androidya.proyecto008; import android.app.Activity; import android.os.Bundle; import android.view.View; public class AcercaDe extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.acercade); } public void cerrar(View view) { finish(); } } Cuando se presiona el botón finalizar llamando al método finish() que tiene por objetivo liberar el espacio de memoria de esta actividad y pedir que se active la actividad anterior. Ahora nuestro programa está funcionando completamente: Primer Activity:

Segundo Activity:

Ahora ya tenemos el programa funcionando en forma completa.

Problema propuesto 1. Realizar un programa que contenga dos Activity. En el primero que solicite el ingreso de una clave (control Password) Si ingresa la clave "abc123" activar el segundo Activity mostrando en un TextView un mensaje de bienvenida (mostrar en un TextView si se ingrese la clave incorrecta). Llamar al proyecto: proyecto009. En tiempo de ejecución los dos Activity deben mostrarse algo similar a esto:

Lanzar un segundo "Activity" y pasar parámetros. Hemos visto en el concepto anterior que un programa puede tener más de una ventana representando cada ventana con una clase que hereda de Activity. Una situación muy común es que la primer ventana necesite enviar datos a la segunda para que a partir de estos proceda a efectuar una acción. Problema:

Confeccionar un programa que solicite el ingrese de una dirección de un sitio web y seguidamente abrir una segunda ventana que muestre dicha página. Para resolver este problema utilizaremos el control visual WebView que nos permite mostrar el contenido de un sitio web. Crearemos un nuevo proyecto llamado proyecto010 y lo almacenaremos en el package name: androidya.proyecto010. 1 - Nuestro primer Activity tendrá la siguiente interfaz visual (ver controles y ID de los controles):

Tenemos un control de tipo TextView (tv1), otro de tipo EditText y finalmente otro de tipo Button (button1) debemos inicializar las propiedades de cada uno de estos tres objetos. El código fuente de esta Activity es:

package androidya.proyecto010; import import import import import

android.app.Activity; android.content.Intent; android.os.Bundle; android.view.View; android.widget.EditText;

public class Proyecto010Activity extends Activity { private EditText et1;

/** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); } public void ejecutar(View view) { Intent i = new Intent(this, Actividad2.class ); i.putExtra("direccion", et1.getText().toString()); startActivity(i); } } Como podemos ver la diferencia con el concepto anterior es que llamamos al método putExtra de la clase Intent. Tiene dos parámetros de tipo String, en el primero indicamos el nombre del dato y en el segundo el valor del dato: public void ejecutar(View view) { Intent i = new Intent(this, Actividad2.class ); i.putExtra("direccion", et1.getText().toString()); startActivity(i); }

La segunda interfaz visual (recordemos que debemos presionar el botón derecho sobre la carpeta layout y seleccionar la opción New -> Android XML File) la llamaremos actividad2.xml:

En esta interfaz disponemos primero un control de tipo Button (button1) y un objeto de la clase WebView (se encuentra en la pestaña "Composite") y lo dejamos con el ID por defecto llamado webView1 Tenemos que crear el archivo Java donde dispondremos la funcionalidad de la segunda ventana (Activity) Creamos una nueva clase al proyecto desde el menú contextual(presionamos el botón derecho del mouse sobre el paquete androidya.proyecto010) Al nombre de la clase la llamamos Actividad2 y debemos especificar que hereda de la clase Activity Ahora tenemos que modificar el archivo Java generado con esto:

package androidya.proyecto010; import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.webkit.WebView;

public class Actividad2 extends Activity {

private WebView webView1; @Override public void onCreate(Bundle b) { super.onCreate(b); setContentView(R.layout.actividad2); webView1=(WebView)findViewById(R.id.webView1); Bundle bundle=getIntent().getExtras(); webView1.loadUrl("http://"+bundle.getString("dire ccion")); } public void finalizar(View view) { finish(); } } En esta clase definimos una variable de tipo Bundle y la inicializamos llamando al método getExtras() de la clase Intent (esto lo hacemos para recuperar el o los parámetros que envió la otra actividad (Activity)): Bundle bundle=getIntent().getExtras(); webView1.loadUrl("http://"+bundle.getString("direccion"));

El método loadUrl de la clase WebView permite visualizar el contenido de un sitio web. Otro paso fundamental es registrar el Activity en el archivo "AndroidManifest.xml" que se encuentra en la raiz principal del proyecto. Seleccionamos el archivo y activamos la pestaña : "Application", presionamos el botón "add" y seleccionamos "Activity". Por último seleccionamos en "Application Nodes" la actividad creada y definimos la propiedad Name con el nombre de la clase que la implementa (en nuestro caso se llama Actividad2) Como nuestra aplicación debe acceder a internet debemos hacer otra configuración en el archivo "AndroidManifest.xml", debemos ir a la pestaña "Permissions" presionar el botón "Add" y seleccionar "Uses Permissions":

Luego fijar en la propiedad name el valor android.permission.INTERNET Ahora nuestro programa debería estar funcionando completamente. La primer ventana debería ser algo similar a esto:

La segunda ventana debería ser algo similar a esto otro:

Almacenamiento de datos en un archivo de texto en la memoria interna. Otra posibilidad de almacenar datos en nuestro dispositivo Android es el empleo de un archivo de texto que se almacenará en el almacenamiento interno del equipo (la otro posibilidad es almacenarlo en una tarjeta SD Card) Problema:

Confeccionar un programa que permita almacenar notas en un control EditText y cuando se presione un botón almacenar los datos del EditText en un archivo

de texto llamado "notas.txt". Cada vez que se ingrese al programa verificar si existe el archivo de textos "notas.txt" proceder a su lectura y almacenamiento de datos en el EditText. Crear un proyecto en Eclipse de tipo "Android Project" y definir como nombre: proyecto013 y localizarlo en el paquete androidya.proyecto013. La interfaz visual, los controles y sus ID son los siguientes:

El código fuente de la aplicación:

package androidya.proyecto013; import import import import

java.io.BufferedReader; java.io.IOException; java.io.InputStreamReader; java.io.OutputStreamWriter;

import android.app.Activity; import android.os.Bundle; import android.view.View;

import android.widget.EditText; import android.widget.Toast; public class Proyecto013Activity extends Activity { private EditText et1; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); String []archivos=fileList(); if (existe(archivos,"notas.txt")) try { InputStreamReader archivo=new InputStreamReader(openFileInput("notas.txt")); BufferedReader br=new BufferedReader(archivo); String linea=br.readLine(); String todo=""; while (linea!=null) { todo=todo+linea+"\n"; linea=br.readLine(); } br.close(); archivo.close(); et1.setText(todo); } catch (IOException e) { }

} private boolean existe(String[] archivos,String archbusca) { for(int f=0;f Other...:

Ahora seleccionamos en el diálogo siguiente en el cuadro General el ícono de Properties:

Ahora cuando disponemos objetos sobre el formulario o lienzo de nuestra aplicación podemos ver todas las propiedades del objetos seleccionado y modificarlas desde esta ventana:

Por ejemplo si queremos definir la propiedad On Click de un objeto Button debemos seleccionarlo y en la ventana de propiedades cargamos el valor para dicha propiedad:

Layout (TableLayout) El Layout de tipo TableLayout agrupa componentes en filas y columnas. Un TableLayout contiene un conjunto de componentes de tipo TableRow que es el que agrupa componentes visuales por cada fila (cada fila puede tener distinta cantidad de componentes visuales) Cuando disponemos un control de Layouts de tipo TableLayout automáticamente crea cuatro componentes de tipo TableRow que los podemos ver en la ventana "Outline". Podemos borrar o agregar componentes de tipo TableRow según las necesidades de nuestro TableLayout:

Luego de borrar un control de tipo TableRow y agregar componentes de tipo Button la interfaz visual queda como sigue:

Otra propiedad que nos puede ser útil inicializar en los controles que se disponen dentro de un TableLayout es layout_span. Esta propiedad permite que un control se expanda más de una celda. En el siguiente ejemplo el objeto de la clase Button de la segunda fila hemos dispuesto la propiedad layout_span con el valor 2:

Si la propiedad no aparece en la ventana "Properties" cuando seleccionamos el objeto debemos entrar al archivo XML y agregar manualmente dicha propiedad:

Layout (RelativeLayout) Hay varias posibilidades cuando empleamos el RelativeLayout. Primero podemos alinear un control con respecto al Layout que lo contiene. Para probar esto dispondremos un control de tipo RelativeLayout y fijaremos la propiedad Layout_weight con el valor 1 (esto hace que el RelativeLayout ocupe completamente la pantalla) Luego dispondremos un botón en cada vértice y veremos que propiedades son afectadas e inicializadas:

Como podemos ver cada control que agregamos se inicializan alguna de las propiedades: alignParentLeft alignParentRight

alignParentTop alignParentBottom centerHorizontal centerVertical centerInParent

Con este tipo de layout podemos disponer un control en forma relativa a otro control que haya dentro del RelativeLayout. Veamos un ejemplo:

En este ejemplo hemos dispuesto el segundo botón debajo (below) del botón 1 y alineado a la izquierda (luego si desplazamos el botón 1 se desplazará el botón 2) La posición relativa con respecto a otro control puede ser: above (por encima) below (debajo) toLeftOf (a la izquierda de) toRightOf (a la derecha)

Layout (FrameLayout) El control de tipo FrameLayout dispone dentro del contenedor todos los controles visuales alineados al vértice superior izquierdo. Es decir si disponemos dos o más controles los mismos se apilan.

Por ejemplo si disponemos dentro de un FrameLayout un ImageView y un Button luego el botón se superpone a la imagen:

Otra aplicación del control FrameLayout es disponer una serie de controles visuales no visibles e ir alternando cual se hace visible. Problema:

Disponer un ImageView y un Button dentro de un layout FrameLayout. Cuando se inicia la aplicación mostrar solo el botón y al ser presionado ocultar el botón y hacer visible la imagen que muestra el ImageView. Creamos una interfaz visual similar a la siguiente:

Seleccionamos el control ImageView y fijarmos la propiedad Visibility con el valor invisible (esto hace que la imagen no se muestre en pantalla) Luego inicializamos la propiedad On click del control Button indicando el nombre del método que se ejecutará al ser presionado:

El código fuente de la clase es:

package androidya.proyecto016; import import import import import

android.app.Activity; android.os.Bundle; android.view.View; android.widget.Button; android.widget.ImageView;

public class Proyecto016Activity extends Activity { Button b1; ImageView iv1;

/** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); b1=(Button)findViewById(R.id.button1); iv1=(ImageView)findViewById(R.id.imageView1); } public void ocultarBoton(View v) { b1.setVisibility(View.INVISIBLE); iv1.setVisibility(View.VISIBLE); } } Cuando se presiona el botón procedemos a ocultar el botón y hacer visible la imagen: public void ocultarBoton(View v) { b1.setVisibility(View.INVISIBLE); iv1.setVisibility(View.VISIBLE); }

Layout (ScrollView y LinearLayout) El ScrollView junto con un LinearLayout nos permite disponer una cantidad de componentes visuales que superan la cantidad de espacio del visor del celular o tablet. Luego el usuario puede desplazar con el dedo la interfaz creada. Problema:

Disponer un control de tipo ScrollView (que se encuentra en la pestaña Composite). Como veremos automáticamente se crea una componente de tipo LinearLayout e fijemos la propiedad Orientation del LinearLayout con el valor vertical:

Luego dispongamos numerosos botones que superen la cantidad de espacio del dispositivo. Numerar los botones con los números del 1 en adelante:

Luego si ejecutamos el programa veremos que podemos desplazar (scroll) todo el contenido del visor con el dedo:

Otra posibilidad para la implementación de una interfaz en Android es disponer un LinearLayout en la parte superior y un ScrollView en la parte inferior:

Esto hace que en tiempo de ejecución quede fijo el LinearLayout y podamos desplazar con el dedo el ScrollView que aparece en la parte inferior:

Icono de la aplicación Cuando creamos un proyecto para implementar una aplicación con el plugin de Android nos crea un ícono por defecto:

Los íconos e imágenes se almacenan en la carpeta res (resources) y en esta hay tres carpetas llamadas: drawable-mdpi drawable-ldpi drawable-hdpi

Y en cada una de estas hay un archivo llamado icon.png:

Como las resoluciones de los dispositivos Android pueden ser muy distintos (un celular, una tablet, un televisor etc.) se recomienda proporcionar múltiples copias de cada imagen de recursos a diferentes resoluciones y almacenarlos en las carpetas nombradas respetando las siguientes reglas: res/drawable-mdpi/ El ícono debe ser de 48*48 píxeles. res/drawable-ldpi/ 75% del tamaño de las imágenes almacenadas en la carpeta drawablemdpi El ícono debe ser de 36*36 píxeles. res/drawable-hdpi/ 150% del tamaño de las imágenes almacenadas en la carpeta drawablemdpi El ícono debe ser de 72*72 píxeles.

En las versiones más actuales de Android se propone crear una cuarta carpeta llamada: res/drawable-xhdpi/

200% del tamaño de las imágenes almacenadas en la carpeta drawablemdpi

Problema: Crear una aplicación, dibujar y almacenar tres archivos llamados icon.png. Tener en cuenta que el archivo que se almacena en la carpeta drawable-mdpi debe ser de 48 píxeles, el de la carpeta drawable-mdpi de 36 píxeles y el de la carpeta drawable-hdpi debe ser de 72 píxeles de ancho y alto. Ejecutar la aplicación y ver el ícono nuevo.

Reproducción de audio (archivo contenido en la aplicación) Veremos los pasos para reproducir un archivo mp3 (otros formatos soportados por Android son: Ogg, Wav)

Problema: Disponer dos botones con las etiquetas: Gato y León, luego cuando se presione reproducir el archivo de audio respectivo. Los archivos de sonidos almacenarlos en la misma aplicación. Luego de crear el proyecto procedemos a crear una carpeta llamada raw que dependa de la carpeta res, almacenamos los dos archivos mp3 en dicha carpeta:

Luego de copiar los archivos a la carpeta debemos refrescar los archivos contenidos en el proyecto presionando el botón derecho del mouse y seleccionando la opción "Refresh":

Podemos comprobar que los dos archivos están referenciados en el proyecto. Creamos una interfaz con dos botones e inicializamos las propiedades Text y On Click de cada botón:

El código fuente de la clase Proyecto019Activity.java es:

package androidya.proyecto019; import import import import

android.app.Activity; android.media.MediaPlayer; android.os.Bundle; android.view.View;

public class Proyecto019Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);

setContentView(R.layout.main); } public void presionGato(View v) { MediaPlayer mp=MediaPlayer.create(this,R.raw.gato); mp.start(); } public void presionLeon(View v) { MediaPlayer mp=MediaPlayer.create(this, R.raw.leon); mp.start(); } } Cuando copiamos los archivos mp3 se genera luego en la clase R la referencia a los dos archivos y posteriormente los podemos rescatar cuando creamos un objeto de la clase MediaPlayer: MediaPlayer mp=MediaPlayer.create(this,R.raw.gato);

Seguidamente llamamos al método start: mp.start();

Reproducción, pausa, continuación y detención de un archivo de audio. Problema: Confeccionar una aplicación que permita Iniciar un archivo mp3, detener, continuar, detener en forma definitiva y activación o no de la reproducción en forma circular. Crear un archivo mp3 con el programa Audacity contando del 1 al 30. Primero creamos un proyecto y definimos los 5 botones y métodos a ejecutar cuando se presionen los botones respectivos:

Creamos la carpeta raw y almacenamos en la misma el archivo mp3 creado previamente. Refrescamos la carpeta raw para actualizar el archivo mp3:

El código fuente es:

package androidya.proyecto020; import import import import

android.app.Activity; android.media.MediaPlayer; android.os.Bundle; android.view.View;

import android.widget.Button; public class Proyecto020Activity extends Activity { MediaPlayer mp; Button b1; int posicion=0; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); b1=(Button)findViewById(R.id.button5); } public void destruir() { if(mp!=null) mp.release(); } public void iniciar(View v) { destruir(); mp = MediaPlayer.create(this,R.raw.numeros); mp.start(); String op=b1.getText().toString(); if (op.equals("No reproducir en forma circular")) mp.setLooping(false); else mp.setLooping(true); } public void pausar(View v) {

if(mp != null && mp.isPlaying()) { posicion = mp.getCurrentPosition(); mp.pause(); } } public void continuar(View v) { if(mp != null && mp.isPlaying()==false) { mp.seekTo(posicion); mp.start(); } } public void detener(View v) { if(mp != null) { mp.stop(); posicion = 0; } } public void circular(View v) { detener(null); String op=b1.getText().toString(); if (op.equals("No reproducir en forma circular")) b1.setText("reproducir en forma circular"); else b1.setText("No reproducir en forma circular"); } } Primero definimos tres atributos uno de la clase MediaPlayer para administrar el archivo mp3, un entero donde se almacena la posición actual de reproducción en milisegundos (para poder continuarla en el futuro) y la referencia de un objeto de la clase Button: MediaPlayer mp; Button b1;

int

posicion=0;

El método destruir verifica con un if si el objeto de la clase MediaPlayer está creado procede a liberar recursos del mismo llamando al método release: public void destruir() { if(mp!=null) mp.release(); }

El método iniciar que se ejecuta al presionar el botón "Iniciar" primero llama al método destruir (para el caso que el mp3 este en ejecución actualmente) seguidamente creamos un objeto de la clase MediaPlayer llamando al método create (en este hacemos referencia al archivo que copiamos a la carpeta raw) Llamamos al método start. Por último extraemos el texto del quinto botón y verificamos si la reproducción debe ejecutarse en forma circular (en forma indefinida una y otra vez): public void iniciar(View v) { destruir(); mp = MediaPlayer.create(this,R.raw.numeros); mp.start(); String op=b1.getText().toString(); if (op.equals("No reproducir en forma circular")) mp.setLooping(false); else mp.setLooping(true); }

El método pausar verifica que el objeto de la clase MediaPlayer este creado y en ejecución, en caso afirmativo recuperamos la posición actual de reproducción y llamamos seguidamente al método pause: public void pausar(View v) { if(mp != null && mp.isPlaying()) { posicion = mp.getCurrentPosition(); mp.pause(); } }

El método continuar verifica que el objeto de la clase MediaPlayer este creado y la propiedad isPlaying retorne false para proceder a posicionar en que milisegundo continuar la reproducción: public void continuar(View v) { if(mp != null && mp.isPlaying()==false) { mp.seekTo(posicion); mp.start(); } }

El método detener interrumpe la ejecución del mp3 e inicializa el atributo posicion con cero: public void detener(View v) { if(mp != null) { mp.stop(); posicion = 0; } }

Cuando se presiona el botón que cambia si la reproducción se efectúa en forma circular o no procedemos a extraer su texto y según dicho valor almacenamos el valor opuesto: public void circular(View v) { detener(null); String op=b1.getText().toString(); if (op.equals("No reproducir en forma circular")) b1.setText("reproducir en forma circular"); else b1.setText("No reproducir en forma circular"); }

Reproducción de audio (archivo contenido en una tarjeta SD) El objetivo de este concepto es acceder a un archivo mp3 almacenado en la tarjeta SD de nuestro equipo.

Problema: Disponer un botón con la etiqueta: "Gato", luego cuando se presione reproducir el archivo de audio respectivo. El archivo de sonido almacenarlo en la tarjeta SD. Luego de crear el proyecto debemos ejecutar la aplicación en modo depuración para poder acceder a la tarjeta SD que crea el emulador Android. Para ejecutar la aplicación en modo "Debug" presionamos el botón derecha del mouse sobre el proyecto y seleccionamos la opción "Debug A" "Android Aplication":

Una vez que se este ejecutando la aplicación (no importa que todavía no hemos implementado su funcionalidad) procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del menú de opciones de Eclipse: Window -> Show View -> Other :

Y en esta ventana seleccionamos Android -> FileExplorer:

Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android Virtual Device":

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse) Esto lo hacemos mediante un botón que aparece en la parte derecha de esta ventana "Push a file onto device", luego de esto tenemos el archivo montado en la tarjeta SD:

Ahora implementemos la interfaz de nuestra aplicación (un solo botón) que cuando se presione llame al método ejecutar:

El código fuente es:

package androidya.proyecto021; import android.app.Activity;

import import import import import

android.media.MediaPlayer; android.net.Uri; android.os.Bundle; android.os.Environment; android.view.View;

public class Proyecto021Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } public void ejecutar(View v) { Uri datos = Uri.parse(Environment.getExternalStorageDirectory ().getPath() +"/gato.mp3"); MediaPlayer mp=MediaPlayer.create(this, datos); mp.start(); } } Creamos un objeto de la clase Uri llamando al método parse donde indicamos el path y nombre del archivo a recuperar: Uri datos Uri.parse(Environment.getExternalStorageDirectory().getPath() +"/gato.mp3");

=

Creamos el objeto de la clase MediaPlayer pasando ahora la referencia del objeto de la clase Uri: MediaPlayer mp=MediaPlayer.create(this, datos);

Iniciamos la reproducción del mp3: mp.start();

Recordar que para ejecutar este proyecto se debe subir un archivo mp3 llamado "gato.mp3" a la tarjeta SD.

Reproducción de audio (archivo contenido en una tarjeta SD) El objetivo de este concepto es acceder a un archivo mp3 almacenado en la tarjeta SD de nuestro equipo.

Problema: Disponer un botón con la etiqueta: "Gato", luego cuando se presione reproducir el archivo de audio respectivo. El archivo de sonido almacenarlo en la tarjeta SD. Luego de crear el proyecto debemos ejecutar la aplicación en modo depuración para poder acceder a la tarjeta SD que crea el emulador Android. Para ejecutar la aplicación en modo "Debug" presionamos el botón derecha del mouse sobre el proyecto y seleccionamos la opción "Debug A" "Android Aplication":

Una vez que se este ejecutando la aplicación (no importa que todavía no hemos implementado su funcionalidad) procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del menú de opciones de Eclipse: Window -> Show View -> Other :

Y en esta ventana seleccionamos Android -> FileExplorer:

Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android Virtual Device":

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse) Esto lo hacemos mediante un botón que aparece en la parte derecha de esta ventana "Push a file onto device", luego de esto tenemos el archivo montado en la tarjeta SD:

Ahora implementemos la interfaz de nuestra aplicación (un solo botón) que cuando se presione llame al método ejecutar:

El código fuente es:

package androidya.proyecto021; import import import import

android.app.Activity; android.media.MediaPlayer; android.net.Uri; android.os.Bundle;

import android.os.Environment; import android.view.View; public class Proyecto021Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } public void ejecutar(View v) { Uri datos = Uri.parse(Environment.getExternalStorageDirectory ().getPath() +"/gato.mp3"); MediaPlayer mp=MediaPlayer.create(this, datos); mp.start(); } } Creamos un objeto de la clase Uri llamando al método parse donde indicamos el path y nombre del archivo a recuperar: Uri datos Uri.parse(Environment.getExternalStorageDirectory().getPath() +"/gato.mp3");

=

Creamos el objeto de la clase MediaPlayer pasando ahora la referencia del objeto de la clase Uri: MediaPlayer mp=MediaPlayer.create(this, datos);

Iniciamos la reproducción del mp3: mp.start();

Recordar que para ejecutar este proyecto se debe subir un archivo mp3 llamado "gato.mp3" a la tarjeta SD.

Reproducción de audio utilizando el reproductor propio de Android (vía Intent) Otra forma de ejecutar un archivo mp3 es mediante el reproductor interno de Android. Esta aplicación reproduce todos los formatos soportados por Android y tiene una interfaz que le será familiar al usuario de nuestra aplicación.

Problema: Disponer un botón con la etiqueta: "Ejecutar mp3 con el reproductor propio de Android", luego cuando se presione reproducir el archivo de audio respectivo con el reproductor de Android via Intent. El archivo de sonido almacenarlo en la tarjeta SD. Luego de crear el proyecto debemos ejecutar la aplicación en modo depuración para poder acceder a la tarjeta SD que crea el emulador Android. Para ejecutar la aplicación en modo "Debug" presionamos el botón derecha del mouse sobre el proyecto y seleccionamos la opción "Debug A" "Android Aplication":

Una vez que se este ejecutando la aplicación (no importa que todavía no hemos implementado su funcionalidad) procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del menú de opciones de Eclipse: Window -> Show View -> Other :

Y en esta ventana seleccionamos Android -> FileExplorer:

Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android Virtual Device":

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse) Esto lo hacemos mediante un botón que aparece en la parte derecha de esta ventana "Push a file onto device", luego de esto tenemos el archivo montado en la tarjeta SD:

Creamos la interfaz con el Button y especificamos el evento On click:

El código fuente es:

package androidya.proyecto024; import import import import import

android.app.Activity; android.content.Intent; android.net.Uri; android.os.Bundle; android.view.View;

public class Proyecto024Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } public void ejecutar(View v) { Intent intent = new Intent(android.content.Intent.ACTION_VIEW); Uri data = Uri.parse("file:///sdcard"+"/gato.mp3"); intent.setDataAndType(data, "audio/mp3"); startActivity(intent); } } Creamos un objeto de la clase Intent y un objeto de la clase Uri referenciando al archivo mp3 almacenado en la tarjeta SD. Indicamos mediante el método setDataAndType el Uri y el tipo de archivo a reproducir. Activamos la aplicación mediante startActivity.

Menú de opciones con submenú Ahora veremos que podemos desplegar un submenú cuando se selecciona una opción del menú principal. Problema: Confeccionar una aplicación que muestre un menú con dos opciones: una que visualice el texto "Sitios interesantes..." y al ser seleccionado muestre otro submenú con una serie de buscadores. y otra opción en el menú principal para que finalice el programa.

Creamos el archivo "Android XML File" siguiendo los mismos pasos indicados en el concepto anterior, procedemos a crear el primer Item y luego creamos el submenú para dicho menuitem como lo indica la siguiente imagen:

Luego añadimos varios Menu Item al Sub-Menu (uno por cada sitio web a enlazar):

La estructura final del menú de opciones debe ser la siguiente:

El código fuente de la clase Proyecto028Activity.java es: package androidya.proyecto028; import android.app.Activity; import android.content.Intent; import android.net.Uri; import android.os.Bundle; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.widget.Toast; public class Proyecto028Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater=getMenuInflater(); inflater.inflate(R.menu.menu1, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { Intent i; switch (item.getItemId()) { case R.id.item2: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.google.com")); startActivity(i); break; case R.id.item3: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.yahoo.com")); startActivity(i); break; case R.id.item4: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.bing.com"));

startActivity(i); break; case R.id.item5: finish(); } return true; } } El método onCreateOptionsMenu es idéntico al concepto anterior. En el método onOptionsItemSelected verificamos cual de los MenuItem es seleccionado y procedemos a invocar mediante un Intent al navegador configurado por defecto para el dispositivo. La visualización del submenú en tiempo de ejecución es similar a:

31 - Menú de opciones con íconos en los MenuItem

Otra posibilidad es disponer gráficos dentro de los MenuItem de nuestro programa.

Problema: Confeccionar una aplicación que muestre un menú con dos opciones: una que active el navegador con YouTube y otra que active Facebook. Disponer un ícono para cada MenuItem. Luego de crear el proyecto procedemos a buscar dos íconos representativos de Youtube y Facebook (dos archivos png de 48 píxeles de ancho y alto) y los almacenamos en la carpeta drawable-mdpi. Luego de refrescar la carpeta debemos tener en nuestro proyecto en dicha carpeta tres archivos:

Procedemos seguidamente a crear el archivo Android XML File (recordemos que lo hacemos presionando el botón derecho del mouse sobre la carpeta res y seleccionando New -> Android XML File) Creamos un menu llamado menu1 y seleccionamos el RadioButton Menu. Ahora tenemos que crear los dos Item y especificar las propiedades Title (con el texto que queremos que se muestre) y la propiedad Icon. Para configurar cada icon procedemos a asignar los valores @drawable/youtube y @drawable/facebook (los nombres coinciden con los nombres de archivos que copiamos a la carpeta drawable) Nos queda agregar solo la funcionalidad de cada MenuItem:

package androidya.proyecto029; import import import import import

android.app.Activity; android.content.Intent; android.net.Uri; android.os.Bundle; android.view.Menu;

import android.view.MenuInflater; import android.view.MenuItem; public class Proyecto029Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater=getMenuInflater(); inflater.inflate(R.menu.menu1, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { Intent i; switch (item.getItemId()) { case R.id.item1: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.youtube.com")); startActivity(i); break; case R.id.item2: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.facebook.com")); startActivity(i); }

return true; } } Luego cuando lo ejecutamos podemos observar el ícono que se muestra en cada MenuItem:

Menú contextuales Otra variante de menú de opciones son los menú contextuales que se pueden asociar a distintos componentes visuales del formulario (TextView, EditText, ListView etc.) Un menú contectual aparece cuando el usuario presiona por un tiempo más o menos prolongado el control visual.

Problema: Confeccionar una aplicación que muestre un EditText y asociarle un menú contextual que permita cambiar el color de fondo del mismo. El menú debe permitir seleccionar entre el rojo, verde y azul. Primero creamos un proyecto y creamos una interfaz con un control de tipo EditText:

Luego creamos el archivo XML que contendrá el menú de opciones (presionamos el botón derecho del mouse sobre la carpeta res de nuestro proyecto y seleccionamos New -> Android XML File):

Aparece un diálogo donde debemos indicar el nombre del archivo de recursos a crear (lo llamamos menu1, este es el nombre del archivo XML que se creará en una carpeta llamada menu que depende de la carpeta res) y seleccionamos el RadioButton de menu Ya tenemos una nueva carpeta llamada menu y un archivo llamado menu1. Creamos las tres opciones del menú:

Ahora veamos como asociar el archivo XML donde definimos el menú con el código Java: package androidya.proyecto030; import android.app.Activity; import android.graphics.Color; import android.os.Bundle; import android.view.ContextMenu; import android.view.ContextMenu.ContextMenuInfo; import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.widget.EditText; public class Proyecto030Activity extends Activity { EditText et1; /** Called when the activity is first created. */

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.editText1); registerForContextMenu(et1); } @Override public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo menuInfo) { menu.setHeaderTitle("Elija el color de fondo:"); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu1, menu); } @Override public boolean onContextItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.item1:et1.setBackgroundColor(Color.rgb(255, 0, 0)) ; break; case R.id.item2:et1.setBackgroundColor(Color.rgb(0, 255, 0)) ; break; case R.id.item3:et1.setBackgroundColor(Color.rgb(0, 0, 255)) ; break; } return true; } } En el método onCreateContextMenu asociamos el archivo XML llamando al método inflate de la clase MenuInflate. Podemos también llamar al método setHeaderTitle para mostrar un título en el menú emergente. @Override public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo menuInfo) { menu.setHeaderTitle("Elija el color de fondo:"); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu1, menu); } Para la captura de eventos de los MenuItem debemos implementar el método onContextItemSelected donde mediante un switch verificamos cual de los MenuItem fue seleccionado y cambiamos el color de fondo del control EditText:

@Override public boolean onContextItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.item1:et1.setBackgroundColor(Color.rgb(255, 0, 0)) ; break; case R.id.item2:et1.setBackgroundColor(Color.rgb(0, 255, 0)) ; break; case R.id.item3:et1.setBackgroundColor(Color.rgb(0, 0, 255)) ; break; } return true; }

AlertDialog simple El diálogo más simple que podemos crear con Android en una ventana con un título, un mensaje y un botón para cerrarlo. Muy útil si tenemos que informar al usuario y no queremos que la ventana desaparezca hasta que el usuario presione un botón para ocultar el diálogo.

Problema: Confeccionar una aplicación que muestre un diálogo cada vez que se inicie la aplicación informando que el programa que está ejecutando es un programa de prueba y no el completo. Primero creamos un proyecto llamado: proyecto031 Lo almacenamos en el paquete: androidya.proyecto031 El código fuente de la aplicación queda como sigue: package androidya.proyecto021; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; public class Proyecto031Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Importante");

builder.setMessage("Este es un programa solo de prueba y no la versión completa"); builder.setPositiveButton("OK",null); builder.create(); builder.show(); } } Como queremos que el diálogo aparezca inmediatamente se arranque la aplicación procedemos a incorporar el código en el método onCreate. Primero debemos importar la clase AlertDialog: import android.app.AlertDialog; La clase AlertDialog contiene otra clase llamada Builder que es la que encapsula la creación de objetos de la clase AlertDialog. Procedemos a definir y crear un objeto de la clase Builder contenida en la clase AlertDialog: AlertDialog.Builder builder = new AlertDialog.Builder(this); Una vez creado el objeto procedemos a llamar al método que define el título a mostrar en el diálogo: builder.setTitle("Importante"); El mensaje propiamente dicho lo configuramos llamando al método setMessage: builder.setMessage("Este es un programa solo de prueba y no la versión completa"); Mostramos un botón para poder cerrar el diálogo: builder.setPositiveButton("OK",null); Finalmente llamamos al método que crea el diálogo y el que lo visualiza: builder.create(); builder.show(); La interfaz visual del diálogo en tiempo de ejecución es:

AlertDialog con botones de confirmar y cancelar Problema: Confeccionar una aplicación que muestre un diálogo cada vez que se inicie la aplicación informando: "¿Acepta la ejecución de este programa en modo prueba?" y dos botones para confirmar o rechazar. En caso que se rechace finalizar la ejecución del programa. Primero creamos un proyecto llamado: proyecto032 Lo almacenamos en el paquete: androidya.proyecto032 El código fuente de la aplicación queda como sigue:

package androidya.proyecto032; import android.app.Activity; import android.app.AlertDialog; import android.content.DialogInterface; import android.os.Bundle; import android.widget.Toast; public class Proyecto032Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this); dialogo1.setTitle("Importante"); dialogo1.setMessage("¿ Acepta la ejecución de este programa en modo prueba ?"); dialogo1.setCancelable(false); dialogo1.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { aceptar(); } }); dialogo1.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { cancelar(); } }); dialogo1.show(); } public void aceptar() { Toast t=Toast.makeText(this,"Bienvenido a probar el programa.", Toast.LENGTH_SHORT); t.show(); } public void cancelar() { finish(); } } Creamos un objeto de la clase AlertDialog a través de la clase Builder:

AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this); Configuramos el título del diálogo: dialogo1.setTitle("Importante"); Configuramos el mensaje del diálogo: dialogo1.setMessage("¿ Acepta la ejecución de este programa en modo prueba ?"); Evitamos que el diálogo sea salteado por cualquier medio distinto a presionar alguno de los dos botones: dialogo1.setCancelable(false); Llamamos al método setPositiveButton indicando el texto a mostrar en el botón y la clase anónima que capturará el evento clic del botón: dialogo1.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { aceptar(); } }); De forma similar procedemos con el botón de cancelar: dialogo1.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { cancelar(); } }); Mostramos el diálogo: dialogo1.show(); Definimos los métodos del Activity que se llamaran desde las clases anónimas: public void aceptar() { Toast t=Toast.makeText(this,"Bienvenido a probar el programa.", Toast.LENGTH_SHORT); t.show(); } public void cancelar() { finish(); } La interfaz del diálogo es similar a esta:

Notificaciones o mensajes mediante la clase Toast La clase Toast nos permite mostrar un mensaje superpuesto a la ventana por un período de tiempo pero sin congelar la aplicación. Este mensaje no permite interactuar con el usuario (no se pueden ingresar datos, seleccionar botones ni obligar a que se cierre) Eventualmente se lo puede localizar en distintas partes del dispositivo. Problema: Confeccionar una aplicación que muestre una serie de botones y active mensajes de notificaciones con la clase Toast. Primero creamos un proyecto llamado: proyecto033 Lo almacenamos en el paquete: androidya.proyecto033

La interfaz visual a implementar son tres botones:

No olvidemos inicializar la propiedad On Click de cada botón con los métodos: prueba1, prueba2 y prueba3. El código fuente de la aplicación queda como sigue: package androidya.proyecto033; import android.app.Activity; import android.os.Bundle; import android.view.Gravity; import android.view.LayoutInflater; import android.view.View; import android.widget.Toast; public class Proyecto033Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);

setContentView(R.layout.main); } public void prueba1(View v) { Toast toast = Toast.makeText(this, "Mensaje 1", Toast.LENGTH_SHORT); toast.show(); } public void prueba2(View v) { Toast toast = Toast.makeText(this, "Mensaje 2", Toast.LENGTH_SHORT); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.show(); } public void prueba3(View v) { LayoutInflater inflater = getLayoutInflater(); View layout = inflater.inflate(R.layout.toast1, null); Toast toast = new Toast(getApplicationContext()); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.setDuration(Toast.LENGTH_LONG); toast.setView(layout); toast.show(); } } Para el evento click del primer botón mostramos el mensaje con las estructura más simple que nos provee la clase Toast. Definimos un objeto de la clase Toast y llamamos al método makeText pasando como parámetro la referencia del Activity, el mensaje a mostrar y una constante indicando si queremos que el mensaje aparezca por un período corto o largo de tiempo en la pantalla. Por último llamamos al método show para que se muestre el mensaje: public void prueba1(View v) { Toast toast = Toast.makeText(this, "Mensaje 1", Toast.LENGTH_SHORT); toast.show(); }

Si queremos ubicar en otra parte de la pantalla debemos llamar al método setGravity e indicar en el primer parámetro una constante (en este ejemplo lo centramos verticalmente) En el segundo y tercer parámetro de setGravity podemos desplazarlo una cantidad de píxeles hacia derecha o izquierda, arriba o abajo según indiquemos valores positivos o negativos. Luego el método completo para este segundo Toast es: public void prueba2(View v) { Toast toast = Toast.makeText(this, "Mensaje 2", Toast.LENGTH_SHORT); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.show(); }

Para generar un Toast customizado debemos crear un archivo XML donde creamos visualmente los controles a mostrar, en este ejemplo creamos el siguiente archivo (crear un archivo llamado toast1.xml):

Este recurso luego lo incorporamos en el Toast mediante el siguiente código: public void prueba3(View v) { LayoutInflater inflater = getLayoutInflater(); View layout = inflater.inflate(R.layout.toast1,null); Toast toast = new Toast(getApplicationContext()); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.setDuration(Toast.LENGTH_LONG); toast.setView(layout); toast.show(); } Mediante la clase LayoutInflate procedemos a leer el contenido del archivo XML creado anteriormente y lo enlazamos con el toast mediante el método: toast.setView(layout); En pantalla luego el Toast customizado aparece de la siguiente forma:

PRACTICA INTEGRADORA Nombre Competencias a desarrollar

Habilidades

Instrucciones para el alumno

Instrucciones para el docente Recursos, materiales de apoyo

Conocimientos a adquirir

Competencias genéricas a desarrollar

Programando mi phone

NO. l

M1 Construye e interpreta modelos matemáticos deterministas o aleatorios mediante la aplicación de procedimientos aritméticos, algebraicos, geométricos y variacionales, para la comprensión y análisis de situaciones reales o formales. Aplicar las instrucciones necesarias y correctas en el desarrollo de un programa para dispositivos móviles. Formar equipos de 5 personas y definir el tema sobre el cual se desarrollará la aplicación. Posteriormente realizar la recopilación de información y definir requerimientos. Realizar el diseño de la aplicación Realizar código El docente tomará el rol de Lider del proyecto, revisando y controlando el avance del mismo. Empresa, negocio o institución de donde se obtendrá la información. Computadora, Dispositivo móvil Libreta, lápiz Manera Aplicar de manera Realizando el didáctica de correcta las ejercicio en el lograrlas sentencias orden indicado. necesarias para desarrollar una aplicación que pueda ejecutarse en cualquier dispositivo móvil 8.3 Asume una actitud constructiva, congruente con los conocimientos y habilidades con los que cuenta dentro de distintos equipos de trabajo.

Errores Confundir las sentencias de programación en java y utilizarlas de manera equivocada. Contingencias No contar con los materiales de apoyo, tales como el sistema operativo android, o con los dispositivos móviles.

Conclusiones de la competencia 1 Durante el desarrollo de esta competencia el alumno adquirirá los saberes, habilidades, atributos y actitudes necesarias sobre los forma de accesar a Eclipse y desarrollar las aplicaiones de software que puedan ser ejecutadas desde un dispositivo móvil, tomando en cuenta los requerimientos del usuario.

Para evaluar los atributos, saberes y actitudes de este contenido o competencia se hará uso de los instrumentos de evaluación como son la LISTA DE COTEJO para las evidencias de producto, GUIAS DE OBSERVACIÓN para las evidencias de desempeño también se empleará algunas RUBRICA que especifiquen la evaluación de um producto especifico como son cuadros comparativos.

Competencia 2 “Desarrolla aplicaciones para dispositivos móviles sobre plataformas cerradas”.

Saberes 1. Conceptos básicos 2. Navegando por la red 3. ¿Qué vamos a desarrollar? ¿Un sitio web o una aplicación? Ejemplos: 1. Conozco plataformas privadas

Atributos de la Competencia 1.- Conocer una plataforma cerrada 2.- Conocer los dispositivos móviles de plataforma cerrada

Introducción a la Competencia 2 En la competencia pasada conociste los beneficios de una aplicaión abierta, el sistema operativo Android, aprendiste a utilizar herramientas de desarrollo como Eclipse + ADT plugin, Android SDK/NDK y un Emulador para programar tu dispositivo móvil. Sin embargo la creación de comunidades de programadores entorno a una determinada plataforma o sistema operativo, con tutoriales específicos y herramientas compartidas, está sufriendo una evolución hacia la creación “privativa” gracias al auge de los smartphones o teléfonos inteligentes.

En esta competencia conocerás algunos sistemas operativos y herramientas de desarrollo que se programan bajo una plataforma cerrada, es decir que se requiere comprar una licencia. Bienvenidos a esta nueva aventura…..

Un recorrido por las plataformas cerradas.

Plataforma cerrada en Windows es un sistema operativo cerrado, esto es por que su fabricante no entrega el código fuente para que sus usuarios modifiquen el sistema y sus aplicaciones (Internet Explore, etc.), por ende al ser cerrado posee otra características, divide a los usuario por medio de una licencia de uso de software

(la

clave

que

se

usa

para

instalar

y

validar

Windows)

Linux es un sistema operativo abierto, por ende su sistema operativo te da la opción de entregar el código fuente y el de sus aplicaciones, para que tu lo adaptes a tus necesidades, y lo compartas con tus amigos, profesores, etc. es por ello que su software es gratis. ¿Pero como gana dinero? es a través de los servicios que se entregan: capacitaciones, cursos, algunas charlas, Libros. Cada uno de los sistemas operativos ofrece una plataforma para que nosotros podamos aprovechar y utilizar las múltiples características de los dispositivos en la construcción de nuestras aplicaciones:

iOS SDK y Xcode 4 Xcode es el entorno de desarrollo que contiene los diferentes SDKs para la construcción de aplicaciones para los sistemas de Appel (iOS y Mac). Se puede descargar de manera gratuita desde la página para desarrolladores Applehttp://developer.apple.com/xcode/ pero únicamente las personas que cuenten con Apple ID y estén registradas como desarrolladores. El SDK de iOS cuenta con un emulador de iOS, pero si se van a probar aplicaciones directamente en el dispositivo los desarrolladores deben pagar una cuota anual de US$99 (que también incluye la publicación de aplicaciones a través de la Apple Store).

Android SDK y NDK Las aplicaciones en Android se ejecutan sobre la Dalvik Virtual Machine (que es una implementación independiente de una maquina virtual de Java pero con una arquitectura diferente), pero también se pueden crear aplicaciones que se ejecuten directamente sobre el sistema operativo (llamadas aplicaciones Nativas). Las aplicaciones se pueden desarrollar tanto de Java (para la DVM) como en C++ (aplicaciones nativas) a partir de sus respectivas herramientas de desarrollo:  

Android SDK para crear aplicaciones con Java Android NDK para crear aplicaciones con C++

Para la publicación de aplicaciones, los desarrolladores deben estar registrados en el Andoird Market y pagar una cuota de registro de US$25. Symbian SDK Symbian es la plataforma que ofrece crear aplicaciones de diferentes sabores. Symbian SDK permite la creación de aplicaciones con Qt ySymbian C++ para móviles S60, y con Java se pueden crear aplicaciones tanto para móviles S60 y S40. Las aplicaciones se distribuyen a través de la Ovi Store con un costo para los desarrolladores, a la hora de registrarse, de 1€. Windows Phone 7 Developer Tools Y no faltaba que revisáramos como desarrollar para la nueva plataforma de Microsoft para dispositivos móviles, desarrollo sobre Windows Phone 7 Resumen de costos de publicación en las diferentes tiendas de aplicaciones Tienda

Costo

Periodo

Apple Store

US$99

Suscripción anual

Andoird Market

US$25

Al registrarse

Ovi Store

1€

Al registrarse



Windows Phone Marketplace



US$99 Gratuito para estudiantes a través deDreamspark

 

Suscripción anual Un año de suscripción gratuita para estudiantes

(No. 1)

Saberes TITULO

Navegando por la red

Instrucciones para el alumno: El alumno conocerá los sistemas operativos de desarrollo móvil sobre los cuales podrá trabajar. Identificando sus características, ventajas y desventajas de cada uno y realizando un ensayo con tal información. Actitudes: 1. Orden. 2. Puntualidad. 3. Responsabilidad.

Saberes a adquirir Competencias Genéricas: . Se expresa y comunica.  Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de medios, códigos y herramientas apropiados. Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta la investigación sustentada con acervo bibliográfico.

Saberes

(No. 2)

Titulo: ¿Qué vamos a desarrollar? ¿Un sitio web o una aplicación? Instrucciones para el alumno: El alumno analizará la información que a continuación se presenta y determinará que es lo que más le conviene en el desarrollo de la aplicación que realizó en la práctica integradora de la competencia 1. Actitudes: 1. Orden. 2. Responsabilidad 2. Puntualidad. Saberes a adquirir Competencias Genéricas: . Se expresa y comunica.  Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de medios, códigos y herramientas apropiados. Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta la proporcionada y el sustento con acervo bibliográfico.

investigación

¿Qué vamos a desarrollar? ¿Un sitio web o una aplicación? Básicamente, esto dependerá de dos grandes factores, infraestructura y costos. Infraestructura, haciendo referencia a la capacidad que tengamos como empresa(o programador independiente) y en el medio. Un ejemplo, sería relativamente sencillo desarrollar un sitio web para teléfonos móviles, con acceso a nuestro sistema, donde, el usuario podría ingresar al sistema desde cualquier punto, en cualquier momento, usando internet. Pero para ello, sería necesario que nuestra empresa contara con, para listar algunos, una línea de internet dedicada, Ips públicos, sistemas de seguridad, etc. Los cuales, indudablemente, involucran el segundo factor, costos. La segunda alternativa, es la de desarrollar directamente en el dispositivo. Con esta opción, la necesidad de infraestructura puede verse reducida, ya que la información, cambios y demás, pueden ser guardados directamente en el dispositivo, para ser

sincronizados luego con el servidor de datos o, como segunda alternativa, al contar con una red interna, este dispositivo puede trabajar conectado a la misma, teniendo la posibilidad de realizar transacciones en línea y usando, la posible infraestructura ya implementada dentro de la empresa. Otro punto fuerte de tener un API nativo es poder hacer aplicaciones que muchas veces no podemos hacerlas vía WEB. Como por ejemplo aplicaciones que acceden a hardware especializado del móvil (GPS, acelerómetro, brújula), aplicaciones que acceden al software especializado del móvil (Media Player, Agenda de contactos, Email, etc), juegos que necesitan de un API 3D para funcionar, entre otras aplicaciones. En resumen, la decisión del qué se va a desarrollar, dependerá de las necesidades de cada empresa o individuo e indudablemente, de otros factores además de los nombrados, como por ejemplo dependiendo del tipo de aplicación que buscamos desarrollar. Algunas características (muy importantes de comprender) que comparten los dispositivos móviles a la hora de la programación son las siguientes:  

La necesidad de ahorrar energía obliga a utilizar procesadores con una capacidad de cómputo limitada y baja frecuencia de reloj El uso intensivo de cálculos, gráficos, sonido, conexiones inalámbricas etc. limita la vida de la batería

La memoria disponible es muy limitada en comparación con la de un ordenador ordinario. El almacenamiento de datos persistente también es muy limitado: memoria interna + tarjetas SD o similar.

Ejercicio

(No. 1)

Titulo: Conozco plataformas privadas . Instrucciones para el alumno: Elabora un mapa mental para cada una de las plataformas Iphone, Blackberry, Apple, Windows Mobile y otras, que describan el sistema operativo que utilizan, SDK, modo de venta de las aplicaciones, lenguajes de programación, licencia, costo, etc.: Actitudes: 1. Orden. 2. Puntualidad. 3. Responsabilidad. Saberes a adquirir: Uso de plataformas cerradas.

Competencias Genéricas: . Se expresa y comunica.  Escucha, interpreta y emite mensajes pertinentes en distintos contextos mediante la utilización de medios, códigos y herramientas apropiados. o Atributo: Expresa ideas y conceptos mediante representaciones, lingüísticas, matemáticas o gráficas.

Manera didáctica de lograrla: A través de una actitud de orden, tomando en cuenta las etapas de las estrategias: con el fin de incluir en ellas los instrumentos necesarios.

Conclusión de la competencia 2 En esta competencia descubriste que el uso de las aplicaciones móviles no solo se refiere a los teléfonos celulares sino a otro tipo de dispositivos, y que los beneficios o prestaciones que ofrecen se incrementan día a día, por ejemplo:  Acceso a internet y conectividad mediante Bluetooth  Envío de SMS  Acelerómetros  Cámaras integradas  Información de localización de GPS  Sensores de orientación  Aceleración 2D y 3D

Conclusión del submódulo

En este submódulo el alumno ha adquirido los conocimientos necesarios para poder desarrollar aplicaciones móviles tomando en cuenta la gran necesidad que sufren las empresas, esto les permitirá en un futuro no muy lejano poder incorporarse a las grandes empresas que exigen una gran demanda de programadores, ya que la programación de dispositivos móviles y de computadoras es parte medular de la informática.

Los conocimientos, ejercicios y prácticas que se han propuesto en esta guía de aprendizaje te permitieron desarrollar las habilidades, destrezas, conocimientos y actitudes necesarias para solucionar problemas utilizando la lógica computacional realizando programas o aplicaciones en una plataforma móvil. De igual manera, para comprobar lo que has desarrollado de la competencia en todos los apartados señalados con anterioridad se utilizarán dos tipos de instrumentos de evaluación: las guías de observación para medir tus desempeños y las listas de cotejo para los productos logrados.

BIBLIOGRAFÍA

http://en.wikipedia.org/wiki/Maemo http://talk.maemo.org/showthread.php?p=319423 http://maemo.org/ http://es.wikipedia.org/wiki/Maemo http://www.htc.com/www/press.aspx http://en.wikipedia.org/wiki/Android_(operating_system) http://androidandme.com/category/phones/ http://www.engadget.com/tag/android/