Android

ANDROID

Es un S.O. basado en linux y escrito en Java.

Versiones de Android

Guía de instalación

1. Instalación del JDK:
   http://www.oracle.com/technetwork/java/javase/downloads/index.html
2. Instalación de Android Studio:
   http://developer.android.com/sdk/index.html

Activar opciones de desarrollo en Android 4.0 y superiores

Ajustes → Acerca del teléfono → Pulsamos 7 veces sobre el número de compilación.

Problema con la versión de Gradle

The version of Gradle you are using (Gradle installation '...') does not support ... Support for this is available in Gradle ... and all later versions.

Habrá que instalar la última versión de Gradle: gradle.org. Si somos usuarios de linux, debemos instalar el gestor de versiones sdkman.

Todos los ejercicios de este curso

Descargar la aplicación con todos los ejercicios en este enlace.

Ejecutar aplicaciones desde el móvil

Esto será mucho más rápido y veraz que ejecutar desde el emulador.

Conectar teléfono Android a Ubuntu

sudo gedit /etc/udev/rules.d/70-android.rules

SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0e79", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0502", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0b05", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="413c", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0489", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="091e", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="12d1", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="24e3", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2116", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0482", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="17ef", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1004", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="22b8", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0409", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2080", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0955", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2257", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="10a9", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1d4d", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0471", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="04da", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="05c6", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1f53", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="04e8", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="04dd", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0fce", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0930", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="19d2", MODE="0666"

Configura ción de Android Studio

Navegar en el explorador de ficheros a la ubicacion del fichero activo: En el panel "Android", en la columna izuierda -> Engranaje (opciones) -> Autoscroll From Source

Fichero gradle

apply plugin: 'com.android.application' //Esto nos indica que estamos haciendo una aplicación Android

android {
//Los siguientes dos valores van a la par, el primero es la versión de android que estamos usando y el segundo nos indica dentro de esa versión, en que revisión del código estamos
    compileSdkVersion 26 
    buildToolsVersion '26.0.2'
    defaultConfig {
//Este parámetro es un valor único dentro de la PlayStore. Suele coincidir con el package name (el primer paquete creado en la app)
        applicationId "com.example.elamorhallegado.dansu"
        minSdkVersion 19 //Cuanto mayor es, con menos dispositivos será compatible nuestra app
        targetSdkVersion 26

        versionCode 1 //es un numero entero que indica la versión de mi app
        versionName "1.0" //puede ser una palabra que indica la versión de mi app
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false // decidimos si queremos ofuscar nuestro código para evitar que alguien lo pueda decompilar. Es un embrollo para depurar
            ...
        }
    }
}
dependencies {
    ...
}

Error típico

All libraries must use the exact same version specification (mixing versions can lead to runtime crashes). Found versions 8.3.0, 11.4.2. Examples include com.google.android.gms:play-services-auth:8.3.0 and com.google.android.gms:play-services-base:11.4.2

Esto significa que debo actualizar las versiones de las librerías que son 8.3.0 a la versión 11.4.2, que es más actual. Además debo incluir una librería que falta, y que se cita en el error: com.google.android.gms:play-services-base:11.4.2

Las versiones siempre serán 3 cifras: 11.6.0

Android API

http://developer.android.com/index.html → Develop → Reference

http://developer.android.com/reference/packages.html

Primer proyecto

File → new → Android → Android Proyect → Create new proyect in Workspace → Lo llamamos a_hola_mundo

Esto crea un proyecto Android con un Activity que será el punto de inicio de la aplicación.

Error típico: An SDK Target must be specified → Para solventarlo → window → preferences → Android

Activity

Es una clase java. Presenta su propia interfaz de usuario (ventana).

Es cada una de las pantallas que componen una aplicación.

Uno de los activities es el que lanza la aplicación (lanzador)

Hola Mundo - Activity

Este es el código del Activity que se genera por defecto al crear nuestro proyecto.

		
public class A_holaMundoActivity extends Activity{
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}
		
	

R (resources) es una clase java (ruta gen/R.java) que contiene constantes que apuntan a la ubicación de los recursos utilizados en nuestra aplicación.

R.layout.main contiene la ubicación del XML que contiene la apariencia de nuestra activity. Está accesible desde res/layout/main.xml. En eclipse, será posible modificar dicha ubicación mediante un editor gráfico o mediante código.

Hola Mundo - Layout

Por defecto, la propiedad android:text del main.xml apunta a una variable hello, definida en res/values/string.xml que contiene su valor. También podría haber puesto directamente el texto “Hola Mundo”, en vez de una constante.

	
main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >
<TextView  
    android:layout_width="match_parent" 
    android:layout_height="wrap_content" 
	android:text="@string/hello"

    />
</LinearLayout>

string.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, A_holaMundoActivity!</string>
    <string name="app_name">A_holaMundo</string>
</resources>
	

Unidades de medida

• sp: scale-independent pixels. Es similar a la unidad dp, pero su tamaño variará dependiendo de las preferencias del usuario y de la densidad de la pantalla. Lo utilizarás para los tamaños de textos.
• dp: density-independent pixels. Lo utilizarás para todo lo demás. Un dip es lo mismo que un dp, habitualmente utilizamos el término dp, porque se parece más al término sp. Estas unidades son relativas a una pantalla de 160 dpi(dots per inch); luego un dp equivale a un px en este tipo de pantalla.
• px: pixel
• in: inches (pulgadas). Basadas en el tamaño físico de la pantalla.
• mm: milímetros. Basados en el tamaño físico de la pantalla.
• pt: points. 1/72 de una pulgada.

Ejercicio Layout

Hacer una aplicación con un activity que llame a un layout llamado nuevo_layout.xml que tenga dos cuadros de texto.

En el primero se muestra el texto “Hola Mundo”. Dicho texto será una variable definida en strings.xml. Se mostrará en un tamaño superior al normal.

En el segundo se muestra el texto “Adios Mundo”. Dicho texto estará escrito directamente en la propiedad android:text. Se mostrará en rojo y en negrita.

Probar a introducir otros componentes, modificar sus propiedades y ver el efecto que esto tiene

Crear una interfaz de usuario por código

		
public class InterfazUSuarioActivity extends AppCompatActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TextView texto = new TextView(this);
        texto.setText("Hola Mundo");
        setContentView(texto);
    }
}
		
	

