Android

MANUAL DE ANDROID 1
Android Studio
Android Studio es un entorno de desarrollo integrado para la plataforma Android. Fue anunciado el 16 de mayo de
2013 en la conferencia Google I/O, y reemplazó a Eclipse como el IDE oficial para el desarrollo de aplicaciones
para Android. La primera versión estable fue publicada en diciembre de 2014.
Está basado en el software IntelliJ IDEA de JetBrains, y es publicado de forma gratuita a través de la Licencia
Apache 2.0. Está disponible para las plataformas Microsoft Windows, Mac OS X y GNU/Linux.
Activity
Podemos decir que todas las pantallas de una aplicación son una “activity”. Más adelante vamos a ver que existen
algunas variaciones, pero por ahora digamos que todas lo son. Es decir, que si una aplicación tiene cinco pantallas,
tiene 5 “Actividades” o activities.
Las activities están conformadas por dos partes: la parte lógica y la parte gráfica.
La parte lógica es una archivo .java que es la clase que se crea para poder manipular, interactuar y colocar el
código de esa actividad.
La parte gráfica es un XML que tiene todos los elementos que estamos viendo de una pantalla declarados con
etiquetas parecidas a las del HTML, es decir, que el diseño de una aplicación en Android se hace similar a una
página web; XML es un primo de HTML.
Resumiendo, una actividad está conformada por la parte lógica (un archivo Java) y la parte gráfica (un archivo
XML).
Adentrando más en el tema, ya sabemos que tenemos un archivo .java, esto quiere decir que tenemos una clase
principal, al ser una actividad extiende de la clase Activity (por eso el nombre) que nos proporciona Android para
crear actividades con sus métodos asignados.
Veamos una actividad básica:

Este sería nuestro archivo "ManActivity" como el del ejercicio del "HolaMundo".
package com.example.holamundodesarrollowebcom;
import android.os.Bundle;
import android.app.Activity;
public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Expliquemos por líneas:
package com.example.holamundodesarrollowebcom;
Esta línea únicamente indica el nombre del paquete en donde se encuentra nuestra clase.
Willy Felix Blas Cutipa

MANUAL DE ANDROID 2
import android.app.Activity;
Los dos imports, son la forma de decir que necesitamos esos archivos para trabajar dentro de la clase, los que ya
nos da Android para no tener que escribir las cosas desde cero.
public class MainActivity extends Activity {
@Override
}
}
En esta última sección de código lo que estamos haciendo es crear una clase que se llama "MainActivity" y la
estamos extendiendo de acvitity, en español esto es el concepto de herencia de la famosa programación orientada
a objetos, estamos diciendo que "mainactivity" es una clase que hereda las cosas de la clase Activity que ya tiene
Android definida.
Todas las activities deben llevar por lo menos un método, el método "oncreate", que es en donde se crea la
actividad o podemos decir que es donde se le da vida.
Del método "onCreate" lo más importante es la línea de código: SetContentView(R.Layout.acivity_main).
Que es la que hace el trabajo de enlazar la parte lógica con la parte gráfica. El archivo XML que va a mostrarse
cuando se mande a llamar la clase "MainActivity" es el archivo XML llamado "activity_main".
Para cerrar la explicación: si yo creo una actividad nueva y la llamo "VentanaPrinicipal", debo hacer que herede de
activity si quiero que funcione como actividad y para decirle que el archivo XML que va a mostrar sea el
"ventanaprincipal.xml" o "pepito.xml". La línea que dice "SetContentView" debe llevar dentro algo parecido a esto:
"setContentView"(R.layout.ventanaprincipal).
Más adelante vamos a ver como agregar una actividad nueva, ya que además de esto necesitamos hacer otras
cosas en el proyecto. Espero por ahora que quede claro el término de Activity que vamos a estar utilizando.
Estructura de una aplicación Android
src– Aquí van las clases de nuestra aplicación, es decir los archivos .java.
gen- Son archivos que genera Java y por ninguna razón los debemos tocar. Si lo hacemos, ya no van a servir y
puede que ni el proyecto sirva para más adelante. Cada vez que compilamos, Java se encarga de actualizarlo y de
generarlo de nuevo. Dentro de gen encontramos 2 archivos: el BuildConfig y R. El archivo R es el archivo que tiene
los identificadores de todo lo que tiene la aplicación, por ejemplo imágenes, campos de texto, botones, etc. Java le
asigna un identificador y nosotros no tenemos que preocuparnos por él, ya que le colocamos un nombre común que
podamos recordar y Java sabe cómo se llama para nosotros.
assets- Este directorio contiene recursos de ayuda para la aplicación, audio, videos, bases de datos, la carpeta
"assets" y la carpeta "res" sirven ambas para guardar recursos, pero la diferencia es que los que se encuentran en
"assets" no generan un identificar en el archivo R que vimos se encuentra en el directorio "gen".
bin- Aquí tenemos archivos generados por el mismo Java, que en realidad no los utilizamos y tampoco debemos
manipular, son archivos binarios como bien dice su nombre.

