Ao de la Diversificacin Productiva y

del Fortalecimiento de la Educacin

FACULTAD DE INGENIERA,
ARQUITECTURA Y URBANISMO

Android Studio
CURSO:
COMPUTACIN MOVIL
ESCUELA:
INGENIERA DE SISTEMAS
INTEGRANTES:
CHUNGA ZULUETA JORGE LUIS
HUAMAN VILLANUEVA BRAYAN YERAK
ORTIZ MATUTE MEGAN ASHLEY
CICLO:
VII
DOCENTE:
MS. ING. OMAR ANTONIO SNCHEZ
GUEVARA

2015

INDICE
Introduccin.................................................................2
1.

Qu es Android Studio?..........................................................................3
1.1.

2.

Caractersticas.................................................................................. 3

Instalacin y configuracin de Android Studio en Windows.............................4

2.1.

Instalando Android Studio...................................................................4

2.2.1.
2.3.

Configurando el sistema (Windows)..................................................6

Java Home....................................................................................... 7

3.

Estructura del proyecto y archivo................................................................8

4.

Sistema Build Android............................................................................... 9

5.

Variables............................................................................................... 10
5.1.

Variables locales.............................................................................. 10

5.2.

Variable de instancia........................................................................10

5.3.

Variables estticas o de clase............................................................12

6.

Atajos bsicos....................................................................................... 13

7.

Configuracin de Layouts y Views............................................................14

7.1.

Layout............................................................................................ 14

7.1.1.

Tipos....................................................................................... 14

7.1.2.

Atributos.................................................................................. 14

7.1.3.

Programacin........................................................................... 15

Introduccin

El desarrollo de aplicaciones para Android se ha convertido en clave de cara al

futuro, debido a la cantidad de smartphones y tablets que hay con este sistema
operativo. Sin embargo, desarrollar aplicaciones para Android no es nada fcil
si no contamos con una base clara. Para ayudarnos, contamos con una
herramienta muy til, Android Studio. Android Studio es la IDE oficial para el
desarrollo de aplicaciones para Android, basado en IntelliJ IDEA .

IntelliJ IDEA es un Java entorno integrado de desarrollo (IDE) para el desarrollo

de programas informticos. Es desarrollado por JetBrains (anteriormente
conocidos como IntelliJ),

1.

Qu es Android Studio?

Android Studio es un entorno de desarrollo integrado (IDE), basado en IntelliJ IDEA de

la compaa JetBrains, que proporciona varias mejoras con respecto al plugin
ADT (Android Developer Tools) para Eclipse. Android Studio utiliza una licencia de
software libre Apache 2.0, est programado en Java y es multiplataforma.
Fue presentado por Google el 16 de mayo del 2013 en el congreso de desarrolladores
Google I/O, con el objetivo de crear un entorno dedicado en exclusiva a la
programacin de aplicaciones para dispositivos Android, proporcionando a Google un
mayor control sobre el proceso de produccin. Se trata pues de una alternativa real a
Eclipse, el IDE recomendado por Google hasta la fecha, pero que presentaba
problemas debido a su lentitud en el desarrollo de versiones que solucionaran las
carencias actuales (es indispensable recordar que Eclipse es una plataforma de
desarrollo, diseada para ser extendida a travs de plugins).
Android Studio liber la versin estable de Android Studio 1.0 el 8 de diciembre de
2014, Google ha pasado a recomendarlo como el IDE para desarrollar aplicaciones
para su sistema operativo, dejando el plugin ADT para Eclipse de estar en desarrollo
activo. Esta versin la puedes descargar desde la web de Android Developer.
Adems de las capacidades que usted espera de IntelliJ, Android Studio ofrece:
Sistema de construccin basado en Gradle Flexible
Construir variantes y mltiples apk generacin de archivos
Plantillas de cdigo para ayudar a construir las caractersticas de aplicaciones
comunes.
Editor de diseo Rich con soporte para la edicin de arrastrar y soltar tema.
pelusa herramientas para ponerse al rendimiento, facilidad de uso, la compatibilidad
de versiones, y otros problemas
Capacidades ProGuard y aplicacin de firma
El soporte integrado para Google Cloud Platform , por lo que es fcil de integrar
Google Cloud Mensajera y App Engine