Al instanciar un objeto de la clase TextView le pasamos como parámetro el Activity que se va a encargar de gestionarlo.

La clase Activity es una subclase de Context.

El contexto es una variable que almacena el estado del teléfono (brillo, conectividad, batería...). Un activity y un servicio heredan de Context. Por tanto, también son contextos.

Como la clase InterfazUSuarioActivity es una subclase de Activity, también es de tipo context. Por ello, puedes pasar this como contexto del TextView.

Tipos de layout

• Constraint (restricción) Layout
  Nota: Si tenemos algún elemento con su alto o ancho ocupando toda la pantalla o unas dimensiones demasiado grandes, los elementos desaparecerán por la derecha o el fondo de la pantalla.
• Linear Layout
• RelativeLayout: Los elementos se posicionan en función de los que tienen al lado. Ha sido sustituído por el Constraint Layout
• FrameLayout
  Los elementos se superponen unos con otros. No es un layout típico.
• TableLayout
  Coloca los elementos siguiendo una distribución de tabla
• AbsoluteLayout
  Deprecated

Constraint Layout

Alineas cada vista en función de las que tienen al lado o de la que la envuelve.

Cada vista tiene al menos dos restricciones: horizontal y vertical. Estas restricción está conectada con el layout padre o una línea de guía invisible.

Generalmente, tenderemos a realizar este layout con las herramientas de la interfaz visual de android studio.

Añadiremos las restricciones (constraints) arrastrando y soltando a partir de los puntos azules ubicados en los cuatro puntos cardinales.

Linear Layout (el más frecuente)

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
	<AnalogClock 
		android:layout_width="wrap_content"
		android:layout_height="wrap_content" />
	<CheckBox
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:text="un checkbox" />
	<Button
		android:layout_width="wrap_content"
		android:layout_height="wrap_content" 
		android:text="un botón" />
	<TextView
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:text="un TextView" />
</LinearLayout>

Table Layout

Se utiliza la etiqueta TableRow cada vez que queremos insertar una nueva línea.
Utilizaré el atributo android:stretchColumns="*" para que las celdas ajusten su tamaño hasta alcanzar los límites de la pantalla.

<?xml version="1.0" encoding="utf-8"?>
<TableLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
<TableRow>
	<AnalogClock 
	android:layout_width="wrap_content"
	android:layout_height="wrap_content" />
	<CheckBox
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:text="un checkbox" />
</TableRow>
<TableRow>
	<Button
	android:layout_width="wrap_content"
	android:layout_height="wrap_content" 
	android:text="un botón" />
	<TextView
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:text="un TextView" />
</TableRow>
</TableLayout>

GridLayout

<GridLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
      android:columnCount="2">
<AnalogClock 
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<CheckBox
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/un_checkbox" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content" 
android:text="@string/un_boton" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/un_textview" />
</GridLayout>

Frame Layout (posiciona todos los elementos usando todo el contenedor, sin distribuirlos espacialmente)

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
<AnalogClock 
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<CheckBox
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="un checkbox" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content" 
android:text="un botón" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="un TextView" />
</FrameLayout>

Ejercicio Linear Layout

Utilizaremos un Linear Layout y setearemos su propiedad gravity.

El fichero res/strings.xml ha de tener el siguiente contenido:

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="app_name">Ejercicio Layout</string>
	<string name="pablomonteserin">Pablo Monteserín</string>
	<string name="menu1">Acerca de mí</string>
	<string name="menu2">Galería de videos</string>
	<string name="menu3">Galería de fotos</string>
	<string name="menu4">Contacto</string>
</resources>

Ejercicio TableLayout

Android permite diseñar una vista diferente para la configuración horizontal y vertical.

A partir del ejercicio anterior, crea la carpeta res/layout-land y crea en ella una vista con el mismo nombre que la que está en la carpeta layout.

Para ver la carpeta land recién creada: panel Project → Packages.

Habrá que usar un TableLayout dentro de un LinearLayout. Para que los elementos del TableLayout ocupen todo el ancho de la celda, utilizar el siguiente atributo: android:stretchColumns="*".

Todos los elementos visuales del layout (los layouts, los Buttons y el TextView) deben tener un layout_width y un layout_height.

Ejercicio – strings.xml e internacionalizacion

Android utiliza una lista de sufijos para expresar recursos alternativos. Estos sufijos pueden hacer referencia a la orientación del dispositivo, al lenguaje, la región, la densidad de pixeles, la resolución, etc.

Crea el siguiente fichero en el que traducirás todas las cadenas al inglés:
res/values-en/strings.xml

Para cambiar el idioma en el dispositivo:
Ajustes → Idioma y texto → Seleccionar idioma

Contenido scrollable

Bastará con envolver el Layout dentro de nuestro activity_main.xml por un ScrollView. El ScrollView sólo puede tener un hijo.

Ejercicio Constraint Layout

AndroidManifest.xml

Describe las funcionalidades y los permisos que serán necesarios, etc. de la aplicación.
Para editarlo recurriremos a las vistas xml y no a las vistas gráficas que nos da eclipse.
Las siguientes líneas estarán contenidas en el nodo del activity que se lanzará en primer lugar al arrancar la aplicación:

	
<intent-filter>
	<action android:name="android.intent.action.MAIN" />
      <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
	

Cuando en la consola de trazas obtengo un "Class Not Found Exception":
o el nombre de la clase o el nombre del paquete están mal en el manifest. Lo ideal es que en el manifest la definición del paquete coincida con el paquete raíz de todos los activities.

Si tenemos el siguiente error en las trazas:
android.content.ActivityNotFoundException: Unable to find explicit activity class {com.pablomonteserin/com.pablomonteserin.Second}; have you declared this activity in your AndroidManifest.xml?

Falto declarar la segunda activity. Ponemos la siguiente línea en el AndroidManifest.xml

	
<activity android:name=".Second" />
	

R

Todos los recursos (xml, drawable, etc.) se empaquetan en un archivo R que es una especie de índice de recursos.

android:id="@+id/item2"

La arroba significa que nos estamos refiriendo al archivo de recursos R.
El + significa que estamos añadiendo un nuevo recurso.

Cada vez q realizo un cambio en la estructura de mi proyecto (carpetas, documentos xml, atributos de dichos documentos, etc) android lo comprueba. Si el cambio arrojase un error es probable que dicho error apareciese reflejado en la pestaña Console

Imágenes