MANUAL DE ANDROID 3
libs- Se encuentran librerías externas que necesita el proyecto.
res- El directorio "res" contiene todos los recursos de la aplicación.
res/drawable- Contiene todas las imágenes y gráficos PNG que vamos a incluir en nuestra aplicación. Cada uno
representa una densidad, más adelante tendremos un capitulo para este tema en específico.
res/layout- En este directorio colocamos todos los XML que son la parte gráfica de nuestras "activities", es decir,
todos los XML que son las pantallas de nuestra aplicación.
res/values- Se encuentran archivos con cadenas de texto que usamos en nuestra aplicación, algunos estilos de
nuestra aplicación.
AndroidManifest.xml- El archivo Manifest es el más importante para nuestra aplicación, es la columna vertebral
de nuestro proyecto, en él declaramos todas las actividades del proyecto, los permisos, versiones del SDK que
usamos y un montón de cosas que vamos a ver más en detalle.
Archivo Manifest
<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.holamundodesarrollowebcom"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="18" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.example.holamundodesarrollowebcom.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
</application>
</manifest>
La primera línea solamente indica la versión y el formato del documento.
Etiqueta Manifest
Etiqueta <manifest> es la etiqueta principal. En ella tenemos unos atributos:

MANUAL DE ANDROID 4
Atributo Package: hace referencia al nombre del paquete de la aplicación, así que si cambiamos el nombre de la
aplicación, este lo debe cambiar o cambiarlo manualmente nosotros.
Atributo VersionCode: esto es el número de versión del código de la aplicación y nos sirve para saber qué version
estamos trabajando; la idea es manejarlo por número de publicación, es decir, que cada vez que vamos actualizar
para publicar la app, deberíamos cambiarlo.
Atributo VersionName: se trata del número de versión también, pero a diferencia del anterior, este número de
versión es el que se muestra en la Playstore. Podemos decir que el "versioncode" es para el desarrollador y el
"versionname" es para el público en general.
Etiqueta SDK
Aquí vamos a colocar parámetros que sirven para saber la compatibilidad de las versiones en Android.
Atributo minSDKVersion: indicamos la versión mínima de SDK con la que va a funcionar la aplicación. Cuando
creamos el proyecto lo indicamos al iniciarlo, pero se puede cambiar manualmente.
Atributo targetSdkVersion: esta es la versión de la API a la que se dirige principalmente nuestra app.
Etiqueta Application
Dentro de este etiqueta tenemos todos los elementos que forman parte de nuestra aplicación.
Atributo allowBackup: si colocamos en "true" este valor, estamos diciéndole al sistema que se permite hacer copia
de seguridad de la aplicación y contenido.
Atributo icon: es el icono de la aplicación.
Atributo label: es el nombre de la aplicación.
Atributo theme: es el tema que estamos seleccionado para los estilos de nuestra aplicación.
Etiqueta Activity
La etiqueta Activity sirve para dar de alta todas las actividades que creamos en nuestra aplicación; recuerda que si
tenemos cinco actividades, debemos tener cinco etiquetas activity, pero cada una con sus parámetros.
Atributo name: este es el nombre de la clase Java que implementa el Activity.
Atributo label: este es el nombre de la Activity que el usuario va a ver.
Etiqueta Intent-filter
Esta etiqueta sirve para especificar qué es lo que tiene permitido hacer esta activity.
Etiqueta action
Esta etiqueta nos permite colocarle un nombre para más adelante, dentro del código, mandarla a llamar de ese
modo.
Etiqueta Category
Esta etiqueta siempre tiene dos opciones:
<category android:name="android.intent.category.LAUNCHER" />

MANUAL DE ANDROID 5
Usamos Launcher solo una vez dentro de todo el Manifest. Con esto le indicamos que es la actividad principal, la
que se va a lanzar cuando la aplicación se inicie, digamos que es nuestra Activity principal.
<category android:name="android.intent.category.DEFAULT" />

Todas las demás actividades llevan el “DEFAULT” ya que solo le indica que se ejecuta, como solo tenemos una
activity, tenemos un launcher. En caso de tener nueve activities, tendríamos ocho Default y un Launcher.
Con esto ya estudiamos nuestro Manifest en detalle. Esta es la estructura básica de nuestra aplicación, pero
tenemos muchas más opciones para agregar a nuestra aplicación, que vamos a ir conociendo conforme vayamos
avanzando.
Componentes en Android
Así sabremos qué es lo que nos va a ser de utilidad para cada aplicación que afrontemos.
Tendremos seis componentes que podemos utilizar:
Activity
Las actividades son las pantallas que vemos de un móvil, que está conformada por dos archivos, un archivo XML
(parte gráfica) y un archivo .Java (la parte lógica) de nuestra ventana.
Services
Los servicios son tareas que se realizan en segundo plano y no contienen una interfaz de vista para el usuario.
Content Provider
El Proveedor de contenido nos sirve para proporcionar datos a nuestra aplicación, esto nos ayuda a compartir datos
sin preocuparnos por el mecanismo de almacenamiento, lo que nos importa es la información que nos puede
proporcionar para una o varias tareas que necesitan los datos en la aplicación.
Intent
Los intents son objetos que sirven para mandar mensajes. Además, se puede pedir ejecutar una acción a otro
componente con el mismo intent. Dentro de los intents existen diferentes tipos dependiendo de lo que necesitemos.
Widget
Los widgets son “pequeñas” aplicaciones que reciben actualizaciones periódicas, por ejemplo en algunos móviles
tenemos widgets del clima en nuestro móvil, sin necesidad de entrar a la app tenemos la opción de colocar el
widget en una de nuestras ventanas principales en Android y lo mismo sucede con algunos reproductores de
música, etc. La idea es que el usuario pueda hacer cosas sin entrar directamente en la aplicación.
Processes and Threads