1.1. Caractersticas

Principales caractersticas que incluye Android Studio:

Soporte para programar aplicaciones para Android Wear (sistema operativo
para dispositivos corporales como por ejemplo un reloj).
Herramientas Lint (detecta cdigo no compatible entre arquitecturas
diferentes o cdigo confuso que no es capaz de controlar el compilador)
para detectar problemas de rendimiento, usabilidad y compatibilidad de
versiones.

 Utiliza ProGuard para optimizar y reducir el cdigo del proyecto al exportar

a APK (muy til para dispositivos de gama baja con limitaciones de
memoria interna).
Integracin de la herramienta Gradle encargada de gestionar y automatizar
la construccin de proyectos, como pueden ser las tareas de testing,
compilacin o empaquetado.
Nuevo diseo del editor con soporte para la edicin de temas.
Nueva interfaz especfica para el desarrollo en Android.
Permite la importacin de proyectos realizados en el entorno Eclipse, que a
diferencia de Android Studio (Gradle) utiliza ANT.
Posibilita el control de versiones accediendo a un repositorio desde el que
poder descargar Mercurial, Git, Github o Subversion.
Alertas en tiempo real de errores sintcticos, compatibilidad o rendimiento
antes de compilar la aplicacin.
Vista previa en diferentes dispositivos y resoluciones.
Integracin con Google Cloud Platform, para el acceso a los
diferentes servicios que proporciona Google en la nube.
Editor de diseo que muestra una vista previa de los cambios realizados
directamente en el archivo xml.

2.
Instalacin y configuracin de Android Studio en
Windows

Android Studio se est convirtiendo en la herramienta favorita para crear aplicaciones

en Android.
Requerimientos de sistema Android Studio
Windows, Mac OS o Linux
2GB de RAM
1.5 GB de disco duro disponible

2.1. Instalando Android Studio

El tamao promedio de esta descarga es de
aproximadamente 450MB y contiene todas las
libreras necesarias para comenzar crear
aplicaciones Android.
Una vez descargado el instalador, tienes que
ejecutarlo y seguir las instrucciones en pantalla.

En algunos equipos luego de la instalacin, el sistema intentar abrir Android

Studio y posiblemente te muestre este error:

Este error es comn. Android Studio requiere que tengas instalado el JDK de
JAVA en su version 1.6 o superior, solo tienes que instalarlo y configurar tu
sistema para que Android Studio pueda manejarlo.

2.2. Instalar JAVA JDK

Las libreras del Java JDK (Java Development Kit) son indispensables para
ejecutar el emulador de Android y algunas herramientas de depuracin.
Toma en cuenta que no es suficiente con instalar el Java JRE (Java Runtime
Edition) que se usa comnmente para elementos de internet, es necesario
instalar el JDK completo para tener acceso a todas las herramientas de
desarrollo.

El instalador del JDK lo puedes encontrar en el sitio de descargas de

Oracle. Descarga la versin del JDK correspondiente a tu sistema e instlalo
en tu ordenador.
Si utilizas un equipo Windows, una vez que tengas instalado el JAVA JDK en
tu equipo debers configurarlo para que Android Studio pueda utilizar estas
nuevas libreras. Los usuarios de Mac OS no deben realizar ninguna
configuracin especial en el sistema.

2.2.1. Configurando el sistema (Windows)

Para que Android Studio tenga acceso a las libreras de JAVA es necesario
modificar las variables del entorno para definir su ruta en el sistema.
Para configurar las variables de entorno del sistema, comienza por abrir el
explorador de windows y buscar el icono Computer.

Selecciona la opcin propiedades en el men contextual, esto abrir la