Tamaños de imágenes y layouts en función de la pantalla dónde serán reproducidos

res/drawable-mdpi/my_icon.png 		//bitmap for medium density
res/drawable-hdpi/my_icon.png 		//bitmap for high density
res/drawable-xhdpi/my_icon.png 		//bitmap for extra high density

res/layout/my_layout.xml 			//layout for normal screen size (“default”)
res/layout-small/my_layout.xml 		//layout for small screen size
res/layout-large/my_layout.xml 		//layout for large screen size
res/layout-xlarge/my_layout.xml 		//layout for extra large screen size
res/layout-xlarge-land/my_layout.xml 	//layout for extra large in landscape orientation

Ponemos los recursos en estas carpetas y será el sistema el que decida cuál utilizar.

Ejercicio - Cargar una imagen

Debemos copiar la imagen en la carpeta drawable-hdpi.

Cargar la imagen en un ImageView:
Introducimos un objeto de tipo ImageView en el xml y lo vinculamos a la imagen guardada en drawable.

Cargar la imagen en un ImageButton:
Introducimos un elemento de tipo ImageButton en el xml y lo vinculamos a la imagen guardada en drawable.

Cambiar dinámicamente la foto del ImageView anterior:

ImageView iv = findViewById(R.id.imageView1);
iv.setImageResource(R.drawable.cara);

Cargar imagen con esquinas redondeadas

ImageView iv = findViewById(R.id.miFoto);

Bitmap batmapBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.aperturaabductores);
RoundedBitmapDrawable circularBitmapDrawable = RoundedBitmapDrawableFactory.create(getResources(), batmapBitmap);

// option 1 h/t [Chris Banes](https://chris.banes.me/)
circularBitmapDrawable.setCornerRadius(batmapBitmap.getWidth());

// option 2 h/t @csorgod in the comments
circularBitmapDrawable.setCircular(true);


iv.setImageDrawable(circularBitmapDrawable);

Background repeat

Por defecto una imagen se deformará para ocupar las dimensiones del ImageView, en el caso de que la imagen sea mas pequeña. Si lo que queremos es que la imagen se repita:

activity_main.xml<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:background="@drawable/background_repeat"
...

background_repeat.xml<?xml version="1.0" encoding="utf-8"?>
<bitmap xmlns:android="http://schemas.android.com/apk/res/android" 
   android:src="@drawable/icon"
   android:tileMode="repeat"
    />

Consola de trazas

Poner nuestras propias trazas:

		
Log.d("total", cadenaTexto);
	
	

Si quiero mostrar por las trazas un número:

	
Log.d("total", ""+numeroRegistros);
	

Para ver las trazas:
Window → show view → other → logcat, devices (debo seleccionar el dispositivo del que quiero ver las trazas)

AndroidManifest.xml → Debbuggable: true

Ejercicios estilos

Ejercicio - Cambiar dinámicamente el color o la imagen de fondo de un layout

LinearLayout milayout= findViewById(R.id.miLayout); 
milayout.setBackgroundColor(Color.rgb(151, 19, 19)); 

Ejercicio - Poner un degradado a un layout

res/drawable/degradado.xml<?xml version="1.0" encoding="utf-8"?>
<shape
  xmlns:android="http://schemas.android.com/apk/res/android">
	<gradient android:startColor="#FFFFFF"
	android:endColor="#0000FF"
	android:angle="270"/>    
</shape>

En el .java
View mlayout = findViewById(R.id.main_layout);
mlayout.setBackgroundResource(R.drawable.degradado);

Ejercicio - Maquetar un botón

res/drawable/rect.xml
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
	android:shape="rectangle">
	<gradient
		android:startColor="#FFFF0000"
		android:endColor="#80FF00FF"
		android:angle="45"/>
	<!--  Este es el padding para colocar el texto -->
	<padding
		android:left="7dp"
		android:top="7dp"
		android:right="7dp"
		android:bottom="7dp" />		
	<corners android:radius="10dp" />
</shape>

main.xml<Button android:text="Button"
 android:id="@+id/button1"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:background="@drawable/rect" />
<Button android:text="Button"
 android:id="@+id/button1"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" 
 android:background="@drawable/rect" />

Ejercicio – usar colores predefinidos

res/layout/main.xml<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    android:textSize="30dp"
    android:textColor="@color/red"
    />

res/values/colors.xml (también podría modificar un fichero llamado loquesea.xml)
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<color name="red">#ff0000</color>
	<color name="green">#00ff00</color>
	<color name="blue">#0000ff</color>
</resources>

Ejercicio - Cargar las propiedades de un elemento desde un xml

Creamos el xml:
New → Android XML file → what type of resource would you like to create? → Values

res/layout/main.xml
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello" 
    style="@style/code"/>
	

res/values/styles.xml (también podría modificar un fichero llamado loquesea.xml)
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<style name="code" parent="@android:style/TextAppearance">
		<item name="android:textSize">40sp</item>
		<item name="android:typeface">monospace</item>
		<item name="android:textColor">#0000FF</item>
	</style>    
</resources>
	

Ejercicio - crear un estilo que sobrescriba el anterior.

res/layout/loquesea.xml
<TextView 
    android:text="TextView" 
    android:id="@+id/textView1" 
    style="@style/code.red" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content"></TextView>
	

res/values/styles.xml (también podría modificar un fichero llamado loquesea.xml)
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<style name="code" parent="@android:style/TextAppearance">
			<item name="android:textSize">40sp</item>
			<item name="android:typeface">monospace</item>
			<item name="android:textColor">#0000FF</item>
	</style>
	<style name="code.red">
		<item name="android:textColor">#FF0000</item>
	</style>    
</resources>	
	

Ejercicio – Cargar un theme de los que vienen por defecto en android

Para aplicar un theme a toda la aplicación añado la línea en rojo en el AndroidManifest.xml:

<application android:icon="@drawable/icon" android:label="@string/app_name"
android:theme="@style/Base.Theme.AppCompat.Light">

Para aplicarlo a un activity en concreto:

<activity android:name=".AcercaDe"
	android:label="@string/app_name"
	android:theme="@style/Base.Theme.AppCompat.Light"/>

Lo que no hacemos es aplicar el tema en el xml del layout.

No todos los temas son compatibles con todos los activities.

Ejercicio → Cargar mi propio theme

