Actividades e Intenciones

Curso Android

  • Actividad: una unidad de interacción con el usuario, es lo que coloquialmente llamamos una pantalla de la aplicación.
  • Toda actividad ha de tener una vista asociada, que será utilizada como interfaz de usuario.
  • Una aplicación estará formada por un conjunto de actividades independientes, es decir se trata de clases independientes que no comparten variables, aunque todas trabajan para un objetivo común.
  • Toda actividad ha de ser una subclase de Activity.

A medida que nuestra aplicación crezca va a ser imprescindible crear nuevas actividades.

Este proceso se puede resumir en cuatro pasos:

  • Crea un nuevo Layout para la actividad.
  • Crea una nueva clase descendiente de Activity. En esta clase tendrás que indicar que el Layout a visualizar es el desarrollado en el punto anterior.
  • Para que nuestra aplicación sea visible será necesario activarla desde otra actividad.
  • De forma obligatoria tendremos que registrar toda nueva actividad en AndroidManifest.xml

Comunicación entre actividades

Android nos permite este intercambio de datos utilizando el mecanismo

Intent intent = new Intent(this, MI_CLASE.class);
intent.putExtra("usuario", "Pepito Perez");
intent.putExtra("edad", 27);
startActivity(intent);
Bundle extras = getIntent().getExtras();
String s = extras.getString("usuario");
int i = extras.getInt("edad");

Cuando lances una actividad usa el siguiente código:

En la actividad lanzada podemos recoger los datos:

Intent intent = new Intent(this, MI_CLASE.class);
startActivityForResult(intent, 1234);
 ...
@Override protected void onActivityResult (int requestCode, 
                                  int resultCode, Intent data){
    if (requestCode==1234 && resultCode==RESULT_OK) {
       String res = data.getExtras().getString("resultado");
    }
}
Intent intent = new Intent();
intent.putExtra("resultado","valor");
setResult(RESULT_OK, intent);
finish();

Cuando la actividad lanzada termina también podrá devolver datos que podrán ser recogidos por la actividad lanzadora de la siguiente manera.

 

En la actividad llamada has de escribir:

Ejercicio

Añadiendo un menú a una actividad

  • Android permite asignar menús a las actividades, que se despliegan cuando se pulsa la tecla de menú.
  • Desde la versión 3.0 ya no es obligatorio que un dispositivo Android disponga de la tecla de menú.
  •  En la versión 3.0 aparece la barra de acciones, donde se integra el menú de las actividades.
  • En este punto estudiaremos el planteamiento anterior a la aparición de la barra de acciones, es decir, el menú de actividad.

Creando un nuevo menú

1- Para crear un nuevo menú, usa File > New > Android resource file. En el campo File name: selecciona menu_main y en el campo Resource type: selecciona Menu.

NOTA: Es posible que este fichero de menú ya esté creado. Esto ocurre cuando se crea un nuevo proyecto  seleccina Add an activity: Basic Activity o Scrolling Activity.

 

2-Completa el archivo creado con la estructura que indica el siguiente ejemplo

<menu 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"
      tools:context=".MainActivity">
   <item android:id="@+id/action_settings"
         android:title="Preferencias"
         android:icon="@android:drawable/ic_menu_preferences"/>
   <item android:title="Acerca de..."
         android:id="@+id/acercaDe"
         android:icon="@android:drawable/ic_menu_info_details"/>
</menu>

Tres atributos principales:

  • id que permite identificarlo desde el código
  • title, para asociarle un texto  
  • icon, para asociarle un icono.

3- Para activar el menú, has de introducir el siguiente código java de tu actividad.

@Override public boolean onCreateOptionsMenu(Menu menu) {
   getMenuInflater().inflate(R.menu.menu_main, menu);
   return true; /** true -> el menú ya está visible */
}
    
@Override public boolean onOptionsItemSelected(MenuItem item) {
   int id = item.getItemId();
   if (id == R.id.action_settings) {
      return true;
   }
   if (id == R.id. acercaDe) {
      lanzarAcercaDe(null);
      return true;
   }
   return super.onOptionsItemSelected(item);
}

La barra de acciones (ActionBar)

La Action bar, o App bar como se la ha rebautizado con la llegada de Material Design y Android 5.0, es la barra de título y herramientas que aparece en la parte superior de la gran mayoría de aplicaciones actuales de la plataforma Android.

  • Desde la versión 3.0.
  • Aglutina varios elementos; los más habituales son el icono de la aplicación con su nombre y los botones de acciones frecuentes.
  • Las acciones menos utilizadas se sitúan en un menú desplegable, que se abrirá desde el botón Overflow.
  • Si la aplicación dispone de pestañas (tabs), estas podrán situarse en la barra de acciones.
  • También pueden añadirse otros elementos, como listas desplegables y otros tipos de widgets incrustados, como el widget de búsqueda.

En caso de disponer de menos tamaño de pantalla el sistema puede redistribuir los elementos y pasar alguna acción al menú de «Overflow». Por ejemplo, en un móvil la barra de acciones anterior se podría ver de la siguiente manera:

Antes de la llegada de Material Design, a la izquierda del título también podía (y solía) aparecer el icono de la aplicación, aunque esto último ya no se recomienda en las últimas guías de diseño de la plataforma. Lo que sí puede aparecer a la izquierda del título son los iconos indicativos de la existencia de menú lateral deslizante (navigation drawer) o el botón de navegación hacia atrás/arriba.

  • Los dispositivos anteriores a la versión 3.0 requerían una tecla física para mostrar el menú de la actividad.  
  • En los dispositivos que sí que dispongan de este botón físico, es posible que los tres puntos que representan el menú de Overflow no se representen en la barra de acciones.
  • Cuando la aplicación se ejecute en una versión inferior a la 3.0, el menú se mostrará de forma tradicional. Cuando el usuario pulse la tecla de menú, aparecerá:

Pero, en caso de disponer de una versión 3.0 o superior, se mostrará en la barra de acciones.

En la actualidad, Android proporciona este componente a través de la librería de soporte appcompat-v7, que podemos incluir en nuestro proyecto añadiendo su referencia en la sección dependencies del fichero build.gradle:

dependencies {
    ...
    compile 'com.android.support:appcompat-v7:22.1.1'
}

De cualquier forma, en versiones actuales de Android Studio, esta referencia viene incluida por defecto al crear un nuevo proyecto en blanco.

A partir de aquí, podemos hacer uso de la action bar de dos formas diferentes.

  • Primera opción: más sencilla aunque menos flexible, consiste en utilizar la action bar por defecto que se añade a nuestras actividades por tan sólo utilizar un tema (theme) determinado en la aplicación y extender nuestras actividades de una clase específica.
  • Segunda opción: más flexible y personalizable aunque requiere más código, consiste en utilizar el nuevo componente Toolbar disponible desde la llegada de Android 5.0 (aunque compatible con versiones anteriores).

Primera opción

1.     Asegúrate de que en tu proyecto esté la librería appcompat-v7.

2.     Haz que tu actividad herede de ActionBarActivity o AppCompatActivity en lugar de Activity. Hasta la versión 21 de la librería appcompat-v7 la clase base de la que debían heredar nuestras actividades era ActionBarActivity, pero esto cambió con la versión 22, donde la nueva clase a utilizar como base será AppCompatActivity.

3.     En AndroidManifest has de aplicar un tema adecuado a la actividad o a toda la aplicación. Estos temas han de pertenecer a Theme.AppCompat.* o ser descendientes de estos.

Tan sólo con esto, si ejecutamos el proyecto podremos comprobar como nuestra actividad muestra la action bar en la parte superior

La action bar por defecto tan sólo contiene el título y el menú de overflow.

  • El título mostrado por defecto corresponde al título de la actividad, definido en el fichero AndroidManifest.xml, en el atributo label del elemento activity correspondiente a dicha actividad.
  • Los botones de acción y las opciones del menú de overflow se definen de la misma forma que los antiguos menús de aplicación que se utilizaban en versiones de Android 2.x e inferiores. De hecho, es exactamente la misma implementación.

Atributos para las acciones declaradas en el XML 

 

  • showAsAction: 
    • always: serán mostrados siempre, sin importar si caben o no. El uso de estas acciones debería limitarse a unas pocas, o incluso mejor si no hay ninguna, ya que al forzar que se visualicen todas al mismo tiempo podrían verse incorrectamente.
    • ifRoom: serán mostradas en la barra de acciones si hay espacio disponible, y serán movidas al menú de Overflow  si no lo hay. En esta categoría se deberían encontrar la mayoría de acciones.
    • never: la acción nunca se mostrará en la barra de acciones, sin importar el espacio disponible. En este grupo se deberían situar acciones como modificar las preferencias, que deben estar disponibles al usuario; pero no visibles en todo momento.
    • withText: Se mostrará el texto de la opción junto al icono en el caso de que éste se esté mostrando como botón de acción.
  • orderInCategory: las acciones se ordenan de izquierda a derecha según lo indicado en este atributo.
    • Las acciones con un número más pequeño más a la izquierda.
    • Si todas las acciones no caben en la barra, las que tienen un número menor son movidas al menú de Overflow.
  • Si prefieres que en una actividad no se muestre la barra de acciones, puedes asignarle un tema terminado en .NoTitleBar. Para ello edita el fichero AndroidManifest.xml y añade la línea subrayada.

Segunda opción

 

Una forma más flexible y personalizable de añadir una action bar a una aplicación es utilizar el nuevo componente Toolbar proporcionado por la librería appcompat. De esta forma podemos incluir de forma explícita la action bar en nuestros layouts XML como si fuera cualquier otro control, y no sólo en la parte superior de la pantalla a modo de app bar, sino también en cualquier otro lugar de la aplicación donde queramos utilizar esta funcionalidad de barra de acciones.

1- Asegurar es que nuestro proyecto incluye la última versión de la librería de soporte appcompat-v7, en la sección de dependencias del fichero build.gradle.

 

2- A continuación necesitamos “desactivar” la funcionalidad por defecto, configurando un tema para nuestra aplicación que no incluya la action bar. Para ello, editaremos el fichero /res/values/styles.xml para hacer que nuestro tema extienda de alguno de los siguientes (dependiendo si queremos partir del tema oscuro o claro):

  • Theme.AppCompat.NoActionBar
  • Theme.AppCompat.Light.NoActionBar

 

3- También que nuestras actividades deben extender a AppCompatActivity.

4- Hecho esto, ya podemos modificar el layout de nuestra actividad para incluir la action bar utilizando el nuevo componente Toolbar. 

<LinearLayout
    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:orientation="vertical"
    tools:context=".MainActivity">
 
    <android.support.v7.widget.Toolbar
        android:id="@+id/appbar"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:minHeight="?attr/actionBarSize"
        android:background="?attr/colorPrimary"
        android:elevation="4dp"
        android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"
        app:popupTheme="@style/ThemeOverlay.AppCompat.Light" >
 
    </android.support.v7.widget.Toolbar>
 
    <!-- Resto de la interfaz de usuario -->
 
</LinearLayout>

 

  • android:background. Asignaremos a esta propiedad el valor ?attr/colorPrimary de forma que se utilice como color de la barra de herramientas el que hemos definido como colorPrimary en el tema de la aplicación .
  • android:elevation. Esta propiedad define la elevación del componente, lo que determina la sombra que proyectará sobre el elemento inferior. Esta propiedad tan sólo tiene efecto cuando la aplicación se ejecuta sobre Android 5.0 o superior.
  • android:theme. Mediante esta propiedad definimos el tema a utilizar por la Toolbar(y que heredarán sus controles hijos). No debemos confundir esto con el tema definido a nivel de aplicación en el fichero styles.xml. Para conseguir el mismo efecto que en el artículo anterior, donde utilizamos el tema global Theme.AppCompat.Light.DarkActionBar.
  • app:popupTheme. tema del popup.

5- En nuestro código debemos indicar que esta Toolbar actuará como action bar de la actividad. Para ello, en el método onCreate() de la actividad haremos una llamada a setSupportActionBar() con la referencia a la toolbar:

import android.support.v7.widget.Toolbar;
//...
 
public class MainActivity extends AppCompatActivity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        Toolbar toolbar = (Toolbar) findViewById(R.id.appbar);
        setSupportActionBar(toolbar);
    }
 
    //...
}

Para no tener que reescribir la definición completa del toolbar en todas nuestras actividades también podemos hacer uso de la cláusula include. Para ello, declaramos primero el toolbar en un layout XML independiente, por ejemplo en un fichero llamado /res/layout/toolbar.xml.

Y posteriormente incluir este fragmento en el layout de nuestras actividades haciendo referencia a él mediante include:

 

<LinearLayout
    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:orientation="vertical"
    tools:context=".MainActivity">
 
    <include android:id="@+id/appbar"
        layout="@layout/toolbar" />
 
    <!-- Resto de la interfaz de usuario -->
 
</LinearLayout>

ListView

ListView

  • Diseñar un Layout que lo contenga al ListView
  • Diseñar un Layout individual que se repetirá en la lista
  • Implementar una actividad que lo visualice el Layout con el ListView
  • Personalizar cada una de los Layouts individuales según nuestros datos  

Visualiza una lista deslizable verticalmente de varios elementos, donde cada elemento puede definirse como un Layout 

Definir un ListView conlleva los siguientes cuatro pasos:

1- Para utilizar un ListView dentro de un Layout usamos la siguiente estructura:

<FrameLayout>
       <ListView
       android:id="@android:id/list"... />
       <TextView
              android:id="@android:id/empty"
              ... />
</FrameLayout>

Donde tenemos un FrameLayout que permite visualizar dos posibles elementos, uno u otro, pero no los dos simultáneamente.

  • El primero es el ListView que se visualizará cuando haya algún elemento en la lista.
  • El segundo puede ser cualquier tipo de vista y se visualizará cuando no existan elementos en la lista.

 

2- Indicar al sistema cada uno de los Layouts individuales que contendrá el ListView. Esto lo haremos llamando al método setListAdapter(). Existen varias alternativas con diferentes grados de dificultad.

 

3- Una vez creado el Layout que contiene el ListView tendremos que visualizarlo en una actividad. Para este propósito utilizaremos un tipo de actividad especial, ListActivity.

 

Un ListView que visualiza una lista de Strings

<FrameLayout
        android:layout_width="match_parent"
        android:layout_height="0dip"
        android:layout_weight="1">>
        <ListView android:id="@android:id/list"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>
        <TextView
            android:id="@android:id/empty"
            android:text="No hay elementos"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    </FrameLayout>
final String[] datos = new String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"};
ArrayAdapter<String> adaptador =new ArrayAdapter<String>(this,
                        android.R.layout.simple_list_item_1, datos);
setListAdapter(adaptador);

Un ListView que visualiza Layouts personalizados

setListAdapter(new ArrayAdapter(this,
                       R.layout.elemento_lista,
                       R.id.titulo,
                       array));

this: es el contexto, con información sobre el entorno de la aplicación.

R.layout.elemento_lista: es una referencia de recurso a la vista que será utilizada repetidas veces para formar la lista.

R.id.titulo: identifica un id de la vista anterior que ha de ser un TextView. Su texto será reemplazado por el que se indica en el siguiente parámetro.

array: vector de String con los textos que serán visualizados en cada uno de los TextView. 

<RelativeLayout  
       xmlns:android="http://schemas.android.com/apk/res/android"
       android:layout_width="match_parent"
       android:layout_height="?android:attr/listPreferredItemHeight">
       <ImageView android:id="@+id/icono"
             android:layout_width="?android:attr/listPreferredItemHeight"
             android:layout_height="match_parent"
             android:layout_alignParentLeft="true"
             android:src="@drawable/asteroide2"/>
       <TextView android:id="@+id/titulo"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_toRightOf="@id/icono"
             android:layout_alignParentTop="true"
             android:textAppearance="?android:attr/textAppearanceLarge"
             android:singleLine="true" />
       <TextView android:id="@+id/subtitulo"
             android:layout_width="match_parent"
             android:layout_height="match_parent"
             android:text="Otro Texto"
             android:layout_toRightOf="@id/icono"
             android:layout_below="@id/titulo"
             android:layout_alignParentBottom="true"
             android:gravity="center"/>
</RelativeLayout>

Un ListView con nuestro propio adaptador

Si queremos algo más adaptable tendremos que escribir nuestro propio adaptador extendiendo la clase BaseAdapter. En esta clase habrá que sobreescribir los siguientes cuatro métodos:

View getView(int position, View convertView, ViewGroup parent)

Este método ha de construir un nuevo objeto View que será visualizado en la  posición position .

int getCount()

Devuelve el número de elementos de la lista. 

Object getItem(int position)

Devuelve el elemento en una determinada posición de la lista.

long getItemId(int position)

Devuelve el identificador de fila de una determinada posición de la lista.

Intenciones

Una intención representa la voluntad de realizar alguna acción o tarea, como realizar una llamada de teléfono o visualizar una página web. Una intención nos permite lanzar una actividad o servicio de nuestra aplicación o de una aplicación diferente.

  • Intenciones explícitas: se indica exactamente el componente a lanzar. Su utilización típica es la de ir ejecutando los diferentes componentes internos de una aplicación.
  • Intenciones implícitas: pueden solicitar tareas abstractas, como “quiero tomar una foto” o “quiero enviar un mensaje”. Además las intenciones se resuelven en tiempo de ejecución, de forma que el sistema mirará cuantos componentes han registrado la posibilidad de ejecutar ese tipo deintención. Si encuentra varias el sistema puede preguntar al usuario el componente que prefiere utilizar.

Ilustración de la forma en que se entrega una intent implícita mediante el sistema para iniciar otra actividad.

[1] La actividad A crea unaIntent con una descripción de acción y la pasa a startActivity().

[2] El sistema Android busca en todas las apps un filtro de intents que coincida con la intent. Cuando se encuentra una coincidencia,

[3] el sistema inicia la actividad coincidente (actividad B) invocando su método onCreate() y pasándolo a la Intent.

Filtro de intents

Un filtro de intents es una expresión en el archivo de manifiesto de una aplicación que especifica el tipo de intents que el componente podría recibir. Por ejemplo, declarando un filtro de intents para una actividad, permite que otras aplicaciones inicien directamente la actividad con cierto tipo de intent. Así mismo, si no declara ningún filtro de intent para una actividad, solo se la puede iniciar con una intent explícita.

<activity android:name="MainActivity">
    <!-- This activity is the main entry, should appear in app launcher -->
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<activity android:name="ShareActivity">
    <!-- This activity handles "SEND" actions with text data -->
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
</activity>

En concreto se utilizan intenciones cada vez que queramos:

  • Lanzar una actividad (startActivity() y startActivityForResult())
  • Lanzar un servicio (startService())
  • Lanzar un anuncio de tipo broadcast (sendBroadcast())
  • Conectarnos con un servicio (bindService())

Cuando se crea una Intención (es decir, se instancia un objeto de tipo Intent) esta contiene información de interés para que el sistema trate adecuadamente  la  intención o para el componente que recibe la intención. Puede incluir la siguiente información:

Nombre del componente: Esto es opcional, pero es la información clave que hace que una intent sea explícita, lo que significa que la intent debe enviarse solamente al componente de la aplicación definido en el nombre del componente. Sin un nombre de componente, la intent es implícita y el sistema decide qué componente debe recibir la intent conforme la información restante que esta contiene (como la acción, los datos y la categoría, que se describen a continuación). Por lo que si necesita iniciar un componente específico en su aplicación, debe especificar el nombre del componente.

Acción: Una cadena de caracteres donde indicamos la acción a realizar o en caso de un Receptor de anuncios (Broadcast receiver), la acción que tuvo lugar y que queremos reportar. La clase Intent define una serie de constantes para acciones genéricas que se enumeran a continuación:

https://developer.android.com/reference/android/content/Intent.html?hl=es-419

Categoría: Complementa a la acción. Indica información adicional sobre el tipo de componente que ha de ser lanzado. El número de categorías puede ampliarse arbitrariamente. No obstante, en la clase Intent se definen una serie de categorías genéricas que podemos utilizar.

Datos: Referencia a los datos con los que trabajaremos.

  • Hay que expresar estos datos por medio de una URI (el mismo concepto ampliamente utilizado en Internet).

Ejemplos de URIs son: tel:963228525, http://www.androidcurso.com, content://call_log/calls…

  • En muchos casos resulta importante saber el tipo de datos con el que se trabaja. Con este propósito se indica el tipo MIME asociado a la URI, es decir, se utiliza el mismo mecanismo que en Internet.

Ejemplos de tipos MIME son text/xml, image/jpeg, audio/mp3…

Extras: Información adicional que será recibida por el componente lanzado.

Está formada por un conjunto de pares variable/valor.

Estas colecciones de valores se almacenan en un objeto de la clase Bundle. Su utilización ha sido descrita en la sección Comunicación entre actividades. 

intent.putExtra("usuario", "Pepito Perez")
intent.putExtra("edad", 27);

 Lanzar una actividad de forma explícita: utilizando el constructor Intent(Context contexto, Class<?> clase)

Intent intent = new Intent(this, AcercaDe.class);
startActivity(intent);

Lanzar una actividad de forma implícita: podemos usar el constructor Intent(String action, Uri uri)


Intent intent = new Intent(Intent.ACTION_DIAL,URI.parse("tel:962849347");
startActivity(intent);

Tabla con intenciones que podemos utilizar de aplicaciones Google

Made with Slides.com