ventana de propiedades del sistema.
Busca en el costado izquierdo la seccin de propiedades avanzadas del
sistema, al presionarlo debe aparecer una ventana de configuracin.

En el costado inferior derecho, encontrars un botn para definir las variables

del entorno, al presionarlo se mostrar el contenido que vamos a editar.
Las variables del entorno nos van a permitir que Android Studio tenga acceso
Java SDK. Para realizar esta tarea vamos a editar la seccin de Variables de
sistema, que es la lista que se encuentra en la parte inferior de la ventana.
En esta seccin necesitas instalar una variable
llamada JAVA_HOME

2.3.

Java Home

Busca en la lista de variables de sistema si existe

una variable llamada JAVA_HOME, si no existe,
presiona el botn new para crearla.
La nueva variable debe llamarse JAVA_HOME y
en el valor debes incluir la ruta al Java JDK que
instalaste en tu ordenador. Supongamos que
tienes instalada la versin 1.8.0 de Java JSDK, la
ruta que deberas usar sera similar a esta:

C:\Program Files\Java\jdk.1.8.0_05
Toma en cuenta que esta direccin puede
cambiar segn tu versin del JDK o ajustes
de la instalacin, no olvides verificar en tu
sistema que la direccin este correcta y
ajustar el valor a esa nueva direccin de ser
necesario.
Si es posible, reincida tu
equipo para asegurarte que
los
cambios
estn
disponibles en el sistema
operativo.

3. Estructura del proyecto y archivo

Android Studio nos ofrece un apartado dentro de su interfaz de trabajo donde
podemos tener vista muestra una versin aplanada de la estructura de nuestro
proyecto que proporciona acceso rpido a los archivos de cdigo fuente clave de los
proyectos de Android y le ayuda a trabajar con el sistema de construccin basado en
Gradle.

src: En este caso no contiene solo la lgica de la aplicacin, sino que lo contiene
todo.

main/java: Contienen la lgica, que en el ejemplo solo tenemos la clase

MainActivity

main/res: Que como en el caso de eclipse contiene tanto la interfaz grfica

como recursos, con la diferencia que esta dentro de la carpeta src.

Vamos a comentar un poco estas carpetas dentro de

recursos:
drawable-*: Aqu pondremos las imgenes que
usaremos para la aplicacin dependiendo de la
resolucin.
layout: Contiene la interfaz grfica de la que
hablbamos antes.
menu: Sirve para crear los distintos menus de la
aplicacin.
values: Aqu tendremos los estilos, traducciones,
colores
values-es: Igual que la anterior pero para idioma
espaol, es decir, si el dispositivo esta en espaol
coge los valores de esta carpeta. Se usa mucho para traducciones

4.

main/AndroidManifest: Aqui declaramos todo lo referente a la app. Permisos,

actividades, servicios, API mnimo para la que programamos

Sistema Build Android

El sistema de construccin de Android es el conjunto de herramientas que se utiliza

para construir, probar, ejecutar y empaquetar sus aplicaciones. Este sistema de
construccin reemplaza el sistema Ant utilizado con Eclipse ADT. Puede funcionar
como una herramienta integrada en el men Android Estudio e independientemente de
la lnea de comandos. Puede utilizar las caractersticas del sistema de construccin
de:
Personaliza, configurar y ampliar el proceso de construccin.
Crear varios archivos APK para su aplicacin con diferentes caractersticas utilizando
el mismo proyecto y los mdulos.
La reutilizacin de cdigo y recursos a travs de conjuntos de origen.
La flexibilidad del sistema de construccin Android le permite lograr todo esto sin
necesidad de modificar los archivos de origen del ncleo de su aplicacin. Para
construir un proyecto Android Studio, consulte Creacin y ejecucin de Android
Estudio. Para configurar los ajustes de generacin personalizada en un proyecto
Android de estudio, ver Configuracin Gradle construye.

5.

Variables