New → Android XML file → what type of resource would you like to create? → Values

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style parent="@android:style/Theme.Dialog" name="myTheme">
    	<item name="android:textColor">#FF0000</item>
    </style>
</resources>

Cargamos el theme creado por nosotros utilizando el código pintado de rojo en el AndroidManifest.xml:

<application android:icon="@drawable/icon" android:label="@string/app_name"
android:theme="@style/myTheme">

Ejercicio

Crear un theme que herede de Theme.Dialog y hacer que toda la aplicación lo implemente.

El tema tendrá los siguientes estilos:

android:textColor="#00FF00"
android:typeface="monospace"

Iconos

Recomendaciones sobre cómo hacer los iconos en Android: http://developer.android.com/guide/practices/ui_guidelines/icon_design.html

Fragments

Es una porción de la interfaz de usuario que puede añadirse o eliminarse forma independiente al resto de elementos de la actividad.

Esto nos permite dividir la interfaz en varias porciones con el fin de diseñar diversas configuraciones de pantalla.

Todo fragment debe tener asociado, además del layout, su propia clase java, que debe extender de la clase Fragment.

onCreateView(), es el “equivalente” al onCreate() de las actividades, y dentro de él es donde normalmente asignaremos un layout determinado al fragment. En este caso tendremos que “inflarlo” (convertir el XML en la estructura de objetos java equivalente) mediante el método inflate() pasándole como parámetro el ID del layout correspondiente, en nuestro caso fragment_listado.

activity_contiene_fragment.xml<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.pablomonteserin.layouts.fragments.RecipienteFragment">

	<fragment class="com.pablomonteserin.layouts.fragments.BlankFragment"
        android:id="@+id/FrgListado"
        android:layout_weight="40"
        android:layout_width="match_parent"
        android:layout_height="60dp" />

</LinearLayout>

BlankFragmentpublic class BlankFragment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.layout_del_fragment, container, false);
    }
    @Override
    public void onActivityCreated(Bundle state) {
        super.onActivityCreated(state);
        TextView tv = getView().findViewById(R.id.elTextViewDelFragment);
        tv.setText("Esto es un fragment");
    }
}

layout_del_fragment.xml<FrameLayout 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"
    tools:context="com.pablomonteserin.layouts.fragments.BlankFragment">

    <!-- TODO: Update blank fragment layout -->
    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="@string/hello_blank_fragment"
        android:id="@+id/elTextViewDelFragment"/>

</FrameLayout>

Navigation Drawer

Cargamos un activity que tendrá un layout que cargará dos componentes:

• El layout en el que se cargarán los fragments.
• El menú de navegación.

<?xml version="1.0" encoding="utf-8"?>
<androidx.drawerlayout.widget.DrawerLayout 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:id="@+id/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:openDrawer="start">

    <include
        layout="@layout/app_bar_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <com.google.android.material.navigation.NavigationView
        android:id="@+id/nav_view"
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:layout_gravity="start"
        android:fitsSystemWindows="true"
        app:headerLayout="@layout/nav_header_main"
        app:menu="@menu/activity_main_drawer" />

</androidx.drawerlayout.widget.DrawerLayout>

Este es el xml del menú de navegación:

activity_main_drawer.xml<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:showIn="navigation_view">

    <group android:checkableBehavior="single">
        <item
            android:id="@+id/nav_home"
            android:icon="@drawable/ic_menu_camera"
            android:title="@string/menu_home" />
        <item
            android:id="@+id/nav_gallery"
            android:icon="@drawable/ic_menu_gallery"
            android:title="@string/menu_gallery" />
        <item
            android:id="@+id/nav_slideshow"
            android:icon="@drawable/ic_menu_slideshow"
            android:title="@string/menu_slideshow" />
        <item
            android:id="@+id/nav_tools"
            android:icon="@drawable/ic_menu_manage"
            android:title="@string/menu_tools" />
    </group>

    <item android:title="Communicate">
        <menu>
            <item
                android:id="@+id/nav_share"
                android:icon="@drawable/ic_menu_share"
                android:title="@string/menu_share" />
            <item
                android:id="@+id/nav_send"
                android:icon="@drawable/ic_menu_send"
                android:title="@string/menu_send" />
        </menu>
    </item>

</menu>

Y el xml del documento en el que se cargarán los datos:

res/layouts/app_bar_main.xml<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout 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=".MainActivity">

    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:theme="@style/AppTheme.AppBarOverlay">

        <androidx.appcompat.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="?attr/colorPrimary"
            app:popupTheme="@style/AppTheme.PopupOverlay" />

    </com.google.android.material.appbar.AppBarLayout>

    <include layout="@layout/content_main" />

</androidx.coordinatorlayout.widget.CoordinatorLayout>

Este xml carga otro xml que es el que finalmente cargará los contenidos.

res/layouts/content_main.xml<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
    app:layout_behavior="@string/appbar_scrolling_view_behavior"
    tools:showIn="@layout/app_bar_main">

    <fragment
        android:id="@+id/nav_host_fragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:defaultNavHost="true"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:navGraph="@navigation/mobile_navigation" />
</androidx.constraintlayout.widget.ConstraintLayout>

Finalmente, el xml de los contenidos:

navigation/mobile_navigation.xml<?xml version="1.0" encoding="utf-8"?>
<navigation 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:id="@+id/mobile_navigation"
    app:startDestination="@+id/nav_home">

    <fragment
        android:id="@+id/nav_home"
        android:name="com.rchampa.examples.navdrawer.ui.home.HomeFragment"
        android:label="@string/menu_home"
        tools:layout="@layout/fragment_home" />

    <fragment
        android:id="@+id/nav_gallery"
        android:name="com.rchampa.examples.navdrawer.ui.gallery.GalleryFragment"
        android:label="@string/menu_gallery"
        tools:layout="@layout/fragment_gallery" />

    <fragment
        android:id="@+id/nav_slideshow"
        android:name="com.rchampa.examples.navdrawer.ui.slideshow.SlideshowFragment"
        android:label="@string/menu_slideshow"
        tools:layout="@layout/fragment_slideshow" />

    <fragment
        android:id="@+id/nav_tools"
        android:name="com.rchampa.examples.navdrawer.ui.tools.ToolsFragment"
        android:label="@string/menu_tools"
        tools:layout="@layout/fragment_tools" />

    <fragment
        android:id="@+id/nav_share"
        android:name="com.rchampa.examples.navdrawer.ui.share.ShareFragment"
        android:label="@string/menu_share"
        tools:layout="@layout/fragment_share" />

    <fragment
        android:id="@+id/nav_send"
        android:name="com.rchampa.examples.navdrawer.ui.send.SendFragment"
        android:label="@string/menu_send"
        tools:layout="@layout/fragment_send" />
</navigation>

res/values/style.xml<resources>
	<style name="AppTheme.NoActionBar">
		<item name="windowActionBar">false</item>
		<item name="windowNoTitle">true</item>
	</style>
	<style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar" />
	<style name="AppTheme.PopupOverlay" parent="ThemeOverlay.AppCompat.Light" />
</resources>

Para que el código funcione, debemos importar las siguientes librerías en gradle:

implementation 'androidx.navigation:navigation-fragment:2.1.0'
implementation 'androidx.navigation:navigation-ui:2.1.0'

Tabs

layout_tabs.xml<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_height="match_parent"
    android:layout_width="match_parent">

    <TabHost android:id="@android:id/tabhost"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <LinearLayout
            android:orientation="vertical"
            android:layout_width="match_parent"
            android:layout_height="match_parent" >

            <TabWidget android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:id="@android:id/tabs" />

            <FrameLayout android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:id="@android:id/tabcontent" >

                <LinearLayout android:id="@+id/tab1"
                    android:orientation="vertical"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent" >

                    <TextView android:id="@+id/textView1"
                        android:text="Contenido Tab 1"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content" />
                </LinearLayout>

                <LinearLayout android:id="@+id/tab2"
                    android:orientation="vertical"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent" >

                    <TextView android:id="@+id/textView2"
                        android:text="Contenido Tab 2"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content" />
                </LinearLayout>
            </FrameLayout>
        </LinearLayout>
    </TabHost>
</LinearLayout>

TabsActivitypublic class TabsActivity extends AppCompatActivity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.layout_tabs);

		Resources res = getResources();

		TabHost tabs=findViewById(android.R.id.tabhost);
		tabs.setup();

		TabHost.TabSpec spec=tabs.newTabSpec("mitab1");

		// Añado dos pestañas a mi sistema de pestañas. La primera ...
		spec.setContent(R.id.tab1);
		spec.setIndicator("", ContextCompat.getDrawable(this,android.R.drawable.ic_btn_speak_now));
		tabs.addTab(spec);

		//... y la segunda
		spec=tabs.newTabSpec("mitab2");
		spec.setContent(R.id.tab2);
		spec.setIndicator("mi casa es tu casa",ContextCompat.getDrawable(this, android.R.drawable.ic_dialog_email));
		tabs.addTab(spec);

		tabs.setCurrentTab(0);
    }
}

OnClick

main.xml
…
<Button android:text="Button"
 android:id="@+id/button1"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:onClick="btnPulsado"/>
...

MainActivity.javapublic void btnPulsado(View v){
	TextView tv = findViewById(R.id.textView1);
	tv.setText("botón pulsado");
}

Clase OnClickListener

Con esto conseguiremos tener solamente una única clase que gestione todos los eventos de click.

public class Main extends AppCompatActivity{
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
        
		Button b = findViewById(R.id.button1);
		b.setOnClickListener(new View.OnClickListener(){

			@Override
			public void onClick(View v) {
				Log.d("traza", "llega");
			}
		});
	}
}

Añadir un nuevo Activity

Botón derecho sobre el paquete → new → Activity → Empty Activity

Esto crea una clase Activity con su método onCreate y su correspondiente referencia en el AndroidManifest.xml.

¿Para qué sirve un Intent?

Para invocar componentes (un Activity, código ejecutándose en segundo plano, et.)

Crear un botón en la primera activity para que cuando pulsemos sobre él vayamos a la segunda

startActivity(new Intent(this, SecondActivity.class));

Activity que hace la llamada. Si sólo ponemos this, se pensará que estamos haciendo referencia a la clase OnClickListener, en lugar de a la clase Main

Hay que registrar el Activity en el AndroidManifest.xml

<activity android:name=".AcercaDe" 
	android:label="@string/app_name">
</activity>

Pasar información de una activity a otra

En el editor visual de layouts de Android, un componente Plain Text corresponde realmente a un EditText en el código fuente.

Main.java
	public final static String TEXTO = "texto";

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}

	public void pasarInfo(View view) {
		final EditText et = findViewById(R.id.editText1);
		Intent intent = new Intent(this, SecondActivity.class);
		intent.putExtra(TEXTO, et.getText().toString());
		startActivity(intent);
	}

SecondActivity.javapublic void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.second);
		TextView tv = findViewById(R.id.textView1);
		tv.setText(getIntent().getExtras().getString(Main.TEXTO));
	}

Menus

Ejercicio - Crear un menú

Un menú contextual es lanzado al pulsar la tecla menú del teléfono.

res/menu/menu.xml
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
	<item android:id="@+id/item1" android:title="Option 1" android:icon="@android:drawable/ic_menu_compass" />
	<item android:id="@+id/item2" android:title="Option 2" android:icon="@android:drawable/ic_menu_call" />    
</menu>

MenuActivity.java
public class MenuActivity extends Activity {
	...
	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.menu, menu);
		return true;
	}

Al ejecutar la aplicación pulsamos el botón de menú para ver los menús.

Ejercicio - Detectar la pulsación de un menú

Añadimos el siguiente código al java anterior:

public boolean onOptionsItemSelected(MenuItem item){
	if(item.getItemId() == R.id.item1){
    	Log.d("opcion", "opcion 1 pulsada");
    }
	return super.onOptionsItemSelected(item);
}

También se podía haber hecho con el método onclick, procesando la información de la siguiente forma:

public void menuPulsado(MenuItem menu){
	...
}

Problema al cambiar la orientación de la pantalla

Al cambiar la orientación se destruyen los componentes visuales y se vuelven a crear, llamando al onCreate.

Podemos solventar los problemas que esto pueda acarrear modificando el nodo <activity> correspondiente del AndroidManifest.xml:

- Para limitar el giro de la aplicación:
android:screenOrientation="portrait"

- Para que no se destruya el activity:
android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize"

Ejercicio – Al pulsar sobre un botón, convertir una imagen en otra

Asignaremos el xml de la animación al imageview usando el atributo src del layout.