Cuando una aplicación se inicia, lo que sucede de manera muy técnica, es que se crea un proceso. Entonces todo
lo que se ejecuta dentro de esa aplicación es parte del mismo proceso de ejecución. Un hilo es otra forma de dividir
el trabajo, un proceso puede tener varios hilos de ejecución, el hilo lo podemos tomar como una secuencia de
control dentro de cualquier proceso y este ejecuta lo que indiquemos de manera independiente.
Estos son, a grandes rasgos, los componentes que podemos encontrarnos dentro de una aplicación Android.
Ciclo de vida de una actividad
Continuamos con el Manual de desarrollo para Android con un artículo que nos debe aclarar algunas de las bases
que debemos conocer perfectamente para dominar el desarrollo de Apps para este sistema operativo. No es otra
que el ciclo de vida de una activity.

MANUAL DE ANDROID 6
A diferencia de muchos sistemas o aplicaciones que se inician con un método "main()", que si vienes del mundo
Java o C++ me imagino que te sonará, aquí la secuencia es diferente y es como se muestra en la imagen:
Tratare de explicar la imagen: lo que está encerrado en óvalos son lo que llamaremos “estados” y para llegar a un
estado tenemos que pasar por un método o más, en la imagen se muestran los métodos y son los que tiene el
prefijo “on”. Entonces, por ejemplo:
Ejemplo 1: Para llegar al estado "Created" de una actividad, pasamos por el método "onCreate()".
Ejemplo 2: Para pasar al estado "Started" desde el estado "Stopped" pasamos por los métodos "onRestart()" y
"onStart()".
Espero que con esto quede claro cómo interpretar la imagen.
En Android se inicia con la invocación de métodos específicos que corresponden a etapas de vida. Tenemos una
secuencia de métodos que devuelven una llamada e inician la actividad, también tenemos una secuencia de
métodos que terminan la actividad.
Como ven en la imagen, tenemos una pirámide, esta primera inicia por la izquierda con el "onCreate()" y termina del
lado derecho con el "onDestroy"; vamos del principio al final.
Que quede claro que no siempre utilizamos los métodos del ciclo vida, depende de lo que vamos a necesitar y
cuándo lo vamos a necesitar, hay aplicaciones donde se aplican todos, ninguno o solo un par.
Tenemos los métodos:
onCreate()
onStart()
onResume()
onPause()
onStop()
onRestart()
onDestroy()
onCreate()

MANUAL DE ANDROID 7
Es el que debemos ejecutar en un inicio para definir, por ejemplo, la interfaz del usuario y también crear algunas
variables de ámbito de la clase. Este método por lógica solo se debería ejecutar solo una vez, al momento de
invocar la actividad. En este método casi siempre vamos a encontrar cómo se define un archivo XML, como la parte
gráfica de la actividad o la configuración de la interfaz.
Cuando el método "onCreate()" termina de ejecutarse llama al método "onStart()" y "onResume()", esto sucede de
manera muy rápida.
Técnicamente, la actividad se vuelve visible para nuestro usuario cuando llamamos en "onStart()", pero como sigue
muy rápido al "onResume()" y se mantiene en ese estado hasta que suceda otra cosa. Por ejemplo, cuando se
apaga la pantalla o cuando vamos a otra actividad, también en caso de recibir una llamada telefónica.
onStart()
Es donde la actividad se muestra ya al usuario como comentamos anteriormente.
onResume()
Es el estado en donde se encuentra en primer plano y el usuario interactúa con la actividad, podemos decir en
español que es el estado “corriendo” o “ejecutando”.
onPaused()
Es cuando esta se encuentra parcialmente oscurecida por una actividad que se encuentra en el primer plano, por
ejemplo está medio transparente o no cubre toda la pantalla, en este estado no se reciben datos de entrada del
usuario y no puede ejecutarse código.
onStop()
En este estado se encuentra completamente invisible u oculto para el usuario, podemos decir que se encuentra en
el “fondo”, en este estado podemos decir que todo se congela, por ejemplo las variables e información se mantiene
pero no podemos ejecutar el código.
onRestart()
Este método se llama después del "onStop()" cuando la actividad actual se está volviendo a mostrar al usuario, es
decir, cuando se regresa a la actividad. Después de este continua el "onStart()" y luego en "onResume()" y
finalmente ya está de nuevo mostrándose la actividad al usuario.
onDestroy()
Cuando el sistema destruye su actividad se manda a llamar al método "onDestroy()" para la actividad. Este método
es la última oportunidad que tenemos de limpiar los recursos y que si no eliminamos podrían no tener un buen
rendimiento para el usuario en caso de olvidarlo. Es buena práctica asegurarse de que los hilos que creamos son
destruidos y las acciones de larga duración también estén ya detenidas.
Con esto finalizamos este capítulo y toda la información que se plasma en este manual de Android sale de la
documentación oficial: developer.android.com
Implementar Un Botón En Android

Un botón es un control con texto o imagen que realiza una acción cuando el usuario lo presiona. La clase Java que
lo represente es Button y puedes referirte a él dentro de un layout con la etiqueta <Button> respectivamente.

MANUAL DE ANDROID 8
Para agregar un botón a la actividad principal de tu app dirígete a actividad_botones.xml y agrega la siguiente
definición.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.herprogramacion.botones.ActividadBotones">
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="AGREGAR" />
</RelativeLayout>
Con ello centramos el botón en el relative layout.
El texto que especifica su acción especificarlo en el atributo android:text. En el ejemplo anterior se usó la palabra
"AGREGAR".
Este código debería mostrar en la ventana Preview la siguiente imagen:

MANUAL DE ANDROID 9
Atributos de un Botón
Si quieres cambiar las propiedades de un botón recurre a los atributos que la documentación presenta en formato
Java o XML.
Debido a que Button extiende de TextView, puedes usar todos los atributos de esta clase.
Algunos de los más utilizados son:

Atributo Descripción
android:text Permite cambiar el texto de un botón
Se usa para cambiar el fondo del botón. Puedes usar un recurso del
android:background
archivo colors.xml o un drawable.
Determinar si el botón está habilitado ante los eventos del usuario.

android:enabled Usa true (valor por defecto) para habilitarlo y false en caso
contrario.
Asigna una posición al texto con respecto a los ejes x o y

dependiendo de la orientación deseada.
android:gravity
Por ejemplo: Si usas top, el texto se alineará hacia el borde
superior.
Representa al identificador del botón para diferenciar su existencia

android:id
de otros views.
Almacena la referencia de un método que se ejecutará al momento

android:onClick
de presionar el botón.
android:textColor Determina el color del texto en el botón
Determina un drawable que será dibujado en la orientación

establecida.
android:drawable*
Por ejemplo: Si usas el atributo android:drawableBottom, el
drawable será dibujado debajo del texto.
Teniendo en cuenta la anterior tabla te invito a ver los resultados que producen usar algunos de esos atributos.
Cambiar texto de un botón

Asigna una cadena directamente al atributo android:text para indicar la acción del botón.
<Button
android:text="Agregar" />
Por defecto el texto del botón estará en mayúsculas, pero si quieres deshabilitar esta característica usa el valor
false en el atributo android:textAllCaps.
<Button
...

MANUAL DE ANDROID 10
android:textAllCaps="false"/>
Ahora, si deseas cambiar el texto programáticamente usa el método setText().
Para ello abre ActividadBotones.java. Obtén la instancia del botón con findViewById() y luego invoca setText()
con una secuencia de caracteres como parámetro.
public class ActividadBotones extends AppCompatActivity {
@Override
setContentView(R.layout.actividad_botones);
Button boton = (Button) findViewById(R.id.button);

boton.setText("Ordenar");
}
}
Esto produce el siguiente resultado:
Cambiar texto de botón en Android programáticamente
Ahora también es posible asignar un recurso string al texto del botón desde XML y Java.
En caso de XML usa la notación de recurso @string o @android:string (strings del sistema) de la siguiente forma:
<Button
...
android:text="@string/texto_agregar"/>
En Java solo usa el operador punto para llegar al identificador perteneciente a la clase R:

boton.setText(R.string.texto_agregar);
Cambiar Color de Fondo

Modificar el fondo de un botón implica el cambio del atributo android:background por un recurso de color o
drawable.
Ejemplo:
Usar el color primario del proyecto como color de background de un botón
Solución:
Invoca la referencia @color/colorPrimary de tu archivo values/colors.xml:

<Button
...
android:background="@color/colorPrimary"/>
El resultado es:
Sin embargo, hacer esto hace perder la reacción de superficie que se tenía antes por el Material Design.
La forma redondeada tampoco se hace presente.
Solo queda la elevación al momento de tocar el botón.
Para conservar el efecto y cambiar el color del botón usa el atributo app:backgrountTint de la siguiente forma:

xmlns:app="http://schemas.android.com/apk/res-auto"
<Button
app:backgroundTint="@color/colorPrimary"
android:text="@string/texto_agregar" />
</RelativeLayout>
Así tendrías:

Botón con Texto e Imagen

