Categoría: CURSO ANDROID

El EditText tiene la capacidad de interactuar con el usuario mostrando y recogiendo la información capturada en él, y propiedades que nos son de utilidad en dicho proceso de captura de información, por ejemplo captura de texto, captura de números, captura de contraseñas, entre otros.

A continuación veremos cómo modificar estas propiedades para poder utilizarlas en nuestra Aplicación según nuestras necesidades.

android:id="@+id/TxtHint"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Hint animado"
android:layout_gravity="center_horizontal"
android:Text="Texto"

Id
Es el nombre con el que identifica a cada elemento, debe ser único.

Width
Es el ancho que toma el control, generalmente se toma el valor “match_parent” para que se muestre a lo ancho de la pantalla

Height
Es el alto del control que generalmente se toma el valor “wrap_content” que es el alto del contenido del mismo control

Gravity
Es la alineación que tomará el control respecto a su elemento padre, center, right, left…

Text
Es un texto que se mostrará en nuestro control de forma inicial

Hint
Esta propiedad es de mucha utilidad debido a que el espacio de las interfaces en dispositivos es muy limitada como para poner una etiqueta de texto fuera del EditText ya que consumiría demasiado espacio valioso, lo que hace es poner un texto de descripción del EditTex de la misma manera que lo hace el placeholder en otros lenguajes de etiquetado. Pero hay dos estilos de ponerlo.

La primera en la que desaparece cuando escribimos algún texto en el EditText y que nos deja después con la duda de qué dato estaba capturando y para verlo hay que borrar todo el texto para que aparezca de nuevo. Sólo con colocar la siguiente propiedad en el EditText.

android:hint="Hint normal"

La segunda en la que el hint se desplaza hacia arriba con un tamaño mas pequeño indicándonos en todo momento de qué se trata el dato capturado.

En ésta forma es necesario tener la propiedad hint en el EditText pero todo nuestro EditText lo tenemos que poner dentro de un TextInputLayout.

Para poder utilizarlo necesitamos el android support design en nuestro archivo gradle nivel app

compile 'com.android.support:design:22.2.1'

<android.support.design.widget.TextInputLayout
     android:layout_width="match_parent"
     android:layout_height="wrap_content">

<EditText
     android:id="@+id/TxtHint"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:hint="Hint animado"
     android:paddingBottom="35dp"
     />
</android.support.design.widget.TextInputLayout>

 

---

Cómo colocar botones, configuraciones, titulo y botón atrás en el ActionBar?

El ActionBar en Android es la barra que se encuentra en la parte superior de la pantalla o de cada Activity, en el que podemos encontrar el título del Activity, Botón hacia atrás y el menú con las opciones que queramos.

El Activity cuando lo agregamos ya tiene por defecto el ActionBar y ésta sólo contiene el título que se le pone cuando creamos el Activity. A continuación vemos cómo agregar estos controles que son de mucha utilidad.

Primero veremos como cambiar el titulo del Activity, se puede hacer de dos formas, desde el archivo AndroidManifest donde se encuentra información de todos los Activitys de nuestra Aplicación y en tiempo de ejecución desde código.

Desde AndroidManifest

<activity android:name=".TextViewActivity" android:label="TextView"/>

Desde código, en tiempo de ejecución.

setTitle("Calendar");

Ahora pondremos el botón hacia atrás desde el código.

//en el evento OnCreate para mostrar el botón atras
 getSupportActionBar().setDisplayHomeAsUpEnabled(true);

//Para controlar la acción que realizará el botón
@Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case android.R.id.home:
                Intent i = new Intent(CalendarActivity.this,Principal.class);
                startActivity(i);
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }

Lo que sigue es poner el menú en el que podemos elegir cuál de las opciones dejamos visibles con un icono representativo y cuales funciones dejamos en la lista de configuraciones a las que podemos acceder desde el icono de los tres puntos que representan el menú de configuraciones.

Primero debemos confirmar si tenemos en nuestro proyecto la carpeta con el nombre menu, si no la tenemos la podemos crear, esto dentro del directorio “res” y dentro un archivo de tipo “menu resourse file”, cabe decir que el contenido que pongamos dentro será visto en el Activity donde lo mandamos llamar, así que si necesitamos opciones de menú diferentes en cada Activity debemos crear un menú para usarlo en cada Activity.

Los items los agregamos en el archivo que acabamos de crear, en éste caso el archivo botones.xml que usaré en el Activity ButtonActivity

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item android:id="@+id/MenuAgregar" android:icon="@android:drawable/ic_menu_add" app:showAsAction="always"   android:title="Agregar"/>
    <item android:id="@+id/MenuRegresar" android:icon="@android:drawable/ic_menu_revert" app:showAsAction="always|withText" android:title="Regresar"/>
    <item  android:id="@+id/MenuEnviar" android:icon="@android:drawable/ic_dialog_info" app:showAsAction="never" android:title="Enviar"></item>
    <item android:id="@+id/MenuGuardar"  app:showAsAction="never" android:title="Guardar"/>

</menu>

Vemos que la propiedad app:showAction presenta diferentes valores que explicaré a continuación:

“always” significa que se debe mostrar siempre, es decir, en el ActionBar.

“always|withText” nos muestra el icono pero cuando hay espacio muestra el texto del title como se muestra en la imagen de arriba con el botón Regresar.

“never” significa que no se muestre ésta opción nunca quedando oculta en el menú de los tres puntos.

---

Un layout es el diseño de nuestra vista o pantalla en la que pondremos todos nuestros controles que tendrán interacción con el usuario como EditText,Botones, etc. Este control se genera y ordena con en un archivo XML teniendo diferentes tipos de Layout para diferentes necesidades.

3.1.1 Tipos de Layout

Existen diferentes tipos de Layout para ordenar el contenido de diferentes formas en pantalla.

LinearLayout
El LinearLayout apila todos los elementos hijo que tiene uno detrás de otro y puede ser en vertical (uno debajo de otro)

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.mejorprogramacion.layouts.LinearVertical">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="mejorprogramacion.com" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="TextView" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10"
        android:inputType="textPersonName"
        android:text="Name" />

    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button" />

</LinearLayout>

o puede ser horizontal (uno al lado de otro).

Poniendo la orientación en vertical u horizontal.

android:orientation="horizontal"

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.mejorprogramacion.layouts.LinearHorizontal"
    android:orientation="horizontal">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="mejorprogramacion.com" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="TextView" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="5"
        android:inputType="textPersonName"
        android:text="Name" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Button" />

</LinearLayout>

RelativeLayout
Este Layout posiciona los controles o elementos hijos de forma relativa entre unos y otros, por ejemplo: debajo de, o ala izquierda de.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.mejorprogramacion.layouts.Relative">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="mejorprogramacion.com"
        android:id="@+id/textView" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/textView"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="62dp"
        android:ems="5"
        android:inputType="textPersonName"
        android:text="Name" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/editText"
        android:layout_marginTop="97dp"
        android:layout_toEndOf="@+id/editText"
        android:layout_toRightOf="@+id/editText"
        android:text="Button" />

</RelativeLayout>

TableLayout
Es una tabla definida (Filas y Columnas) en las que podemos poner los elementos, es muy parecido a una tabla en HTML.

Dentro de la etiqueta de éste Layout para cada fila o row debemos poner la etiqueta TableRow para cada fila.

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.mejorprogramacion.layouts.Table">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="mejorprogramacion.com" />

    <TableRow>
        <TextView
            android:id="@+id/textView"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="TextView" />
        <EditText
            android:id="@+id/editText"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:ems="5"
            android:inputType="textPersonName"
            android:text="Name" />
    </TableRow>

    <TableRow>
        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Button" />
    </TableRow>

</TableLayout>

AbsoluteLayout
Posiciona los elementos de manera absoluta en pantalla según la posición indicada, seguramente es el Layout menos usado ya que dada la gran variedad en los tamaños de pantalla de los dispositivos móviles puede tener problemas en el total de área que se pueda mostrar en la pantalla, es decir, algunos elementos podrían no mostrarse por estar posicionados en un área que está por fuera de la pantalla.

Cuando seleccionamos éste Layout en Android Studio nos damos cuenta de que la etiqueta la pone tachada y esto significa que está obsoleta, si podemos utilizarla pero debemos evitar su uso por las razones que vimos anteriormente.

<?xml version="1.0" encoding="utf-8"?>
<AbsoluteLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.mejorprogramacion.layouts.Absolute">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_x="93dp"
        android:layout_y="0dp"
        android:gravity="center"
        android:text="mejorprogramacion.com" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_x="63dp"
        android:layout_y="63dp"
        android:text="TextView" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_x="194dp"
        android:layout_y="43dp"
        android:ems="5"
        android:inputType="textPersonName"
        android:text="Name" />

    <Button
        android:id="@+id/button"
        android:layout_width="169dp"
        android:layout_height="wrap_content"
        android:layout_x="82dp"
        android:layout_y="151dp"
        android:text="Button" />

</AbsoluteLayout>

FrameLayout
Coloca los elementos hijos uno detrás del otro alineados por la esquina superior izquierda.

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.mejorprogramacion.layouts.Frame">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="mejorprogramacion.com" />

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:srcCompat="@mipmap/ic_launcher" />

    <Button
        android:id="@+id/button"
        android:layout_width="109dp"
        android:layout_height="58dp"
        android:text="Button" />

</FrameLayout>

ConstraintLayout
La ventaja que ofrece este Layout a la hora de diseñarlo es que puedes poner una relación de cada elemento con otros elementos o con el mismo Layout haciéndolo totalmente responsive, teniendo la seguridad de que el control o elemento se mantendrá en su posición relativa dentro de la pantalla sea cual sea su tamaño.

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.mejorprogramacion.layouts.Constraint">

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="mejorprogramacion.com" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="299dp"
        android:layout_height="33dp"
        android:layout_marginEnd="40dp"
        android:layout_marginStart="8dp"
        android:text="TextView"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        tools:layout_editor_absoluteY="41dp" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="148dp"
        android:layout_height="52dp"
        android:layout_marginBottom="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="20dp"
        android:ems="5"
        android:inputType="textPersonName"
        android:text="Name"
        app:layout_constraintBottom_toTopOf="@+id/button"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.881"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textView"
        app:layout_constraintVertical_bias="0.464" />

    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="8dp"
        android:layout_marginTop="168dp"
        android:text="Button"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textView"
        tools:layout_editor_absoluteX="0dp" />

</android.support.constraint.ConstraintLayout>

---

Pasar información de un Activity a otro es muy sencillo y se hace justo cuando vamos a cambiar de uno a otro.

Existen dos formas de hacerlo.

La primera forma (Forma1), la más sencilla, solamente envía las variables y su valor cuando se cambia de un Activity a otro.

Tenemos que insertar el nombre de la variable y el valor que queremos enviar, el nombre de la variable sirve solamente para poder recuperarla en el Activity destino, no cumple otra función (puede ser del mismo nombre que la variable usada en el Activity para no confundirnos).

//Forma 1
Intent i = new Intent(PrincipalActivity.this, SegundoActivity.class);
i.putExtra("Mensaje", Mensaje);
startActivity(i);

Ahora veremos cómo recuperar las variables, para eso es necesario tener una variable con el tipo de dato que necesitemos (String, int, float…) que es donde guardaremos el valor que estamos trasladando.

Mensaje = getIntent().getExtras().getString("Mensaje");
TxtEtiqueta.setText(Mensaje);

La segunda forma (Forma2), un poco más complicada que la anterior, guarda en la memoria del dispositivo las variables y sus valores de la misma forma que las configuraciones de la Aplicación, de manera persistente por medio del objeto SharedPreferences, esto nos ayuda cuando tenemos una variable con un valor al que queremos acceder en cualquier momento en cualquier Activity, sin la necesidad de estar enviando el valor cada vez que cambiemos de Activity.

Con el objeto SharedPreferences creamos un apartado en memoria donde se van a guardar las variables.y de la misma manera que la forma anterior agregamos las variables y sus respectivos valores, cabe aclarar que esto lo podemos hacer en cualquier momento, no es necesario hacerlo justo antes de cambiar de Activity.

//Forma 2
SharedPreferences preferencias = getSharedPreferences("variables", Context.MODE_PRIVATE);
SharedPreferences.Editor editor = preferencias.edit();
editor.putString("Mensaje", Mensaje);
editor.commit();

Intent i = new Intent(PrincipalActivity.this, TercerActivity.class);
startActivity(i);

Para recuperar el objeto SharedPreferences se hace de la siguiente manera.

SharedPreferences preferencias=getSharedPreferences("variables", Context.MODE_PRIVATE);
Mensaje = preferencias.getString("Mensaje","");
SharedPreferences.Editor editor=preferencias.edit();
editor.remove("Mensaje");
editor.commit();
TxtEtiqueta.setText(Mensaje);

Algo que debemos tener en cuenta es que como las variables son persistentes, cada que estemos seguros de no necesitarla más, debemos eliminarla del objeto SharedPreferences.

editor.remove("Mensaje");

Esta forma de guardar variables es útil si cuando estamos usando nuestra Aplicación y cambiamos a otra, al momento de regresar en el evento OnResume() podemos cargar las variables nuevamente y evitar que haya fugas de información.

---

Un Activity tiene un ciclo de vida dentro de nuestra Aplicación que va desde que lo llamamos o creamos hasta que lo dejamos de utilizar, es importante conocerlo para saber cómo es que se comporta cuando se realizan ciertas actividades en función del Sistema Operativo pero también del propio dispositivo, es decir, el SO es quién decide cuando cambia de estado en el ciclo de vida del Activity pero como mencioné cuando se manipula y se gira el dispositivo el estado de nuestro Activity también se ve afectado.

El siguiente diagrama muestra los estados y transiciones de un Activity en su ejecución.

Ahora veremos qué significa o a qué se refieren los estados del ciclo de vida del Activity.

Al Iniciar o lanzar el Activity

onCreate()
Como su nombre lo dice es cuando se crea el Activity por primera vez y donde se deben crear vistas, botones, enlace de datos, etc., todas las configuraciones estáticas que se van a utilizar.

onStart()
Viene después de crear el Activity y es el método que la inicia y se vuelva visible para el usuario.

onResume()
Éste método se ejecuta justo antes de que el usuario interactúe con el Activity ya que es el que lo pone en la parte superior de la pila de actividades.

Mientras el Activity se está ejecutando

onPause()
Este método se usa para confirmar los cambios sin guardar, detener animaciones y otros procesos que podrían estar consumiendo CPU. Es llamado por el Sistema Operativo cuando el usuario está a punto de llamar a otro Activity o ponerlo en segundo plano.

onStop()
Cuando el Activity ya no es visible para el usuario ya sea porque se abrió uno nuevo o se reanudó otro que estaba abierto y se puso por delante de este.

onRestart()
Cuando el Activity se pone onStop() pero se quiere interactuar nuevamente con él es cuando se llama a éste método siguiendo el método onStart().

onDestroy()
De la misma manera que onRestart(), cuando el Activity se pone en onStop(), pero ahora el Activity ya no es requerido y se va a cerrar por completo se llama a éste método para destruir el Activity.

---

Para elegir el Activity correcto primero necesitamos saber qué tipo de contenido va a mostrar (mapas, popup, etc.), Android Studio nos ofrece una serie de plantillas de Activitys para elegir cuando agregamos uno al proyecto como vemos a continuación.

 

Basic Activity / Básica
La Actividad básica nos presenta un Title Bar, Float Button, Menu y Back Button, siendo obvias las funciones de cada uno, considerando las actividades más comunes que un desarrollador pretende hacer con el Activity.

 

Bottom Navigation Activity / Botones de Navegación al Fondo
Este Activity nos agrega un Title Bar, Back Button, Menu y Navigation Bar en la parte de abajo donde podemos agregar cualquier cantidad de botones como si se tratasen de accesos directos dentro de nuestra Aplicación.

 

Empty Activity / Vacía
El Empty Activity agrega solamente el Title Bar y Back Button para que nosotros hagamos lo que queramos con él.

 

Fullscreen Activity / Pantalla Completa
Fullscreen no tiene Title Bar ni otros botones, como su nombre lo dice es un Activity a pantalla completa.

 

Google AdMob Ads Activity / Anuncios de Google AdMob
Este Activity cumple con la única función de mostrar los anuncios de AdMob.

 

Google Maps Activity / Google Maps
Nos agrega un Title Bar, Back Button y un mapa de Google.

 

Login Activity / Acceso
Nos agrega todo lo necesario para poder hacer un login a nuestra Aplicación.

 

Master Detail Flow / Flujo Maestro y de Detalles
Esta pantalla crea una APP que tiene una visualización de una lista de elementos que al seleccionarlos se abre una visualización de los detalles de dicho elemento.

 

Navigation Drawer Activity / Panel Lateral de Navegación
Además de un Basic Activity agrega un panel lateral de navegación a la izquierda de la APP.

 

Scrolling Activity / Desplazamiento
Este Activity nos muestra una pantalla que podemos desplazar dependiendo de la cantidad de contenido que tenga.

 

Settings Activity / Configuraciones
El Setting Activity son las configuraciones que podemos hacer a nuestra aplicación, es un listado algo especial donde agregamos cada una de las configuraciones con tipo de captura especial para el tipo de datos que se necesite guardar.

Tabbed Activity / Pestañas
Con este activity podemos agregar diferentes pestañas con diferente contenido y controles cada uno deslizables hacia los lados.

 

 

---

Un Activity o Actividad no es otra cosa más que una clase que muestra cada pantalla que vemos en cualquier aplicación, un formulario, un mapa, la cámara, y que también hay de diferentes tipos, pueden ser a pantalla completa, otros flotantes, etc.

---

Hacer una depuración o debigging de nuestro código nos ayuda para corregir errores que hemos detectado en la ejecución de la aplicación, nos permite poner un punto de interrupción, correr la aplicación paso a paso para ver el proceso línea por línea, ejecutar hasta el siguiente punto de interrupción y básicamente nos permite encontrar Bugs en nuestro código.

Para hacer la depuración presionamos el botón “Debug app” es el que tiene el insecto que parece un escarabajo.

En nuestro dispositivo nos aparecerá una advertencia que nos dice si queremos continuar con el debugging, simplemente lo dejamos continuar sin presionar nada desaparecerá solo.

En Android Studio los botones Stop y Apply Changes (rayo amarillo) se activarán y significan detener la depuración y aplicar cambios realizados durante la misma, respectivamente.

Existen los errores no controlados que nos detienen la ejecución de la aplicación porque encuentran un fallo y no se puede avanzar más allá, de estos errores nos damos cuenta cuando por ejemplo presionamos un botón y la aplicación se detiene sin más.

También existen los errores controlados que cuando se llega a un punto especifico y no se cumplen las condiciones óptimas para la secuencia correcta de la aplicación, le decimos que nos muestre un mensaje en pantalla, y de ésta manera la ejecución de la aplicación no se detiene, si no que regresa a un punto que nosotros le indicamos; Esto se logra verificando el valor de una variable y si no tiene el valor adecuado mostramos un mensaje, pero también pueden ocurrir eventos que no podemos controlar directamente y necesitamos que si hay algún problema no se detenga la ejecución total de la aplicación que se hace colocando nuestra función dentro de un bloque Try-Catch que lo que hace es tratar de ejecutar el código que está dentro del bloque Try, si no hay errores sigue con la ejecución normal pero se sucede algo inesperado, algo que no se puede procesar, en ese momento se detiene la ejecución de ese código y pasa directamente al bloque Catch que nos da información del error ocurrido y donde generalmente mostramos un mensaje con la descripción del error, pero que también podemos enviar a otras funciones o simplemente ignorarlo y dejar correr el resto del código.

En éste caso al presionar un botón mostraremos un mensaje que nos diga que un proceso se realizó con éxito, vamos a convertir un texto a numero.

Aquí verificamos que la variable tenga valor y como no tiene mostramos el mensaje que no se pudo convertir.

En éste otro tratamos de hacer la conversión de la variable que tiene valor nulo o una letra a numero entero, pero como eso no se puede hacer nos detendrá la aplicación.

Cuando nuestra aplicación se detiene y no sabemos por qué (si ejecutamos en dispositivo, éste debe estar conectado) en la ejecución de la aplicación cuando ocurre un error no controlado nos muestra toda la información de lo que ocurrió y también la línea donde ocurrió, para dirigirnos a esa área a buscar el problema.

En éste caso nos dice la tercera línea de color rojo la Exception, es decir, el problema ocurrido que el valor “e” no es un tipo de datos entero válido, por lo tanto no se puede convertir, por otro lado nos dice también que ocurrió en el evento “onClick” en la línea “30” del Activity “MainActivity” (marcado de color azul).

Si no es posible encontrar la falla a simple vista, probablemente se trate de un error con los valores que se están manejando, para revisarlo ponemos un punto de interrupción en la línea donde sucede el problema y iniciamos la depuración.

En ésta imagen podremos observar la depuración con el punto de interrupción en la línea 31 y aquí nos damos cuenta que la variable Texto que es la que toma el valor del EditText contiene la letra “e” que por supuesto no se puede convertir a número.

El mismo ejemplo pero con el código de la conversión dentro de un bloque Try-Catch que tomará el error y lo mostraremos en un mensaje.

---

Ejecutar nuestra aplicación directamente en nuestro dispositivo nos permite ver como va realmente en él, probar los recursos que no podemos en el emulador como el uso de la cámara fotográfica, probar sonidos, guardar en memoria, en otras palabras nos permite ver el comportamiento de nuestra aplicación en un dispositivo final (sin olvidar que todos los dispositivos son diferentes en tamaño, procesador, RAM, pantalla, entre otras características), veremos como conectar dispositivo a Android Studio.
Primeramente tienes que instalar los drivers de tu dispositivo en tu computadora.

1.4.2.1 Forma alámbrica por USB
Ahora en nuestro dispositivo vamos a Ajustes > Acerca del teléfono > Información del dispositivo y en la opción Número de compilación seleccionamos varias veces hasta que nos diga que somos programadores; Esto habilitará una opción extra en el menú de Ajustes que se llama Programador.

En este nuevo menú encontraremos varias opciones que nos permitirán monitorear el proceso de ejecución de la aplicación, por ejemplo Estadísticas de la aplicaciones instaladas, Mostrar toques, que ilumina el área seleccionada con un toque y la que nos interesa que es la Depuración USB que nos permitirá conectar el dispositivo a Android Studio.

1.4.2.2 Forma inalámbrica por WIFI
Para conectar por ADB “Android Debug Bridge” primero necesitamos tener conectado el teléfono a la computadora por USB (Con la depuración USB activada) .
Abrimos el Símbolo del sistema y ejecutamos el comando adb devices que se encuentra en la carpeta de instalación del SDK de Android
En mi caso es este directorio:
D:\Instalacion_Android\platform-tools\adb devices

Nos aparecerá una lista de dispositivos adjuntos en la que podremos ver el nuestro.
Solo nos queda ejecutar nuestra aplicación en dispositivo y esta se ejecutara en nuestro teléfono.

2. En seguida ejecutamos el comando adb tcpip 5555 que significa el puerto por donde se hará la conexión y puede ser cualquiera (comúnmente elegido el 5555).
D:\Instalacion_Android\platform-tools\adb tcpip 5555

Una vez que nos diga que se reseteo en modo TCP desconectamos el teléfono.

3. Para el paso final es necesario conocer la IP de nuestro teléfono, para ello vamos a Ajustes > Acerca del teléfono > Estado > Dirección IP, ya que identificamos nuestra IP regresamos al Símbolo del Sistema y ejecutamos el siguiente comando para conectar a nuestra IP, ponemos la IP seguida del puerto que abrimos anteriormente, separados por dos puntos ( : ) después de esto ya estará conectado por WIFI.
D:\Instalacion_Android\platform-tools\adb connect 192.168.1.98:5555

Si queremos asegurarnos de lo anterior ejecutamos nuevamente el comando adb devices que nos lo confirmará.
D:\Instalacion_Android\platform-tools\adb devices

*Desafortunadamente esto no dura para siempre por lo que la próxima vez que queramos conectarnos vía WIFI es necesario ejecutar el comando de la conexión de IP que vimos en el paso 3

---

La ventaja de crear un dispositivo virtual Android es que podemos ponerle todas las características de procesamiento y tamaño de pantalla que nosotros queramos pudiendo emular prácticamente cualquier dispositivo de cualquier marca para ver realmente como se comporta nuestra Aplicación en ese ambiente.

Ahora veremos como crear un emulador de Android.

• Elegimos la opción AVD Manager.

• Esta es una lista de dispositivos virtuales prefabricados para Android Studio, en éste caso no los tengo descargados y para usarlos tengo que descargarlos, podríamos usar uno de estos so lo deseamos, pero para crear un dispositivo damos click donde dice “Create Virtual Device”.

• Aquí debemos elegir el tipo de dispositivo entre los que podemos elegir están Android TV, Relojes, Tablets y por supuesto teléfonos.

• Elegimos un perfil de hardware que nos agrade o bien podemos crear uno nuevo o hasta importarlo.

• Entre las configuraciones del hardware podemos elegir desde el tamaño de la pantalla, la resolución, memoria RAM y hasta los tipos de sensores como GPS, Acelerometro y Giroscopio.

• Una vez creardo el perfil de hardware elegimos el Sistema Operativo que tendrá, en este caso elegimos Android 5.1 Lollipop.

• Finalmente lo iniciamos y tenemos un emulador de Android con la versión Lollipop.

 

 

 

 

 

 

 

---