MainActivity.javaImageView iv = findViewById(R.id.imageView1);
TransitionDrawable td = (TransitionDrawable) iv.getDrawable();
td.startTransition(1000);

res/drawable/transition.xml<?xml version="1.0" encoding="utf-8"?>
<transition
  xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/steve1"></item>
    <item android:drawable="@drawable/steve2"></item>
</transition>

En el layout, el ImageView deberá tener el siguiente atributo: android:src="@drawable/transition"

Ejercicio

Al pulsar sobre un botón, animarlo utilizando la clase Tween, que se encargará de deformarlo.

MainActivity.java…
Animation anim = AnimationUtils.loadAnimation(this, R.anim.animation);
Button b = findViewById(R.id.button1);
b.startAnimation(anim);

// iv.reverseTransition(1000); // hace la animación en dirección contraria
…

res/anim/animation.xml<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <scale
        android:fromXScale="0.5"
        android:toXScale="2.0"
        android:fromYScale="0.5"
        android:toYScale="2.0"
        android:pivotX="50%"
        android:pivotY="50%"
        android:duration="4000"
        >
    </scale>
</set>

Ejercicio - set de animaciones

	
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
	<scale xmlns:android="http://schemas.android.com/apk/res/android"
	 	android:fromXScale="0.5"
	 	android:toXScale="2.0"
	 	android:fromYScale="0.5"
	 	android:toYScale="2.0"
	 	android:pivotX="50%"
	 	android:pivotY="50%"
	 	android:duration="4000" />
	<rotate android:fromDegrees="0"
		android:toDegrees="180"
		android:pivotX="50%"
		android:pivotY="50%"
		android:duration="20000"
		android:startOffset="2000" />
</set>
	

Detectar el fin de una animación

El activity debe implementar la interfaz AnimationListener.

	
...
questionsPanel_anim.setAnimationListener(this);
questionsPanel.startAnimation(questionsPanel_anim);	
...


public void onAnimationEnd(Animation arg0) {
		if(arg0==questionsPanel_anim){
			pintarPreguntasYRespuestas();
		}
}
	

Animación FrameByFrame

MainActivity.java…
ImageView iv = findViewById(R.id.imageView1);
iv.setBackgrounResource(R.drawable.animation);
AnimationDrawable animation = (AnimationDrawable) iv.getBackground();
animation.start();

res/layout/activity_main.xml<ImageView
    android:background="@drawable/animation"
    ...
/>

res/drawable/animation.xml<animation-list xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/animation_00031" android:duration="30" />
<item android:drawable="@drawable/animation_00032" android:duration="30" />
<item android:drawable="@drawable/animation_00033" android:duration="30" />
…

Qué es una Lista

Una lista en el contexto de Activity es la interfaz gráfica que nos permite navegar por una serie de datos.

Usando RecyclerView

RecyclerView rv =  findViewById(R.id.miLista);
String [] paises = getResources().getStringArray(R.array.countries);
MyAdapter myAdapter = new MyAdapter(this, paises);
rv.setLayoutManager(new LinearLayoutManager(this));
rv.setHasFixedSize(true);
rv.setAdapter(myAdapter);

MyAdapter.javapublic class MyAdapter extends RecyclerView.Adapter<MyAdapter.ViewHolderPais> {

//El ViewHolder es la fila. En el constructor del ViewHolderPlanta accedemos a los objetos
//de la fila mediante código Java
public static class ViewHolderPais extends RecyclerView.ViewHolder {
	TextView tv;
	private View.OnClickListener onItemClickListener;

	public ViewHolderPais(@NonNull View itemView) {
		super(itemView);
		tv = itemView.findViewById(R.id.tv);
	}
}

private String[] paises;
private Context context;

public MyAdapter(@NonNull Context context, String [] paises) {
	this.paises = paises;
	this.context = context;
}

//En el constructor del ViewHolder inflamos el xml
@NonNull
@Override
public ViewHolderPais onCreateViewHolder(@NonNull ViewGroup parent, int position) {
	LayoutInflater layoutInflater = LayoutInflater.from(parent.getContext());
	View row = layoutInflater.inflate(R.layout.simple_row_list,parent,false);
	ViewHolderPais viewHolder = new ViewHolderPais(row);
	viewHolder.itemView.getTag();
	return viewHolder;
}

@Override
public void onBindViewHolder(ViewHolderPais viewHolder, int position) {
	final String pais = paises[position];
	viewHolder.tv.setText(pais);
}

@Override
public int getItemCount() {
	return paises.length;
}
}

res/values/countries.xml<?xml version="1.0" encoding="UTF-8"?>
<resources>
	<string-array name="countries">
		<item name="usa">United States</item>
		<item name="brazil">Brazil</item>
		<item name="russia">Russia</item>
		<item name="egypt">Egypt</item>
		<item name="japan">Japan</item>
	</string-array>
</resources>

Content Provider

Nos permiten acceder a la información de otras aplicaciones incluida en un dispositivo, por ejemplo, a la agenda telefónica.

En un content provider los datos pueden estar almacenados:

• en una base de datos.
• en archivos.
• en una red.

Cómo acceder a los contactos

Para leer los contactos, primero habrá que añadir uno:
Símbolo del teléfono → botón de menú → Add contact.

Añadimos el permiso justo antes del cierre del Manifest:
<uses-permission android:name="android.permission.READ_CONTACTS" />

Obtener los teléfonos

Para recuperar los contactos:private ArrayList getContactos(){
	ContentResolver cr = getContentResolver();
	Cursor contactos = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
	String phoneNo = "";
	ArrayList listaContactos = new ArrayList();
	int n = contactos.getCount();

	if (contactos.getCount() > 0) {
		while (contactos.moveToNext()) {
			String id = contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts._ID));
			String name = contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
			if (Integer.parseInt(contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER))) > 0) {
				Cursor pCur = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,null,
				ContactsContract.CommonDataKinds.Phone.CONTACT_ID+ " = ?", new String[] { id }, null);
				while (pCur.moveToNext()) {
					phoneNo = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
					listaContactos.add(new Contacto(name, phoneNo));
				}
				pCur.close();
			}
		}
	}
	return listaContactos;
}

Para solicitar los permisos de acceso a los contactos:if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){
	if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
		ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.READ_CONTACTS}, MY_PERMISSIONS_REQUEST_READ_CONTACTS);
	}else{
		contactosList = getContactos();
	}
}else{
	contactosList = getContactos();
}

...

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
	switch (requestCode) {
		case MY_PERMISSIONS_REQUEST_READ_CONTACTS: {
			// If request is cancelled, the result arrays are empty.
			if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
				contactosList = getContactos();
			} else {
				// permission denied, boo! Disable the
				// functionality that depends on this permission.
			}
			return;
		}
		// other 'case' lines to check for other
		// permissions this app might request
	}
}

Ejercicio

Recuperar los contactos del teléfono y mostrarlos en un RecyclerView

Preferencias

Las usamos para guardar pequeñas cantidades de información.

Suelen ser datos que una aplicación debe guardar para personalizar la experiencia del usuario, por ejemplo información personal, opciones de presentación, etc.

La información es almacenada en forma clave-valor en ficheros xml, en el dispositivo móvil:
/data/data/paquetejava/shared_prefs/nombre_coleccion.xml

Ver las preferencias del emulador

Para acceder a las shared preferences del dispositivo: View → Tools Windows → → Device File Explorer

/data/data/com.pablomonteserin/shared_prefs/
com.pablomonteserin_preferences.xml

Guardar preferencias

public class Almacenamiento_Pref_Activity extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
		String txt = sp.getString("texto", "valor por defecto");
		Toast.makeText(getApplicationContext(), txt, Toast.LENGTH_LONG).show();
	}
	
	//El siguiente código se ejecuta cuando la aplicación está a punto de terminar
	@Override 
	protected void onPause() {
		super.onPause();
		EditText et = findViewById(R.id.editText);
		SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
		SharedPreferences.Editor sharedPreferencesEditor = sp.edit();
		sharedPreferencesEditor.putString("texto", et.getText().toString());
		sharedPreferencesEditor.commit();
	}
		
	

Si pulso el botón de retroceso volveré al menú principal, pero la información introducida estará disponible la próxima vez que ejecute la aplicación.

XML de preferencias

res/xml/preferences.xml<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <CheckBoxPreference android:key="primero" android:title="Opción 1" android:summary="Descripción opción 1" />
    <CheckBoxPreference android:key="segundo" android:title="Opción 2" android:summary="Descripción opción 2" />
</PreferenceScreen>

public class Preference_activity extends PreferenceActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       	// setContentView(R.layout.preferencias_layout);
        addPreferencesFromResource(R.xml.preferencias_layout);

¿Qué es un fragmento?

Es una parte de una actividad, que tiene su propio ciclo de vida, recibe sus propios eventos de entrada, y que se puede añadir o quitar dinámicamente.

Preferencias con Fragment

public class MainActivity extends AppCompatActivity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		getFragmentManager().beginTransaction()
				.replace(android.R.id.content, new PreferenciasFragment()).commit();
	}

public static class PreferenciasFragment extends PreferenceFragment {
		@Override
		public void onCreate(Bundle savedInstanceState) {
			super.onCreate(savedInstanceState);

			// Make sure default values are applied. In a real app, you would
			// want this in a shared function that is used to retrieve the
			// SharedPreferences wherever they are needed.
			PreferenceManager.setDefaultValues(getActivity(), R.xml.preferences, false);
			// Load the preferences from an XML resource
			addPreferencesFromResource(R.xml.preferences);
		}
	}
}

res/xml/preferences.xmlNos sigue sirviendo el xml de la diapositiva anterior.

build.gradledependencies {
	implementation "androidx.preference:preference:1.0.0-alpha3"

Ejercicio – recuperar las preferencias marcadas en la diapositiva anterior en dos textview en un nuevo Activity

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);

//Dónde "primero" el atributo "key" del elemento <CheckBoxPreference> en el XML.
tv.setText(""+sp.getBoolean("primero", false));

SQLite

Ejecutaremos una vez el siguiente código para que la base de datos aparezca en el file explorer (data → data → nombreDelPaquete → databases)

	
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
        
	//La siguiente línea busca la base de datos. Si la encuentra la abre. si no, la crea
	SQLiteDatabase db = openOrCreateDatabase("nombre_base_datos", MODE_PRIVATE, null);
	db.close();
}
	

Para crear y manipular nuestra base de datos cómodamente usaremos https://sqlitebrowser.org/.

Instalación en ubuntu:

 sudo apt-get install sqlitebrowser

Usaremos el correspondiente fichero de la base de datos que tiene en su interior ceros y unos, no el que se puede exportar y que tiene código xml.

Sqlite - operaciones

//La siguiente línea busca la base de datos. Si la encuentra la abre. si no, la crea
SQLiteDatabase db = openOrCreateDatabase("nombre_base_datos", MODE_PRIVATE, null);
Cursor c = db.rawQuery("SELECT * FROM MyTable", null);
c. moveToFirst();
Log.d("LEE", c.getString(c.getColumnIndex("campo1")));
c.close();
db.close();

Después de hacer una consulta, si quiero leer los resultados de la misma debo llevar el cursor al punto a partir del cual quiero leer. De lo contrario no funcionará.

Operaciones con parámetros

//INSERT
ContentValues nuevoRegistro = new ContentValues();
nuevoRegistro.put("nombre_campo1", "6");
nuevoRegistro.put("nombre_campo2","Pepe");
db.insert("Usuarios", null, nuevoRegistro);

----------------------------------------------------------------------------------------------

//UPDATE
ContentValues valores = new ContentValues();
valores.put("nombre","usunuevo");
db.update("Usuarios", valores, "codigo=6", null);

----------------------------------------------------------------------------------------------

//DELETE
db.delete("Usuarios", "codigo=6", null);
db.execSQL("DELETE FROM invitado WHERE nombre=' pp'");

----------------------------------------------------------------------------------------------

//CONSULTA
Cursor c = db.rawQuery("SELECT * FROM MyTable", null);
//Para recorrer un cursor:
while(c.moveToNext()){
	//No debemos hacer el c.moveToFirst(); o nos saltaremos el primer registro.
	Log.d("LEE", c.getString(c.getColumnIndex("campo1")));
	...

SQLite – precarga base de datos

public class MyApp extends Application {
	@Override
	public void onCreate() {
		super.onCreate();
		File file = this.getDatabasePath("nombre_base_datos");
		if (!file.exists()) {
			file.getParentFile().mkdirs();// Esto crea todas las carpetas para que la ruta a la bd exista. 
			Log.d("paso1", "copiamos la base de datos si no existía antes");
			OutputStream os = null;
			InputStream is = null;
			try {
				is = this.getResources().openRawResource(R.raw.nombre_base_datos);
				os = new FileOutputStream(file);
				byte[] buffer = new byte[1024];
				int length;
				while ((length = is.read(buffer)) > 0) {
					os.write(buffer, 0, length);
				}
				os.flush();
			} catch (Throwable t) {//e.printStackTrace();
			} finally {
				try {
					if (os != null)
						os.close();
				} catch (IOException e) {//e.printStackTrace();
				}
				if (is != null) {
					try {
						is.close();
					} catch (IOException e) {//e.printStackTrace();
}}}}}} //cierre de llaves..	

Para cargarlo desde el manifest debemos modificar el nodo application y añadir el atributo: android:name:

<application
android:icon="@drawable/icon"
android:label="@string/app_name"
android:name=".MyApp"
android:debuggable="false">

Instalar la base de datos con cada actualización de la app

public class MyApp extends Application {
	private boolean hayActualizacion;
	@Override
	public void onCreate() {
		super.onCreate();
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    		int version = prefs.getInt("version", -1);
		try {
			PackageInfo pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
			int posible_nueva_version = pInfo.versionCode;
			if(version<posible_nueva_version){
				hayActualizacion = true;
				SharedPreferences.Editor editor = prefs.edit();
				editor.putInt("version", posible_nueva_version);
				editor.commit();
			}else{
				hayActualizacion = false;
			}	
		} catch (NameNotFoundException e1) {
			e1.printStackTrace();
		}
		if(hayActualizacion){
			...	

Cargar un listview y un spinner con datos

Para cargar un listView con los datos de una lista (objeto de tipo List):

listView.setAdapter(new ArrayAdapter(this,android.R.layout.simple_list_item_1,lista));

Para cargar un spinner, sería un código similar:

spinner.setAdapter(new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,lista));

OnChange de un spinner

Spinner sp = findViewById(R.id.spinner1);
		
sp.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
	public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
		recalcular ();
	
	@Override
	public void onNothingSelected(AdapterView<?> arg0) {
		// TODO Auto-generated method stub
	}
	// add some code here
});

Ejercicio CRUD

Hacer el alta, baja, modificación y consulta de una entidad. Para mostrar los datos usaremos un listview. Para borrar o modificar, usaremos un spinner.

Ejercicio - plantas

Usaremos un RecyclerView para que escuche cuando hacemos click sobre alguna de sus filas.

public void onBindViewHolder(ViewHolderPlanta viewHolder, int position) {
	viewHolder.itemView.setOnClickListener(new View.OnClickListener() {
		@Override
		public void onClick(View v) {
			...
		}
	});
}

startActivity(new Intent(this,InfoActivity.class).putExtra(PLANTA,plantas.get(position)));

Para recoger un Pojo, este debe implementar la interfaz serializable y debemos usar:

Planta planta = (Planta) getIntent().getExtras().getSerializable(MisPlantasActivity.PLANTA);

Ejercicio - plantas II

Añadir un ToggleButton al segundo activity. Al pulsarlo, la planta correspondiente en el activity principal se mostrará pintada de verde. Para ello cambiaremos un campo llamado “is_checked” definido en la base de datos.

Cargar un sonido

MediaPlayer mp = MediaPlayer.create(Audio.this, R.raw.hakunamatata);

Cargar un video

getWindow().setFormat(PixelFormat.TRANSLUCENT);
        VideoView videoHolder = new VideoView(this);
        //if you want the controls to appear
        videoHolder.setMediaController(new MediaController(this));
        Uri video = Uri.parse("android.resource://" + getPackageName() + "/"
                + R.raw.leon);
        videoHolder.setVideoURI(video);
        setContentView(videoHolder);
        videoHolder.start();

Hacer streaming de un video

Habrá que dar permisos de conexión a internet en el:

AndroidManifest.xml<uses-permission android:name="android.permission.INTERNET"/>

String stringUrl = "https://pablomonteserin.com/curso/html5/ex/HakunaMatataItMeansNoWorries.mp3";
try {
	final MediaPlayer mediaPlayer = new MediaPlayer();
	mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
	mediaPlayer.setDataSource(stringUrl);
	mediaPlayer.prepareAsync();
	mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
		@Override
		public void onPrepared(MediaPlayer mp) {
			mediaPlayer.start();
		}
	});
} catch (Exception e) {
	e.printStackTrace();
}

Usar cámara de fotos

public void sacaFoto(View v){
	Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
	startActivityForResult(intent,0);
}

protected void onActivityResult(int requestCode, int resultCode, Intent data){
	super.onActivityResult(requestCode, resultCode, data);
	Bitmap bm = (Bitmap) data.getExtras().get("data");
	iv.setImageBitmap(bm);
}

Alert dialog

AlertDialog.Builder builder = new AlertDialog.Builder(Main.this);
builder.setMessage("Are you sure you want to exit?");
//setCancelable determina si el cuadro de diálogo será cancelable utilizando la tecla de retroceso (BACK key)
builder.setCancelable(false);
builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int which) {
		Main.this.finish();
	}
});
builder.setNegativeButton("No", new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int which) {
		dialog.cancel();
	}
});
AlertDialog alert = builder.create();
alert.show();

ProgressBar Dialog

layout.xml<ProgressBar
	android:layout_width="match_parent"
	android:layout_height="wrap_content"
	android:id="@+id/progressBar"
	style="?android:attr/progressBarStyleHorizontal"/>

<ProgressBar
	android:layout_width="match_parent"
	android:layout_height="wrap_content"/>

 ProgressBar pb = (ProgressBar) findViewById(R.id.progressBar);
pb.setIndeterminate(false);
pb.setProgress(50);

Ejercicio

La barra de progreso que inicialmente estaba a cero debe ir aumentando progresivamente según hacemos click.

Ejercicio - Personal dialog

Cuando haga click sobre un botón, deberá aparecer un cuadro de diálogo personalizado.

Dialog d = new Dialog(PersonalDialog.this);
d.setContentView(R.layout.personal_dialog);
d.setTitle("This is important");
d.show();

Creamos un layout llamado personal_dialog.xml para el dialog.

Toast - notificaciones instantáneas

Ejercicio: al pulsar el botón se muestra el mensaje mergente

Toast.makeText(this, "El texto emergente",Toast.LENGTH_SHORT).show();