En la sección de atributos viste que existen atributos con la forma android:drawable* para alinear una imagen al
texto de un botón.
Para demostrar su uso veamos el siguiente ejemplo sencillo.
Alinear a la izquierda del botón ordenar un icono asociado a pizzas.
Solución
Abre el layout actividad_botones.xml y agrega un botón centrado en el padre. Cambia el color de texto a blanco
(@android:color/white), usa un tinte de color rojo (#ef9a9a) y alinea a la izquierda el siguiente drawable de
pizza:
Tu código debería quedar de la siguiente forma:

xmlns:app="http://schemas.android.com/apk/res-auto"
<Button
android:drawableLeft="@drawable/ic_pizza"
android:drawablePadding="8dp"
android:id="@+id/boton"
android:textColor="@android:color/white"

app:backgroundTint="#ef9a9a"
android:text="Ordenar"
android:layout_centerHorizontal="true" />
</RelativeLayout>
Y el resultado sería:
Como ves, usé android:drawableLeft para ubicar la imagen en la izquierda. Si compruebas con las sugerencias de
Android tendrás varias posiciones: derecha, abajo y arriba.
La Clase ImageButton
ImageButton funciona exactamente cómo Button, solo que en lugar de traer un texto en su background, viene una
imagen para especificar la acción.
Para cambiar la imagen de un image button usa el atributo android:src. Obviamente su valor es un drawable.
El contorno del background se conserva como lo hemos visto hasta ahora, la diferencia está que en el centro se
ubicará la imagen elegida en src.
Si quieres que el background por defecto desaparezca, asigna un color transparente o cambia el contenido con un
list drawable (esto lo verás más adelante).
Ejemplo:
Cambiar la imagen de un image button con el icono de la app.

Solución
Lo primero es abrir el layout de la actividad y añadir un elemento <ImageButton> centrado en el relative layout.
El icono de la aplicación actual se encuentra en la referencia @mipmap/ic_launcher. Así que asigna este valor al
atributo andriod:src.
Adicionalmente puedes el color del sistema @android:color/transparent sobre android:background para eliminar el
contorno. Pero recuerda que esto elimina los efectos del Material Design.
<ImageButton
android:id="@+id/boton"
android:src="@mipmap/ic_launcher"
Ejecuta la app y verás la apariencia del botón final:
Crear Botón Desde Android Studio
Usa la pestaña Design que se ve en la vista de un layout para arrastrar y soltar un botón desde la paleta o cambiar
sus atributos.

1. Sitúate en la ventana Palette. Luego busca el elemento Button de la sección Widgets
2. Lleva el puntero del mouse hacia el layout y ubícalo según tu objetivo. En mi caso tengo un RelativeLayout, el
cual permite orientar mi botón en lugares asociados al contenido del padre y al de otros views.
Por el momento lo ubicaré en el centro absoluto del layout, donde el editor mostrará líneas de guía para saber que
valores estoy otorgando:

3. Una vez elegido el lugar donde se ubicará el botón, confirma con un click su inserción. Esto mostrará en la
ventana Properties todos los atributos del botón que puedes editar.
4. Si deseas, da doble click sobre el botón en el layout para desplegar una caja de edición rápida para el id y el
texto.
Tipos De Botones En Material Design
La documentación sobre botones en el Material Design nos habla de tres tipos:
● Raised Buttons
● Flat Buttons
● Floating Action Buttons (FAB)
Los raised buttons son los que hemos visto hasta ahora. Tienen backgrounds rectangulares, se elevan ante el click
del usuario y su superficie reacciona con un efecto ripple.

Se usan sobre layouts que tienen gran variedad de contenido para delimitar las secciones o elementos. Además
realzan la importancia de realizar una acción relacionada.
Por el contrario, un flat button o botón sin bordes tiene reacción de superficie pero no se eleva al ser presionado. Se
usan para acciones en diálogos, toolbars y de forma persistente en steppers.
El Floating action button tiene las mismas interacciones de elevación y ripple que el raised button, solo que este
tiene forma circular. Su objetivo es promover una acción principal relacionada a una pieza de material.
Manejar Los Eventos De Un Botón
Es de esperar que un botón dispara un evento al ser clickeado por un usuario, lo que permitirá ejecutar la acción a
la que hace referencia dicho view.
Para procesar el evento existen varias formas de proceder.
Usar el Atributo android:onClick

Anteriormente cuando viste la clase Button se mencionó la existencia de android:onClick() para asignar un
método que se ejecute cuando el usuario presione el botón.
Para ello se requiere que el método cumpla con las siguientes condiciones:
1. Que sea público

2. Que sea tipo void
3. Que reciba un parámetro del tipo View
4. Debe declararse en la actividad que usa el mismo layout
Ejemplo:
Cambiar el texto de un Text View por el mensaje “Botón presionado: [hora_actual]” al presionar un Button.
Solución:
Comienza por añadir un text view al layout. En mi caso lo ubicaré en el centro del relative layout y por debajo
pondré el botón:


<Button
android:text="@string/texto_agregar"
android:layout_below="@+id/textView"
<TextView
android:text="A la espera..."
android:id="@+id/textView"
</RelativeLayout>
Ahora en la actividad ActividadBotones crearé un método para los clicks llamado cambiarMensaje().
La idea es obtener el text view como campo para poder cambiar su texto con setText() desde el método.
Para obtener la hora usa la clase Calendar y para formatear su estructura usa SimpleDateFormat.
ActividadBotones.java
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class ActividadBotones extends AppCompatActivity {
private TextView texto;
@Override
texto = (TextView) findViewById(R.id.textView);

}
public void cambiarMensaje(View v){

SimpleDateFormat formato = new SimpleDateFormat("HH:mm:ss");

Date fechaActual = Calendar.getInstance().getTime();
String s = formato.format(fechaActual);
texto.setText(String.format("Botón presionado: %s", s));
}
}
Lo siguiente es dirigirse al layout y asignar el método en el botón con android:onClick. Al momento de hacerlo, el
motor de Android Studio debe sugerirte que cambiarMensaje() está disponible.
El atributo quedaría de la siguiente forma:
<Button
...
android:onClick="cambiarMensaje"/>
Al ejecutar la app y clickear el botón tendrás el cambio de texto por la hora actual.

Usar Escucha Anónima OnClickListener

Otra forma es crear una instancia anónima de la interfaz View.OnClickListener para manejar los eventos del botón.
Esto requiere usar el método setOnClickListener() para asignar el listener al botón y luego sobrescribir el
controlador onClick() con las acciones a ejecutar.
Ejemplo:
Iniciar otra actividad al presionar un botón
Solución
Lo primero es añadir otra actividad al proyecto actual que tienes abierto (recuerda quitar el text view que se tenía
antes y la referencia de android:onClick()).
Ve al menú de herramientas y presiona File > New > Activity > Empty Activity
Nombra a la nueva actividad como “ActividadNueva” y confirma.
Lo siguiente es ir ActividadBotones y obtener la instancia del botón que tenemos en onCreate().
Luego invoca el método setOnClickListener() desde la instancia y como parámetro digita solamente "new O". Esto
es suficiente para que Android Studio te recomiende la creación de un nuevo OnClickListener.
Al presionar ENTER o clickear la sugerencia, Android Studio creará la escucha anónima junto a la implementación
del controlador onClick():

boton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});