El alcance de una variable indica la parte del programa donde puede utilizarse. En
base al alcance, las variables se clasifican en:
5.1.
Variables locales
Se declaran dentro de mtodos o de instrucciones asociadas a bucles for,
estructuras condicionales, etc. Su alcance se restringe al cdigo del mtodo o
de la instruccin. No admiten modificadores de acceso salvo final y deben
estar inicializadas antes de ser empleadas.

5.2.
Variable de instancia
Se declaran despus de la clase y fuera de cualquier mtodo. Los valores que
asumen para cada objeto constituyen el estado o conjunto de atributos del
objeto.
Su alcance es global, es decir, las pueden utilizar directamente todos los
mtodos no estticos de la clase.
Para acceder desde el mtodo "main" o desde cualquier otro mtodo esttico
a una variable de instancia es necesario crear un objeto de la clase.
Al hecho de crear un objeto de una clase se le conoce tambin
como instanciar la clase. Si no se inicializan explcitamente, asumen el valor
nulo por defecto, una vez instanciada la clase.

Resultado:

Si las variables de instancia no se inicializan explcitamente bien mediante un

objeto de la clase bien en la misma lnea donde se declaran, qu ocurrir?
Se mostrar el elemento nulo asociado a los valores iniciales de los diversos
tipos de variables. As, en las variables primitivas enteras (byte, short, int y
long) dicho elemento nulo es 0, en las reales (float y double) es 0.0, en las

booleanas es false y en las referenciadas (asociadas a objetos de clases) es

null.
5.3.
Variables estticas o de clase
Son propias nicamente de la clase y no de los objetos que pueden crearse
de la misma, por lo tanto, sus valores son compartidos por todos los objetos
de la clase. Van precedidas del modificador "static".
Para invocar a una variable esttica no se necesita crear un objeto de la clase
en la que se define:
Si se invoca desde la clase en la que se encuentra definido,
basta con escribir su nombre.
Si se le invoca desde una clase distinta, debe anteponerse a su
nombre, el de la clase en la que se encuentra seguido del operador
punto (.) <NombreClase>.variableEstatica

public class SerHumanoBis{

String nombre;
String colorOjos;
String colorOjos;
int edad;
//Declaramos una variable esttica comn
//Para todos los objetos de la clase
static String planeta="Tierra"
String txt_resultado="";
void mostrarCaracteristicas(){
txt_pantalla+ String txt_resultado="";
void mostrarCaracteri void mostrarCaracteristicas(){
txt_pantalla+=nombre+ " tiene "+edad+" a"+(char)164+"os";
txt_pantalla+="Sus ojos son: "+colorOjos;
txt_pantalla+="Su planeta es la: "+planeta;
}
void eresMayorEdad{
id (edad>=18){
txt_pantalla+= nombre + " es mayor de edad";
txt_pantalla+=" Tiene &quo void eresMayorEdad{
id (edad>=18){
txt_pantalla+= nombre + " es mayor de edad";
txt_pantalla+=" Tiene "+edad+" a"+(char)164+"os";
}
else {
txt_pantalla+= nombre + " es menor de edad";
txt_pantalla+=" Tiene "+edad+" a"+(char)164+"os";
}
void escribe_mensaje() {
serHumanoBis shb1=new SerHumanoBis();
shb1.nombre="Jesus";
shb1.colorOjos="azules";
shb1.edad=28;
shb1.mostrarCaractersticas();
shb1.eresMayorEdad();
txt_pantalla+="---------------------"

serHumanoBis shb2=new SerHumanoBis();

shb2.nombre="Rebeca";
shb2.colorOjos="verdes";
shb2.edad=27;
shb2.mostrarCaractersticas();
shb2.eresMayorEdad();
txt_pantalla+="---------------------"
txt_pantalla+="FIN DEL PROGRAMA"
}

El resultado:
Jesus tiene 28 aos
Sus ojos son azules
Su planeta es la Tierra
Jesus es mayor de edad
Tiene 28 aos
--------------------Rebeca tiene 27 aos
Sus ojos son verdes
Su planeta es la Tierra
Rebeca es mayor de edad
Tiene 27 aos
--------------------FIN DEL PROGRAMA

6.

Atajos bsicos

En el Siguiente apartado explicamos algunos atajos producto de combinacin de

teclas, con la finalidad de que el usuario pueda ser ms productivo.
Descripcin
Moverse entre mtodos y clases
Duplicar lnea
Expandir/Comprimir seleccin
Abrir la estructura de llamadas
Encapsular/desplegar bloque
cdigo
Encapsular seleccin
Multicursor
Seleccin en columna
Separar/ eliminar
Archivos recientes
Mover lneas
Encontrar acciones

7.

de

Combinacin de Teclas
Windows
Mac
Ctrl + Arriba/Abajo
Alt + Arriba/Abajo
Ctrl + d
Ctrl + w
Ctrl + Alt + h
Ctrl + Shift + +/-

CMD + d
Alt + Arriba/Abajo
Ctrl + CMD + h
CMD + +/-

Ctrl + Alt + t
Alt + j
Shift + Alt + Insert
Ctrl + Shift + Delete
Ctrl + e
Alt + Shift +
Arriba/Abajo
Ctrl + Shift + a

CMD + Alt + t
Ctrl + g
CMD + Shift + 8
CMD + Shift + Delete
CMD + e
CMD + Shift +
Arriba/Abajo
CMD + Shift + a

Configuracin de Layouts y Views

Layouts y Views para el diseo de la interfaz de usuario (UI) de una aplicacin android.
7.1.
Layout
Es un objeto que representa el espacio contenedor de todas las vistas (Views)
dentro de la actividad. En l se define la estructura y el orden de los
elementos para que el usuario pueda interactuar con la interfaz. Lgicamente
se representan con subclases Java que heredan de la clase ViewGroup.
Para definirlos escribiremos un documento XML que contenga como nodo
raz algn tipo de layout y luego incluir en su interior los elementos
hijos. Android Studio permite generar automticamente el cdigo de los
archivos XML a travs del panel de Diseo.
7.1.1.

Tipos
Existen varios y su uso depende de la necesidad de cada persona.
Veamos la definicin de los ms populares y fciles de usar:
LinearLayout: El Linear Layout es el ms sencillo. Dentro
de l los elementos son
ubicados en forma linear a
travs de columnas o filas.
Posee un atributo que
permite
modificar
su
orientacin, ya sea para
presentar los elementos
horizontal o Verticalmente.

WebView:
Este
View fue creado para
mostrar el contenido con
formato web.

RelativeLayout: Este es el layout mas recomendado a

usar, ya que los componentes dentro de l se pueden organizar de
forma relativa entre s.
Frecuentemente usaremos el Relative Layout para nuestros proyectos debido
a la referencia relativa que podemos asignar a los componentes hijos. Views
Es un componente que permite controlar la interaccin del usuario con la
aplicacin. Estos son muy similares a los controles SWING de Java,
como Labels, Buttons, TextFields, Checkboxes,
etc.
Los
Views
son
organizados dentro de los Layouts para que el usuario comprenda los
objetivos de la actividad.

7.1.2.

Atributos
Veamos los propsitos de los atributos usados con mayor frecuencia al
disear un layout:
layout:height y layout:width: Estos atributos representan
el ancho y largo en dp de un View. No es recomendable asignarle
valores absolutos en dps, ya que el tamao de las pantallas vara de

un dispositivo a otro, as que lo que se ajusta a uno no puede ser el

tamao ms conveniente para otro. Para solucionar este
inconveniente existen dos banderas llamadas match_parent y
wrap_content.
match_parent ajusta la dimensin a las medidas del
contenedor padre y wrap content indica que la dimensin se ajustar
lo necesario para hacer visible el contenido del View.
layout:layout_margin: Especifica las mrgenes del view
con respecto a otros componentes. Podemos definir los valores
individualmente para la margen izquierda, derecha, superior e
inferior. O si deseas puedes especificar un mismo valor para todos
los margenes.
layout:alignComponent: Indica la adyacencia de las
margenes entre componentes. Por ejemplo, esto permitira ubicar el
margen izquierdo de un botn justo al lado del margen izquierdo de
otro botn. Si en algn momento el botn cambia entonces su
compaero cambiar con l. Este atributo muestra el poder de
un Relative layout.
layout:alignParent: Con este atributo especificamos que
un view estar ubicado hacia uno de los lados de su padre.
layout : centerInParent: Permite centrar horizontal y
verticalmente un View con respecto a su padre.
id: Es un nombre que diferencia los views entre si. Es de
utilidad cuando vayamos a referenciar los controles en el cdigo
Java. As que elige nombres representativos y de fcil interpretacin.

7.1.3. Programacin
Crearemos una pequea aplicacin con un Relative Layout y los
siguientes tres views: un EditText, un TextView, y un Button. El objetivo
general es que el usuario digite algn texto en la caja de texto y al
presionar el botn la aplicacin muestre la cantidad de caracteres tiene.
Veamos los pasos a seguir:
Paso 1: Crear un nuevo proyecto
Crea un nuevo proyecto o reutiliza el proyecto Test que habamos creado en
los artculos iniciales.
Paso 2: Abrir el archivo Layout

Abre el archivo de recursos que guarde el layout de tu actividad principal. En mi caso

es activity_my.

Paso 3: Arrastrar y Soltar Views

Presiona la pestaa Design en la parte inferior del editor:

La herramienta que se acaba de visualizar es el panel de diseo de interfaz de Android

Studio.

En la parte central se encuentra un lienzo que muestra la interfaz actual en un

dispositivo.
En su parte superior tenemos una barra que permite configurar el dispositivo
elegido para la pre visualizacin, herramientas de zoom, la versin de Android a
visualizar, el modo tctil (Landscape o Portrait), etc.
A la izquierda veremos la paleta o estante de views para construir la actividad.
Al lado derecho se encuentra el Component Tree o rbol de componentes, en esta
ventana se representa en forma jerrquica la relacin de nuestros views.
Debajo del Component Tree esta el panel de propiedades. En el veremos todos los
atributos que tiene un view seleccionado, los cuales podemos editar con facilidad.

A continuacin arrastraremos al layout el siguiente un Multiline Text de la seccin Text

Fields. Ubcalo en la parte superior y centrado horizontalmente, de tal forma que te
aparezcan los tooltips que se muestran en la ilustracin derecha.

EditText
El view que acabamos de agregar pertenece a la familia de los TextFields.
Un TextField es un control que espera la entrada de texto del usuario, como por
ejemplo su nombre, telfono y datos que sean tiles para la aplicacin.
El que acabamos de agregar es de tipo MultiLine, lo que significa que puede recibir
varios renglones de carcteres en su contenido. Tambin hay otros tipos que solo
reciben nmeros, o texto referente a un correo electrnico, etc.
A pesar de que en diseador se llame TextField en Java es representado por la
subclase EditText y en XML con el elemento <EditText>.

Button
Como su nombre lo indican se refiere a un botn. Como usuarios hemos visto y
clickeado millones de veces a estos amigos. Su propsito es ejecutar una accin que
permita al usuario completar un proceso, confirmar una accin, ejecutar ms
caractersticas de la aplicacin, etc.
En Java lo representaremos con la subclase Button y su equivalente en XML es el
elemento <Button>.
Ahora pasaremos a agregar un botn. Utiliza las mismas caractersticas de ubicacin
mostradas en la ilustracin de la parte derecha.
Medium Text
Es un texto esttico de tamao promedio en la interfaz de usuario. Su propsito es
informar o guiar el recorrido en la aplicacin . Como ves, adicionalmente hay mas texts

en
el
panel: Small(Pequeo), Large(Gigante)
y Plain Text(Texto plano). Si necesitas
una
referencia
adicional,
podras
comparar
el Medium
Text con
un Label de SWING.
El medium Text se representa con la
subclase de Java TextView, lo de
medium simplemente fue posible
editando un atributo que define el tamao
de la fuente. Su equivalente XML es el
componente
<TextView>.
Si todo sali bien el diseo final te habr
quedado similar a este:

Paso 4: Configurar atributos de los Views

Lo que sigue es asignar los IDs, las dimensiones y las posiciones de nuestros tres
componentes en el layout. Para ello selecciona primero el textview en el Component
Tree. Luego dirigete a sus propiedades, busca el atributo id y emplea un nombre
significativo para nuestro componente. En mi caso yo le he asignado main_textview.

Luego haremos lo mismo para los dems views y veremos como cambian sus
nombres en el Component Tree.

Nuestro editText fue configurado inicialmente para que su limite superior estuviera
alineado al lmite superior del Relative Layout. Por eso si vemos sus propiedades
podremos ver el atributo layout:alignParent seleccionado en la opcin top.

Al seleccionar el botn veremos que est ubicado en la parte inferior del editText, con
una margen superior de 41dpy alineado horizontalmente. Estas caractersticas se
representan con los atributos layout:margin , layout:alignComponent y
layout:centerInParent.

Nota que align_component se visualiza como un conjunto de opciones donde

podemos especificar las adyacencias entre componentes. Si te fijas, el botn tiene
alineado a su limite superior el limite inferior del editText(top:bottom).

El textView tiene una alineacin central vertical tanto como horizontal. Si te fijas el
valor de centerInParent es both que significa que se centrar en las dos dimensiones.

Ahora intenta asignarle a su limite superior el limite inferior del botn y adems
adele un margen superior de 41dp.

Seguido modificaremos un atributo especial llamado hint del editText. Hint indica a
travs de un texto informativo, el tipo de texto que el edittext puede recibir. En mi caso
le voy a poner Mensaje.

Lo siguiente es modificar los atributos text del textView y el botn, asignando una
cadena vacia al primero y la cadena Procesar al segundo:

Todo lo que hemos realizado hasta el momento pudo haberse especificado a travs
de la pestaa Text del Editor.Esta pestaa muestra la descripcin XML sobre lo que
acabamos de construir en la pestaa de Diseo.
Si vas a la pestaa Text tendras algo similar a esto:

<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:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MyActivity">

<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:inputType="textMultiLine"
android:ems="10"
android:id="@+id/main_editText"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:hint="Mensaje" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/main_button"
android:layout_below="@+id/main_editText"
android:layout_centerHorizontal="true"
android:layout_marginTop="41dp"
android:text="Procesar" />

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceMedium"
android:id="@+id/main_textview"

android:layout_centerVertical="true"
android:layout_centerHorizontal="true"
android:layout_below="@+id/main_button"
android:layout_marginTop="41dp" />
</RelativeLayout>

Este archivo muestra los componentes de cada View y los atributos que le hemos
asignado(tambin hay otros atributos configurados intrnsecamente por Android
Studio).

Paso 5: Aadir las cadenas relevantes al archivo strings.xml

Qu cadenas son estticas y no se modificarn a lo largo de la ejecucin de la
aplicacin?
A mi parecer el texto del botn sera muy importante al igual que el Hint del edittext.
El texto del textview est destinado a ser dinmico as que lo descartara.
Una vez definido esto, vamos a agregar estas cadenas al archivo strings.xml. Para ello
vamos al panel de propiedades y buscamos el atributo text del botn y hint del edittext.
Presionaremos el botn .

La ventana que se acaba de desplegar permite que elijamos y naveguemos a travs

de todos los recursos del proyecto en la pestaa Project. Existe otra pestaa
llamada System, pero sus utilidades las veremos luego.

Ya que el recurso que necesitamos usar an no existe, debemos crearlo. As que

haremos clic en New Resource y seleccionaremos New String Value.
A continuacin nos aparecer un formulario con dos campos que describen al
string, Resource name y Resource content. El primero hace referencia al nombre del
recurso, el segundo al contenido del string. En mi caso como nombre le asignar
main_button al texto del botn. Y para el hint del edittext usar main_hint.
En los contenidos ubica el texto que tenamos al inicio.

Guardamos y el recurso estar creado. Si deseas abre el archivo strings.xml y

comprueba la existencia de los nodos que acabas de crear.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">Test</string>
<string name="action_settings">Settings</string>
<string name="hint">Mensaje</string>

<string name="button">Procesar</string>
</resources>
Naturalmente otra forma de aadir los nodos a strings.xml es de forma manual si en
algn momento deseas hacerlo.
Paso 6: Programar los eventos
Ya hemos acabo con toda la parte de diseo e interfaz. Lo que sigue es programar lo
que queremos que la aplicacin realice si el botn es presionado. El algoritmo sera
algo como:
Botn presionado?:
SI
-Obtener valor del editText
-Poner valor del editText en el textView

Cmo saber si un botn fue presionado?

Simplemente usaremos una Interfaz que escuche los taps del usuario en un view.
Recuerda que los listeners o escuchas en espaol, son Interfaces implementadas
en Java para participar en la recepciones de eventos. Bueno supongo que eso ya lo
sabes.
Para los botones usaremos una escucha especial llamada OnClickListener. Solo basta
aadir una relacin entre nuestro botn y la escucha para reportar el evento.
Pero Cmo accedemos al botn?
Debes crear un objeto del tipo Button para guardar la instancia del botn.
private Button boton;
Ahora dentro del mtodo callback onCreate() llamaremos al mtodo de la
clase Activity findViewById(). Este mtodo retorna en los views que se encuentran en
el layout a travs de una referencia.
Como
devuelve
un
objeto
el casting pertinente.Veamos:

de

tipo

View, es

necesario

realizar

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

La referencia del botn se obtiene a travs del atributo id de la clase R.

Con ese proceso claro pasamos a codificar de forma anloga con los otros dos Views:
boton = (Button)findViewById(R.id.main_button);
edit = (EditText)findViewById(R.id.main_editText);
text = (TextView)findViewById(R.id.main_textview);

Lo que sigue es anidar una nueva instancia de la escucha al botn con el mtodo de la
clase Button setOnClickListener():
boton.setOnClickListener( new OnClickListener() {
public void onClick(View view){
//Acciones
}
});

OnClickListener permite sobreescribir su mtodo de escucha de taps onClick(). Dentro

de l agregaremos las acciones que se ejecutarn al presionar el botn. El parmetro
de entrada view es el view que fue presionado, el cual no es utilizado en este ejemplo.
Que contendr el listener?
Las acciones que establecimos en nuestro algoritmo: Obtener el valor del edit text y el
setearlo en el viewtext.
Veamos:
String mensaje = edit.getText().toString();
text.setText(String.valueOf(mensaje.length()));
Lo que acabamos de hacer es una fcil transferencia del mensaje desde el editText
hasta el textView. Para ello usamos los mtodos getters y setters del atributo text que
ambos poseen. El mtodo getText() de EditText no retorna en la cadena como tal del
componentes, si no en un objeto del tipo Editable, por ello luego casteamos a String
con toString().
Este sera el cdigo completo:
public class MyActivity extends Activity {
private Button boton;
private EditText edit;
private TextView text;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_my);
boton = (Button)findViewById(R.id.main_button);
edit = (EditText)findViewById(R.id.main_editText);
text = (TextView)findViewById(R.id.main_textview);
boton.setOnClickListener( new OnClickListener() {
public void onClick(View view){
String mensaje = edit.getText().toString();
text.setText(String.valueOf(mensaje.length()));
}
});
}

}
Finalmente ejecuta el proyecto y obtendrs el siguiente resultado: