Desarrollo de Soluciones

Móviles

Pedro Yuri Marquez Solis

 Tipos de aplicaciones móviles

Apps nativas
Las aplicaciones nativas, “son aquellas que han sido desarrolladas con
el software que ofrece cada sistema operativo a los programadores,
llamado genéricamente Software Development Kit o SDK” (Cuello, J. &
Vittone, J, 2013, p. 20)
Apple iOS Android Windows Phone
Lenguajes Objetive C, C++ .Java ,C, C++. C#, VB.NET
Herramientas XCode Android SDK Visual Studio
Formato archivo .app .apk .xap
Tiendas Apps App Store Google Play Windows Phone
Plataforma Android
 Android
• Plataforma de software basada en el
Kernel de Linux.
• Plataforma de código abierto
• Plataforma para abstraer el hardware y
facilitar el desarrollo de aplicaciones para
dispositivos con recursos limitados –
móviles.
• Java, Kotlin, C++
 Filosofía de Android

• Lograr la mayor duración de la batería

posible.
• Menor cantidad de procesos activos y en
Primer plano (UNO).
• Activar únicamente los métodos cuando se
necesiten
• Desactivar los dispositivos que no se están
empleando.
• El Framework exige Encapsulamiento y uso
de normas en el nombrado de objetos.
Arquitectura
de Android
 SDK Android

SDK Android: Software Development Kit, - Kit de Desarrollo

de Software
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.
Componentes de un proyecto en Android Studio
Estructura de un proyecto Android
 Actividad (Activity)
Cada pantalla a mostrar es un Activity es una
subclase de la clase Activity.
Contienen elementos View (mostrar elementos
gráficos y reaccionar a entradas/gestos del
usuario.

El framework Android puede decidir "matar“

(signal Kill) una actividad para liberar
recursos para otras aplicaciones (sólo si su
actividad ya no está en primer plano)
 Servicio(Service)

Un servicio es un proceso que se ejecuta “detrás” en segundo plano, sin la necesidad de

una interacción con el usuario. En Android disponemos de dos tipos de servicios:
servicios locales, que son ejecutados en el mismo proceso y servicios remotos, que son
ejecutados en procesos separados.

Un servicio, a diferencia de una actividad, no tiene interfaz pero permite la

ejecución de un tratamiento en segundo plano (una operación larga o una llamada
remota). Un servicio no se detendrá mientras que no se interrumpa o termine.
Por ejemplo, se puede utilizar un servicio para escuchar música en segundo plano en
su teléfono.
 Proveedores de contenido (Content provider)
Un content provider permite compartir datos entre aplicaciones. Estos datos
pueden estar almacenados de varias maneras, como archivos, bases de datos o a
través de Internet.
Android ofrece content providers (disponibles por defecto) que pueden usarse en
sus aplicaciones:
• Contactos.
• Agenda.
• Multimedia, etc.
 Ejemplos de proveedores de contenido de
Android
• La Galería que contiene imágenes.
• Listas de contactos que contienen
datos de contacto.
• Un diccionario que tiene colecciones
de todas las palabras que se utilizan.
• La lista de reproducción de música
tiene una lista de canciones.
• Los registros de llamadas contienen
los detalles de la llamada.
 Receptor de anúncios (Broadcast receiver)
Un receptor de anuncios recibe y reacciona ante anuncios de tipo broadcast. Los anuncios
broadcast pueden ser originados por el sistema o por las aplicaciones. Algunos tipos de
anuncios originados por el sistema son: Batería baja, llamada entrante. Por ejemplo, saber
cuándo:
El teléfono recibe un SMS.
El teléfono se enciende.
La pantalla está bloqueada, etc.
Los broadcast receivers no tienen interfaz de usuario y deben realizar tareas ligeras. Si
necesita ejecutar una tarea pesada en la recepción de un Broadcast receiver, puede, iniciar
un servicio.
Un Broadcast receiver no puede realizar modificaciones en sus interfaces, sólo puede
mostrar una notificación, iniciar una actividad o un servicio, etc.
 Vista (View)

Las vistas son los elementos que componen la interfaz de

usuario de una aplicación: por ejemplo, un botón o una
entrada de texto. Todas las vistas van a ser objetos
descendientes de la clase View, y por tanto, pueden ser
definidas utilizando código Java. Sin embargo, lo habitual será
definir las vistas utilizando un fichero XML y dejar que el
sistema cree los objetos por nosotros a partir de este fichero.
Esta forma de trabajar es muy similar a la definición de una
página web utilizando código HTML.
 Most commonly
used Android View
classes
 Vistas - Programmatic Approach

Button myButton = new Button(this);

myButton.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.MATCH_PARENT));
myLayout.addView(myButton);
 Vistas - Programmatic Approach  xml file

<TextView
android:id="@+id/todo"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=“Por realizar"
android:textSize="45sp"
android:padding="20dp"
android:textColor="#DD2C00“/>/>
 Ciclo de vida de un activity

Proceso transparente al usuario.

• onCreate()  inicio
• onStar: pasa a estado visible
• onResume()  Vuelve al primer plano
• onPause()  Pasa a segundo plano(-
onResume)
• onStop() cuando la actividad deja de
estar visible (-onStart)
• onDestroy()  Cuando la actividad se
cierra.
 IDE: entorno de desarrollo integrado

IDE
Editor de código, un compilador, un
depurador y un constructor de interfaz
gráfica (GUI).
- Asegura de seguir reglas del
Framework
 Nombre que
se mostrará
al usuario en
el launcher

Identificador
único

Buscar el mas
alto
Nombre de Dominio y paquete único en el google Play
Estructura de un
proyecto en
Android
 AndroidManifest.xml:

Enlazador de los archivos, los

describe e indica como
interactúan.
• Guarda configuración general de
la aplicación.

Atributo : package, metadatos:

Android:icon
Android:label
 java

Guarda las clases java que definen

la lógica de la app.
Agrupados por packages.
Si son muchas clases se
recomienda crear packages.
 res

• Recursos del proyecto para diseñar la

interface, imágenes, íconos del app,
cadenas de texto, que apoyan el
contenido de la app.
 Recursos de la app

• Icono de la aplicación y recursos

• Drawable 
densidad de la pantalla, xml o mapa de bits.

• Mipmap  conserva, para el icono de la app.

• Values: definir textos, arrays, colores, estilos.

 Gradle - scripts
El sistema de compilación de Android
compila recursos y código fuente de la app
y los empaqueta en APK que puedes
probar, implementar, firmar y distribuir.
Android Studio usa Gradle, un paquete de
herramientas de compilación avanzadas,
para automatizar y administrar el proceso
de compilación

• Proyecto

• Módulos
 Gradle Scripts
• compileSdkVersion: es la versión de Android que utilizan las herramientas de compilación
(Gradle) para compilar la aplicación para su lanzamiento, ejecución o depuración.
• applicationId: es el identificador único de la aplicación cuando ésta sea publicada en Google
Play. No pueden existir 2 aplicaciones publicadas con el mismo identificador.
• minSdkVersion: es la versión mínima del sistema operativo Android necesaria para ejecutar la
aplicación. La aplicación no podrá ser instalada en un dispositivo que tenga una versión inferior
a ésta.
• targetSdkVersion: conocida como versión SDK destino, es la versión de Android en la que se
creó la aplicación para que se ejecute. Indica que hemos probado nuestra aplicación hasta la
versión que especificamos en esta propiedad.
• versionCode: es un número que es usado para determinar si una versión es más reciente que
otra. Este numero no es mostrado a los usuarios pero sirve para definir el numero de versión
dentro de la Play Store.
• versionName: es una cadena de texto, su único propósito es mostrar el número de versión de
la aplicación a los usuarios de Google Play.
 targetSdkVersion
Para todos los propósitos prácticos, en la mayoría de las aplicaciones
deberemos establecer targetSdkVersion a la última versión de la API. Esto
asegurará que nuestra aplicación se vea lo mejor posible en los dispositivos
Android más recientes. Si no especificamos targetSdkVersion , por defecto es
minSdkVersion .
Debe por tanto cumplirse:
minSdkVersion <= targetSdkVersion <= compileSdkVersion
Lo ideal es:
minSdkVersion (la menor posible) <= targetSdkVersion == compileSdkVersion (la
versión más reciente de SDK)
Layouts
 Layouts

• Un Layout es un elemento que Algunos de los view

representa el diseño de la interfaz
de usuario de componentes
groups más populares
gráficos como una actividad, son:
fragmento o widget.
• Los layouts pueden ser creados a  LinearLayout
través de archivos XML o con  FrameLayout
código Java de forma programática
 RelativeLayout
 TableLayout
 GridLayout
 Cargar layout XML En Android

• Al tener definido tu layout(recurso), ya es posible inflar su contenido

en la actividad. Para ello usa el método setContentView() dentro
del controlador onCreate().
 Atributos De Un Layout

• Encontrarás atributos
para el tamaño, la
alineación, padding,
bordes, backgrounds,
etc.
• Identificador de un
view—representa un
identificador único para
cada elemento.
 Propiedades esenciales

wrap_content: Ajusta el tamaño al match_parent: Ajusta el tamaño a

espacio mínimo que requiere el las dimensiones máximas que el
view padre le permita.

En el botón ajusta su ancho y alto, la cantidad

necesaria para envolver el texto interior.
 LinearLayout
Es un ViewGroup que organiza las vistas secundarias en una
sola dirección, ya sea vertical u horizontalmente.
 FRAMELAYOUT

• Un FrameLayout es un view group

creado para mostrar un solo elemento
en pantalla.
• Para alinear cada elemento dentro del
FrameLayout usa el parámetro
android:layout_gravity.

• Es posible crear variaciones

combinadas, como por ejemplo right +
bottom.
• En código esta combinación puedes
representarla con un OR inclusivo.
android:layout_gravity="right|bottom"
 RelativeLayout

• Group View que muestra vistas

secundarias en posiciones relativas. La
posición de cada vista se puede
especificar como relativa a los elementos
hermanos (como a la izquierda o debajo
de otra vista) o en posiciones relativas al
área RelativeLayout principal (como
alineada en la parte inferior, izquierda o
central)
 RelativeLayout

• es una utilidad muy potente para

diseñar una interfaz de usuario
porque puede eliminar grupos de
vistas anidadas y mantener plana
la jerarquía de diseño, lo que
mejora el rendimiento. Si se
encuentra usando varios grupos
LinearLayout anidados, es posible
que pueda reemplazarlos con un
solo RelativeLayout.
 GridLayout

• Usa una cuadrícula de líneas

infinitamente delgadas para
separar su área de dibujo en:
filas, columnas y celdas.
Admite la expansión de filas
y columnas, lo que significa
que es posible fusionar
celdas adyacentes en una
celda grande (un rectángulo)
para contener una Vista
Para practicar
 Botones

• Un botón consiste en
un texto o un ícono (o
ambos) que comunica
la acción que ocurrirá
cuando el usuario lo
toque.
 Casillas de verificación

• Las casillas de verificación permiten que el usuario seleccione una o

más opciones de un conjunto. Por lo general, debes presentar cada
opción de casilla de verificación en una lista vertical.

https://developer.android.com/guide/topics/ui/controls/checkbox
 Botones de selección

• Permiten al usuario seleccionar

una opción de un conjunto.
Debes usar botones de selección
para conjuntos opcionales que
son mutuamente excluyentes public void generoSeleccionado(View view) {
sino usa un ícono giratorio en su RadioButton genSeleccionado= (RadioButton) view;
switch (genSeleccionado.getId()){
lugar. case R.id.radFem:{
Toast.makeText(this, "Mujer", Toast.LENGTH_SHORT).show();
• Debido a que los botones de break;
}
selección son mutuamente case R.id.radMas:{
excluyentes, debes agruparlos Toast.makeText(this, "", Toast.LENGTH_SHORT).show();
break;
dentro de un RadioGroup }
}
}
 LinearLayout

• Distribuye sus hijos

en una sola
dimensión
establecida.
• Todos organizados en
una sola columna
(vertical) o en una
sola fila (horizontal).
 LinearLayout
El parámetro android:layout_weight, define la importancia
El LinearLayout permite que tiene un view dentro del linear layout. A mayor
asignar una gravedad a cada
componente según el espacio importancia, más espacio podrá ocupar.
que ocupa.

Para distribuir todos los elementos sobre el espacio total del

layout, puedes usar el atributo height con valor cero.
android:layout_height="0dp"
android:layout_weight="3"
En modo
diseño y
blueprint
 RelativeLayout

El RelativeLayout permite alinear cada hijo

con referencias subjetivas de cada hermano.

Imagina en una sentencia como “el botón estará por debajo del texto” o
“la imagen se encuentra a la derecha de la descripción”.

android:layout_above: Posiciona el borde inferior del elemento actual con el

borde superior del view referenciado con el id indicado.
android:layout_centerHorizontal: Usa true para indicar que el view será centrado
horizontalmente con respecto al padre.
android:layout_alignParentBottom: Usa true para alinear el borde inferior de este
view con el borde inferior del padre.
android:layout_alignStart: Alinea el borde inicial de este elemento con el borde
inicial del view referido por id
En modo
diseño y
blueprint
 TableLayout

• El TableLayout organiza views en filas y

columnas de forma tabular.
• Para crear las filas se usa el componente
TableRow
• Cada celda es declarada como un view de
cualquier tipo (imagen, texto, otro group
view, etc.) dentro de la fila.
• Con otro tipo de view, todo el espacio de
la fila sea ocupado por el objeto.
• El TableRow trae consigo un parámetro
llamado android:layout_column para
asignar la columna a la que pertenece
cada celda en su interior.
• Puedes usar el parámetro weight para
declarar pesos de las celdas.
En modo
diseño y
blueprint
 GridLayout
Fila - columna
• Alinea sus elementos hijos en una cuadrícula
(grilla ó grid). Nace con el fin de evitar anidar
linear layouts para crear diseños complejos.
• Los índices inician en cero.

Atributos :
• columnCount: Cantidad de columnas
• rowCount: Cantidad de filas.
• useDefaultMargins: el valor de true establece
márgenes predeterminadas entre los ítems.
 GridLayout

• Es posible especificar la El siguiente código muestra un TextView

que ocupa 2 columnas y 3 filas.
cantidad de filas y columnas
que ocupará una celda a través
de los atributos
android:layout_rowSpan y
android:layout_columnSpan.
• Esta característica nos
posibilita para crear diseños
irregulares que un TableLayout
no permitiría.
Temas y estilos
 Definiendo Temas - Estilos

2
 colors.xml

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

<resources>
<color name="purple_200">#FFBB86FC</color>
<color name="purple_500">#FF6200EE</color>
<color name="purple_700">#FF3700B3</color>
<color name="teal_200">#FF03DAC5</color>
<color name="teal_700">#FF018786</color>
<color name="black">#FF000000</color>
<color name="white">#FFFFFFFF</color>
<color name="colorPrimary">#000</color>
<color name="colorPrimaryOscuro">#031237</color>
<color name="colorAccent">#03DAC5</color>
</resources>
 temas

• A partir de la API 21 se incuyó MaterialDesign, 3 versiones:

• Theme.Material (versión oscura)
• Theme.Material.Light (versión clara)
• Theme.Material.Light.DarkActionBar (versión clara con la barra oscura).

Para dar soporte a versiones anteriores a la API 21, se recomienda emplear :

Theme.AppCompat(Ligth y Light.DarkActionBar)
 Themes.xml
<resources xmlns:tools="http://schemas.android.com/tools">
<!-- Base application theme. -->
<style name="Theme.Layouts" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
<!-- Primary brand color. -->
<item name="colorPrimary">@color/purple_500</item>
<item name="colorPrimaryVariant">@color/purple_700</item>
<item name="colorOnPrimary">@color/white</item>
<!-- Secondary brand color. -->
<item name="colorSecondary">@color/teal_200</item>
<item name="colorSecondaryVariant">@color/teal_700</item>
<item name="colorOnSecondary">@color/black</item>
<!-- Status bar color. -->
<item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
<!-- Customize your theme here. -->
</style>
<style name="AppThemeYMS" parent="Theme.AppCompat.Light.NoActionBar">
<!-- Customize your theme here. -->
<item name="colorPrimary">@color/colorPrimary</item>
<item name="colorPrimaryDark">@color/colorPrimaryOscuro</item>
<item name="colorAccent">@color/colorAccent</item>
</style>
</resources>
 Estilos

• No crear estilos para cada uno de los componentes, peor si se va usar

en una sola vista.
• Cuando tengan un significado semántico y una finalidad idéntica
dentro de la aplicación  calculadora.
• Basarse en los temas ya definidos por el sistema y modificar
solamente propiedades que queramos modificar
 Styles.xml
<?xml version="1.0" encoding="utf-8"?>

<resources>
<style name="AppTheme.BotonTransparente" parent="TextAppearance.AppCompat.Headline">
<item name="android:textColor">@android:color/white</item>
<item name="android:background">?android:selectableItemBackground</item>
<item name="android:textSize">32dp</item>
<item name="android:layout_width">wrap_content</item>
<item name="android:layout_height">wrap_content</item>

</style>

</resources>
Intents, Listas y Menúes
 Intents

Los intents permiten comunicar diferentes componentes de la

aplicación, como activities y services.

• La clase Intent, permite describir una operación que deseamos

realizar, por ejemplo:
• iniciar una actividad o servicio.
• Intercambiar datos entre aplicaciones o componentes.
• Solicitar al sistema que realice una acción.
Tenemos dos tipos:
• Explicitos
• Implicitos
Llamando actividades – Forma 1 - Explicitos
public class MainActivity extends AppCompatActivity implements
View.OnClickListener {
Button btncaso2, btnCaso3;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btncaso2 = findViewById(R.id.btncaso2);
btnCaso3=findViewById(R.id.btncaso3);
btncaso2.setOnClickListener(this);
btnCaso3.setOnClickListener(this);
}
@Override
public void onClick(View view) {
switch (view.getId()) {
case R.id.btncaso2: { Con esta llamada se abriría
Intent i = new Intent(this, Caso2.class);
startActivity(i);
El activity caso2, quedando
break; en la pila MainActivity.
}
case R.id.btncaso3: {
Intent i = new Intent(this, Caso3.class);
startActivity(i);
break;
}
}
}
}
 Envío de Datos por Intents
• Enviar datos por un Intent:
public void lanzarEje2(View v){
Intent i = new Intent(this,ejer2.class);
i.putExtra("valorTest","enviadoMain!");
startActivity(i);
}

• Recibir datos de un Intent:

public class ejer2 extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ejer2);
String mensaje = getIntent().getStringExtra("valorTest");
Log.d("Hola", mensaje);
Toast.makeText(this, mensaje, Toast.LENGTH_SHORT).show();
}
}
 Llamar a un activity por un método

• Crear el método
public void muestraEje3(View v){
Intent i = new Intent(this, Ejer3.class);
startActivity(i);
}

• En la ventana del layout elegir el botón, mediante la propiedad onClic

elegir el método de llamada.
public void llamaracccion(View v){
Intent i= new Intent(Intent.ACTION_VIEW, Uri.parse("http.google.com"));
startActivity(i);
}
 Intents Implicitos
• Solicita un componente anónimo de una aplicación sin determinar.

Invoca a una actividad relacionada

Intent i= new Intent(Intent.ACTION_VIEW, Uri.parse("http.google.com"));

startActivity(i);

En ciertos casos es necesario

indicar el Uri
 Intents Implicitos

• Solicita un componente anónimo de una aplicación sin determinar.

Podría ocurrir que no hubiese ningún programa
Para realizar la tarea solicitada

Intent i= new Intent(Intent.ACTION_VIEW, Uri.parse("http.google.com"));

if i.resolveActivity(getPackegeManager()) != null{
startActivity(i);
}

Comprobar antes si encuentra

alguna actividad que cumpla la
función deseada
 Acción Constante representativa
Empieza la actividad de una aplicación con el punto principal de entrada ACTION_MAIN
Muestra information al usuario ACTION_VIEW
Indica que cierta información debe ser añadida en una parte especifica ACTION_ATTACH_DATA
Obtiene un acceso a la edición de alguna información ACTION_EDIT
Selecciona un item de un conjunto de datos y retorna en él ACTION_PICK
Visualiza una actividad con opciones para el usuario. ACTION_CHOOSER
Permite seleccionar un tipo de información y retornarla ACTION_GET_CONTENT
Marca un numero para iniciar una llamada ACTION_DIAL
Realiza una llamada a un numero especificado ACTION_CALL
Inicia una acción de envió de datos a alguien que aun no se ha
ACTION_SEND
especificado
Inicia una acción de envío de datos para alguien en especifico ACTION_SENDTO
Gestiona una llamada entrante ACTION_ANSWER
Crea un objeto vacío que se añadirá a un contenedor ACTION_INSERT
Elimina informacion seleccionada de su ubicación ACTION_DELETE
Ejecuta cualquier tipo de dato ACTION_RUN
Inicia una sincronizacion de datos ACTION_SYNC
Retorna en el nombre de la clase seleccionada ACTION_PICK_ACTIVITY
Realiza una busqueda ACTION_SEARCH
Realiza una busqueda web ACTION_WEB_SEARCH
Ejecuta un punto de entrada principal para un teste en modo «test de
ACTION_FACTORY_TEST
fabrica»
 Empleo de listas y adaptadores

• Las listas son vistas de tipo ListView.

• Si el único componente view a mostrar será

Un ListView es mejor emplear un ListActivity
 ListActivity

• Ventajas:
• Métodos para manejar ItemSelected.
• Acceder a la vista mediante getListView
• Posibilidad de implementar el método: onListItemClicked, para actuar cuando se
escoja alguna opción de la lista.
• Para poblar la lista se debe emplear un Adapter. ListAdapter, encargado de
manejar los datos de la lista. Se debe inicializar en el onCreate y asignado
mediante setListAdapter.
• Adapter  transforma los datos internos en Items de la lista con una interface
que se debe especificar con un Layout
 RecyclerView

• Mas flexible que el ListView, diseñado para mostrar grandes

cantidades de datos, reutiliza vistas de los elementos que no se
visualizan.
• Conlleva a programación mas compleja, Adapter.
 Adapters Poblar Lista Con Un Adaptador

• Elemento básico para la creación de listas.

• Vincula los datos de la aplicación con la interface para mostrarlos, en
este caso la interface de cada Item de la lista.

Adaptadores para ListView:

Design Patterns
Adapter: tiene como objetivo convertir la interfaz
de una clase existente en la interfaz esperada por
los clientes también existentes para que puedan
trabajar de forma conjunta.
 Ejemplo ListView
public class MainActivity extends AppCompatActivity {
ListView listaTemas;
String[] spacecrafts={"Juno","Hubble","Casini","WMAP","Spitzer","Pioneer","Columbia","Challenger","Apollo","Curiosity"};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
listaTemas= findViewById(R.id.listaTemas);
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, spacecrafts);
listaTemas.setAdapter(adapter);
listaTemas.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Toast.makeText(MainActivity.this, spacecrafts[position], Toast.LENGTH_SHORT).show();
}
});
}
}
 Listas con LayoutsPersonalizados
public class MainActivity extends AppCompatActivity {
ListView listaTemas;
String[] spacecrafts={"Juno","Hubble","Casini","WMAP","Spitzer","Pioneer","Columbia","Challenger","Apollo","Curiosity"};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
listaTemas= findViewById(R.id.listaTemas);
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, R.layout.itemlista, R.id.nombre, spacecrafts);
listaTemas.setAdapter(adapter);
listaTemas.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Toast.makeText(MainActivity.this, spacecrafts[position], Toast.LENGTH_SHORT).show();
}
});
}
}
 Menús

• AppBar: a partir de Android 3.0, es una barra superior que contiene el

titulo de la actividad, opcionalmente contiene una serie de botones
de menú o un menú desplegable.
Definir el menú de una actividad:
• Sobrecargar el método onCreateOptionsMenú, pasándole como
parámetro un objeto de la clase menú.
• Finalmente devolver true(para que se muestre)
 Menú definido por xml

<?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/item1"
android:icon="@drawable/ic_call"
android:title="Llamar"
app:showAsAction="always"
></item>

<item android:id="@+id/item2"
android:icon="@drawable/ic_blue"
android:title="Enlazar"
app:showAsAction="always"
></item>
</menu>
 Insertar el menú en el ActivityMain
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu1, menu);
return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
switch (item.getItemId()){
case R.id.item1:{
Toast.makeText(this, "Item 1 - Llamar", Toast.LENGTH_SHORT).show();
break;
}
case R.id.item2:{
Toast.makeText(this, "Item 2 - Enlazar", Toast.LENGTH_SHORT).show();
break;
}
}

return super.onOptionsItemSelected(item);
}