Ahora dentro del controlador crea un nuevo Intent para iniciar la actividad ActividaNueva. Seguido invoca
startActivity() para hacer efectivo el inicio.

boton.setOnClickListener(new View.OnClickListener() {
@Override
Intent i = new Intent(ActividadBotones.this, ActividadNueva.class);
startActivity(i);
}
});
Usar OnClickListener Sobre el Contenedor

OnClickListener también puede ser implementada sobre el contenedor del botón como lo es una actividad o un
fragmento.
Así podrás sobrescribir el controlador onClick() para que tenga un alcance global para todos los views que
pertenezcan al contenedor. Lo que es de utilidad si se deseas leer clicks sobre varios elementos al tiempo.
Ejemplo:
Cambiar el color del background de una actividad dependiendo de qué botón de 4 disponibles se presione.
Solución:
Pon 4 botones centrados horizontalmente y uno debajo de otro dentro del relative layout. Usa los siguientes colores
en sus textos: Verde azulado, Verde, Verde claro y Lima.
actividad_botones.xml

<Button
android:text="Verde azulado"
<Button
android:text="Verde"
android:id="@+id/button2"

android:layout_below="@+id/button"
<Button
android:text="Verde claro"
android:layout_below="@+id/button2"
<Button
android:text="Lima"
android:layout_below="@+id/button3"
</RelativeLayout>
Implementa la escucha OnClickListener sobre la ActividadBotones:
public class ActividadBotones extends AppCompatActivity implements View.OnClickListener {

@Override
}
}
Si dejas el código como está, Android Studio te informará que hay un error porque no has sobreescrito el
controlador.
La solución manual sería escribir la firma y cuerpo del método como es requerido. Sin embargo puedes usar la
generación de código automático de Android Studio.
Presiona ALT + insert dentro del cuerpo de la clase y selecciona Implement Methods…

Luego selecciona onClick() del menú y confirma.
Con ello construirás el cuerpo de forma automática:
@Override
}
Lo que sigue es detectar los eventos de click con múltiples botones.
Una de las formas más sencilla es usar una sentencia switch, donde su expresión de validez sea el identificador del
view que viene como parámetro de onClick().
El algoritmo sería el siguiente:
Asignar la escucha a todos los botones con el operador this.

Obtener el view raíz de la jerarquía con getRootView().

Abrir un switch con el id del view clickeado. El id se obtiene con el método getId().
Elegir el color dependiendo del caso. Convierte una definición hexadecimal en entero con Color.parseColor().
Cambiar el background del contenedor con el método setBackgroundColor()
Veamos:
import android.graphics.Color;
public class ActividadBotones extends AppCompatActivity implements View.OnClickListener {
@Override
findViewById(R.id.button).setOnClickListener(this);
findViewById(R.id.button2).setOnClickListener(this);
}
@Override
int color;
View contenedor = v.getRootView();
switch (v.getId()) {
case R.id.button:
color = Color.parseColor("#80CBC4"); // Verde azulado
break;
case R.id.button2:
color = Color.parseColor("#A5D6A7"); // Verde
break;
case R.id.button3:
color = Color.parseColor("#C5E1A5"); // Verde claro
break;
case R.id.button4:
color = Color.parseColor("#E6EE9C"); // Lima
break;
default:
color = Color.WHITE; // Blano
}
contenedor.setBackgroundColor(color);
}
}
Ejecuta la app y prueba clickear los 4 botones para cambiar el background de la actividad.

Eventos de click con múltiples botones en Android
Personalizar El Estilo De Un Botón
Ya viste algunos atributos que puedes cambiar en los botones para transformar su apariencia. Con eso puedes ir a
tu archivo styles.xml y crear estilos para estos views.
A continuación te mostraré algunos casos que pueden presentarse a la hora de querer personalizar un botón.
Cambiar Background
Si quieres omitir la forma por defecto del botón y los efectos de reacción, puedes probar usando un recurso
drawable del tipo State List.
Este elemento representa múltiples drawables que serán usados en un mismo view simulando cambio de estados.
Esto se ajusta perfectamente a los botones ya que su apariencia varía según la interacción.
Ejemplo:
Crear background de un botón con diseño plano (Flat Design)
Solución:
Lo primero que harás es crear un nuevo drawable llamado bk_boton_plano.xml.
Para ello ve a la carpeta drawable, presiona click derecho y selecciona Drawable resource file.

Confirma el nombre con OK:
La definición XML requiere que el nodo principal sea del tipo <selector>.
Dentro de este deben existir elementos <item> que definan el drawable que asignará a cada estado del botón.
Existen cuatro estados primordiales:
● normal
● enfocado (state_focused)
● presionado (state_pressed)
● deshabilitado (state_enabled > false).
Con lo anterior el código quedaría así:
bk_boton_plano.xml

<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/boton_presionado"
android:state_pressed="true" />
<item android:drawable="@drawable/boton_enfocado"
android:state_focused="true" />
<item android:drawable="@drawable/boton_deshabilitado"
android:state_enabled="false" />
<item android:drawable="@drawable/boton_normal" />
</selector>
Cada drawable de estado se compone de una lista de capas de drawables para simular un borde sombreado
inferior.

El estado normal tiene asignado el drawable boton_normal.xml el cual tiene dos en tono naranja profundo.
boton_normal.xml
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

<item android:top="4dp">
<shape>
<solid android:color="#FF7043" />
<corners android:radius="4dip" />
</shape>
</item>

<item android:bottom="4dp">
<shape>
<solid android:color="#FF8A65" />
</shape>
</item>
</layer-list>
El estado de foco simplemente cambia los colores de ambas capas para visualizar un cambio minimo de contraste.
boton_enfocado.xml

<shape>
<solid android:color="#FFCA28" />
</shape>
</item>

<shape>
<solid android:color="#FFD54F" />
</shape>
</item>
</layer-list>
Y el botón presionado es exactamente lo mismo. Un aumento de opacidad en el tono.
boton_presionado.xml


<shape>
<solid android:color="#FFA726" />
</shape>
</item>

<shape>
<solid android:color="#FFB74D" />
</shape>
</item>
</layer-list>
Con esos drawables listos, ahora puedes ir al layout de la actividad y modificar el atributo android:background para
asignar la lista. Cambia el color de texto con android:textColor a blanco para mejorar el contraste y si deseas
desaparecer la animación de elevación, usa android:stateListAnimator con el valor de @null.
<Button
android:textColor="@android:color/white"
android:background="@drawable/bk_boton_plano"
android:stateListAnimator="@null"
android:text="@string/texto_agregar" />
Estilo BorderLess o Botón sin Bordes

Ya habías visto que el botón sin bordes se le denomina Flat button en el Material Design.
Para crear dicho acabado puedes aplicar el estilo Widget.AppCompat.Button.Borderless.
Por ejemplo…
<Button
android:text="Llamar"
style="@style/Widget.AppCompat.Button.Borderless"
Produciría el siguiente resultado:
Botón con estilo BorderLess en Android

Si deseas que el color del texto sea el mismo del acento, entonces usa
Widget.AppCompat.Button.Borderless.Colored
Conclusión
Los botones son unos de los widgets más básicos en Android.
Tienen la función de ayudar al usuario a decidir por sus acciones sobre el contenido y datos de la app.
Saber describir su comportamiento con OnClickListener es vital para las interacciones. Recuerda que las acciones
se ubican en el controlador onClick().
O puedes usar el editor de diseño en Android Studio para asignar el método en el atributo android:onClick.
Usa el estilo correcto según lo hablado en la sección de Material Design. Es decir: Raised buttons para acciones
estables, Flat buttons para confirmaciones o acciones repetitivas y el Floating action button para promover acciones
principales sobre datos.
Trabajar con dos Activities

Al igual que siempre, abriremos nuestro IDE Android Studio y crearemos un nuevo proyecto, llamado “Activities” (o
el nombre que le queramos dar). Rellenaremos los datos de la siguiente manera:
● Name: Activities
● SDK API 19
● Empty Activity
El resto de parámetros los podemos dejar por defecto. Una vez termine de cargar el proyecto, lo primero que
vamos a hacer es lo básico, es decir, vamos a añadir un View en forma de texto, con lo que queramos, y un botón
que ponga “Acerca de” que, más adelante, nos mostrará los créditos de la aplicación. Para ello arrastraremos
ambos elementos desde la lista de Views a la actividad y modificaremos sus propiedades para que tome la
apariencia que nos guste.

Una vez tenemos esto hecho, vamos a crear un segundo Activity, el cual mostrará la información de “Acerca De”.
Crear un segundo Activity

Vamos a crear un segundo Activity. Para ello hacemos clic con el botón derecho en la lista de archivos del
proyecto, sobre “app” y seleccionamos New > Activity > Empty Activity
Automáticamente se nos va a crear una nueva actividad en nuestro proyecto, a la cual la podemos asignar el
nombre que queramos. Ahora ya podemos ver esta segunda actividad.
Lo único que nos queda por hacer es darle forma con los Views, por ejemplo:

Ahora solo nos queda hacer que al pulsar el botón de la primera actividad cargue la segunda donde nos aparezcan
los créditos.
Cómo lanzar el segundo Activity desde el primero, y viceversa

Con los Activities ya creados, lo único que nos queda es programar lo que queremos que hagan los Views. En este
caso, lo que tenemos que hacer es que al pulsar el botón cargue la otra View que tenemos asociada. Nada del otro
mundo.
Debemos escribir código en las dos actividades, en la MainActivity y en la AcercaDe.
Código de la MainActivity
public class MainActivity extends AppCompatActivity {
@Override
Button btn = (Button) findViewById(R.id.botonact1);

btn.setOnClickListener(new View.OnClickListener() {
@Override
Intent intent = new Intent (v.getContext(), AcercaDe.class);
startActivityForResult(intent, 0);
}
});
}
}
Código del AcercaDe
public class AcercaDe extends AppCompatActivity {

@Override
setContentView(R.layout.activity_acercade);
Button btn2 = (Button) findViewById(R.id.botonact2);

btn2.setOnClickListener(new View.OnClickListener() {
@Override


Intent intent2 = new Intent (v.getContext(), MainActivity.class);
startActivityForResult(intent2, 0);
}
});
}
}
El resultado final de la aplicación queda de la siguiente manera:
Cómo cambiar de actividad pasándole variables o parámetros

Es posible que en alguna ocasión nos encontremos con la necesidad de pasar variables, parámetros o información
de una actividad a otra. Esto se puede hacer de forma sencilla con dos funciones adicionales:
● putExtra()
● getExtras()
A continuación vamos a ver cómo pasar parámetros de la actividad 1, llamada por nosotros MainActivity a la
segunda actividad, llamada AcercaDe. Lo primero que vamos a hacer, aprovechando para practicar, es escribir un
cuadro de introducción de texto donde escribiremos lo que queramos y aparecerá, al cambiar, en la segunda
actividad.
Resumen:
● Creamos un TextField en Activity1
● Creamos un TextView en Activity 2

● Utilizamos putExtra() para sacar el contenido de TextField y getExtra para cargar dicho contenido en el
TextView.
Vamos a ver. Una vez introducidos tanto el TextField como el TextView, la apariencia de las actividades será similar
a la siguiente.
El código fuente de MainActivity será el siguiente:
package es.movilzona.activities;
import android.content.Intent;
import android.widget.Button;
import android.widget.EditText;
public class MainActivity extends AppCompatActivity {
@Override
//Cargamos el texto a exportar
final EditText textoexportar;

textoexportar=(EditText)findViewById(R.id.pasarTexto);
Button btn = (Button) findViewById(R.id.botonact1);

btn.setOnClickListener(new View.OnClickListener() {
@Override
Intent intent = new Intent (v.getContext(), AcercaDe.class);
//Exportar parametro
intent.putExtra("frase", textoexportar.getText().toString());
//
startActivityForResult(intent, 0);
}
});
}
}
El código de AcercaDe será el siguiente:
package es.movilzona.activities;
import android.content.Intent;
import android.widget.Button;
public class AcercaDe extends AppCompatActivity {
@Override
setContentView(R.layout.activity_acercade);
//Importamos texto de Act.1

Bundle bundle = getIntent().getExtras();
String fraseimportada=bundle.getString("frase");
String textoPasado = fraseimportada;

TextView out = (TextView)findViewById(R.id.textoPasado);
out.setText(textoPasado);

Button btn2 = (Button) findViewById(R.id.botonact2);

btn2.setOnClickListener(new View.OnClickListener() {
@Override
Intent intent2 = new Intent (v.getContext(), MainActivity.class);
startActivityForResult(intent2, 0);
}
});
}
}
A continuación os dejamos las capturas de la aplicación:

Android

Cargado por

Copyright:

Formatos disponibles

Android

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Android

Cargado por

Copyright:

Formatos disponibles

MANUAL DE ANDROID 1

Veamos una actividad básica:

public class MainActivity extends Activity {

Expliquemos por líneas:

Willy Felix Blas Cutipa

Del método "onCreate" lo más importante es la línea de código: SetContentView(R.Layout.acivity_main).

Estructura de una aplicación Android

Willy Felix Blas Cutipa

libs​- Se encuentran librerías externas que necesita el proyecto.

res​- El directorio "res" contiene todos los recursos de la aplicación.

<?xml version="1.0" encoding="utf-8"?>

<category android:name="android.intent.category.LAUNCHER" />

La primera línea solamente indica la versión y el formato del documento.

Willy Felix Blas Cutipa

Atributo ​icon​: es el icono de la aplicación.

Atributo ​label​: es el nombre de la aplicación.

Atributo name: este es el nombre de la clase Java que implementa el Activity.

Atributo label: este es el nombre de la Activity que el usuario va a ver.

<category android:name="android.intent.category.LAUNCHER" />

Willy Felix Blas Cutipa

<category android:name="android.intent.category.DEFAULT" />

Processes and Threads

Ciclo de vida de una actividad

Willy Felix Blas Cutipa

Espero que con esto quede claro cómo interpretar la imagen.

Tenemos los métodos:

Willy Felix Blas Cutipa

Implementar Un Botón En Android

Willy Felix Blas Cutipa

<?xml version="1.0" encoding="utf-8"?>

Con ello centramos el botón en el relative layout.

Este código debería mostrar en la ventana Preview la siguiente imagen:

Willy Felix Blas Cutipa

Algunos de los más utilizados son:

android:text Permite cambiar el texto de un botón

Determinar si el botón está habilitado ante los eventos del usuario.

Asigna una posición al texto con respecto a los ejes x o y

Representa al identificador del botón para diferenciar su existencia

Almacena la referencia de un método que se ejecutará al momento

android:textColor Determina el color del texto en el botón

Determina un drawable que será dibujado en la orientación

Cambiar texto de un botón

Willy Felix Blas Cutipa

Ahora, si deseas cambiar el texto programáticamente usa el método ​setText().

public class ActividadBotones extends AppCompatActivity {

Button boton = (Button) findViewById(R.id.button);

Esto produce el siguiente resultado:

Cambiar texto de botón en Android programáticamente

Button boton = (Button) findViewById(R.id.button);

Cambiar Color de Fondo

Usar el color primario del proyecto como color de background de un botón

Invoca la referencia ​@color/colorPrimary​ de tu archivo values/colors.xml:

Willy Felix Blas Cutipa

La forma redondeada tampoco se hace presente.

Solo queda la elevación al momento de tocar el botón.

<?xml version="1.0" encoding="utf-8"?>

Willy Felix Blas Cutipa

Botón con Texto e Imagen

Para demostrar su uso veamos el siguiente ejemplo sencillo.

libs- Se encuentran librerías externas que necesita el proyecto.

res- El directorio "res" contiene todos los recursos de la aplicación.

Atributo icon: es el icono de la aplicación.

Atributo label: es el nombre de la aplicación.

Ahora, si deseas cambiar el texto programáticamente usa el método setText().

Invoca la referencia @color/colorPrimary de tu archivo values/colors.xml:

1. Sitúate en la ventana Palette. Luego busca el elemento Button de la sección Widgets

La documentación sobre botones en el Material Design nos habla de tres tipos: