Curso de Android

ANDROID

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

Versiones de Android

http://en.wikipedia.org/wiki/Android_version_history

Guía de instalación

Instalación del JDK:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
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

Layouts

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

Notas:

Para crear un nuevo layout: botón derecha sobre la carpeta res/layout en el panel de estructura de proyecto → new → Layout Resource File

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)

Los elementos se irán apilando horizontal o verticalmente en función del parámetro orientation

<?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>

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" />
…

Descargar imagenes de la animación

ItemList

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

CardView

implementation 'androidx.cardview:cardview:1.0.0'

<androidx.cardview.widget.CardView
	...
	android:layout_margin="4dp"

	app:cardCornerRadius="60dp"
	app:cardElevation="40dp"
	app:cardMaxElevation="60dp"
>

Ejercicio

Utilizar un CardView para maquetar cada una de las filas del contenido cargado con un RecyclerAdapter.

Almacenar info

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 editar un fichero del file explorer (por ejemplo el archivo correspondiente a la base de datos sqlite) debo pulsar el icono correspondiente dentro del panel file explorer (View → Tools Windows → → Device File Explorer). Tendré que acceder a data -> nombre del paquete de la aplicación:
Pull para sacar el fichero seleccionado.
Push para introducir el fichero seleccionado.

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);

Descargar imagenes

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.

Multimedia

Cargar una imagen con la librería picasso

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

dependencies 
	implementation 'com.squareup.picasso:picasso:2.71828'
}

String imageUri = "https://i.imgur.com/tGbaZCY.jpg";
ImageView ivBasicImage = (ImageView) findViewById(R.id.ivBasicImage);
Picasso.get().load(imageUri).into(ivBasicImage);

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();

Enlace a leon.mp4

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);
}

Navigation Drawer

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'

public class MyNavigationDrawer extends AppCompatActivity {

private AppBarConfiguration mAppBarConfiguration;

@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_main_navigation_drawer);
	//toolbar es la barra horizontal superior en la que se encuentra la hamburguesa con el menú de navegación
	Toolbar toolbar = findViewById(R.id.toolbar);
	setSupportActionBar(toolbar);

	// drawer es el layout del activity que contiene el Navigation Drawer y los activities con los que está vinculado
	DrawerLayout drawer = findViewById(R.id.drawer_layout);

	// navigationView es el menú Navigation Drawer
	NavigationView navigationView = findViewById(R.id.nav_view);

	// Debo pasar la id de cada menú al objeto de configuración del navigation drawer
	mAppBarConfiguration = new AppBarConfiguration.Builder(
			R.id.nav_home, R.id.nav_gallery, R.id.nav_slideshow,
			R.id.nav_tools, R.id.nav_share, R.id.nav_send)
			.setDrawerLayout(drawer)
			.build();

	//nav_host_fragment es la id del fragmento que alamcenará los activities de contenido
	NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment);

	//vinculo el navController con su configuración
	NavigationUI.setupActionBarWithNavController(this, navController, mAppBarConfiguration);

	NavigationUI.setupWithNavController(navigationView, navController);
}

@Override
public boolean onSupportNavigateUp() {
	NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment);
	return NavigationUI.navigateUp(navController, mAppBarConfiguration)
			|| super.onSupportNavigateUp();
}
}

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.

activity_main_navigation_drawer.xml<?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">

	<!-- En este componente cargaremos el contenido -->
	<include
		layout="@layout/app_bar_main"
		android:layout_width="match_parent"
		android:layout_height="match_parent" />

	<!-- Este componente es el menú de navegación -->
	<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 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.pablomonteserin.layouts.minavigationdrawer.ui.home.HomeFragment"
        android:label="@string/menu_home"
        tools:layout="@layout/fragment_home" />

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

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

    <fragment
        android:id="@+id/nav_tools"
        android:name="com.pablomonteserin.layouts.minavigationdrawer.ui.tools.ToolsFragment"
        android:label="@string/menu_tools"
        tools:layout="@layout/fragment_tools" />

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

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

HomeFragment.javapublic class HomeFragment extends Fragment {
	public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
	View root = inflater.inflate(R.layout.fragment_home, container, false);
	final TextView textView = root.findViewById(R.id.text_home);
	return root;
}
}

Y el 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>

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>

Dialogs, notifications

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();

Notificaciones

Básica

El código para programar notifiaciones ha cambiado a partir de Android 8.

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
public void lanzarNotificacion(View v){
	NotificationUtils mNotificationUtils;
	if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
		// only for Oreo(8) and newer versions
		mNotificationUtils = new NotificationUtils(this, true);
	}else{
		mNotificationUtils = new NotificationUtils(this, false);
	}
	Notification.Builder nb = mNotificationUtils.getChannelNotification("Titulo", "Mensaje", R.raw.hakunamatata);
	mNotificationUtils.getManager().notify(101, nb.build());
}

public class NotificationUtils extends ContextWrapper {

    private NotificationManager mManager;
    private boolean isAndroid8;
    public static final String ANDROID_CHANNEL_ID = "com.pablomonteserin.ANDROID";
    public static final String ANDROID_CHANNEL_NAME = "ANDROID CHANNEL";

    public NotificationUtils(Context base, boolean isAndroid8) {
        super(base);
        this.isAndroid8 = isAndroid8;
        if(isAndroid8){
           createChannels();
        }
    }

    @TargetApi(26)
    public void createChannels() {
        // create android channel
        NotificationChannel androidChannel = new NotificationChannel(ANDROID_CHANNEL_ID,
                ANDROID_CHANNEL_NAME, NotificationManager.IMPORTANCE_DEFAULT);
        // Sets whether notifications posted to this channel should display notification lights
        androidChannel.enableLights(true);
        // Sets whether notification posted to this channel should vibrate.
        androidChannel.enableVibration(true);
        // Sets the notification light color for notifications posted to this channel
        androidChannel.setLightColor(Color.GREEN);
        // Sets whether notifications posted to this channel appear on the lockscreen or not
		// androidChannel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);
        androidChannel.setLockscreenVisibility(Notification.VISIBILITY_PUBLIC);

        getManager().createNotificationChannel(androidChannel);
    }

    public NotificationManager getManager() {
        if (mManager == null) {
            mManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        }
        return mManager;
    }

    public Notification.Builder getChannelNotification(String title, String body,int sound) {
        Notification.Builder builder;

        if(isAndroid8){
            builder  = new Notification.Builder(getApplicationContext(), ANDROID_CHANNEL_ID);
        }else{
            builder = new Notification.Builder(getApplicationContext());
        }
        builder .setContentTitle(title)
                .setContentText(body)
                .setSmallIcon(android.R.drawable.stat_notify_more)
                .setAutoCancel(true);
        return builder;
    }
}

Ejercicio

Hacer que la notificación muestre una imagen

...
Bitmap aperturaabductoresBitmap = BitmapFactory.decodeResource(getResources(),
                            R.drawable.aperturaabductores);
...
nb.setStyle(new Notification.BigPictureStyle().bigPicture(bitmap));

Notificación que abre un activity

PendingIntent

Es un envoltorio de un Intent que puede necesitar ciertos permisos para ser ejecutado. Si la aplicación dónde se está ejecutando ya tiene esos permisos, envolviendo el Intent con un PendingIntent, podremos hacer uso de dichos permisos.

Intent notificationIntent = new Intent(this, NotificacionesActivityAbierto.class);

PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
...
.setContentIntent(pendingIntent);

Temporizadores

Son aquellas clases que nos permiten programar tareas que se ejecutarán al cabo de un tiempo.

Recogemos 3 grandes tipos:

CounterTimeDown: nos permite ejecutar un evento cada cierto tiempo (siempre que la aplicación esté abierta, si la app está en segundo plano, dará problemas).

CountDownTimer timer = new CountDownTimer(3000, 1000) {
	private int counter;

	public void onTick(long millisUnistilFinished) {
		Log.d("traza", "Se ejecuta el timer");
	}
}.start();

Para cancelarlo:if(isMyServiceRunning(		Servicio.class)){
	CountDownTimerServiceMovil.timer.cancel();
}

private boolean isMyServiceRunning(Class<?> serviceClass) {
	ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
	for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
		if (serviceClass.getName().equals(service.service.getClassName())) {
			return true;
		}
	}
    return false;
}

Servicios

Son códigos que se ejecutan en segundo plano, aunque la aplicación no esté abierta.

Usar CounterTimer como Servicio

Ejemplo de uso de AlarmManagerIntent myIntent = new Intent(this, AlarmReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(this,id, myIntent, 0);

AlarmManager alarmManager = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + delay, pendingIntent);
//alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), delay,pendingIntent);

AlarmReceiver.javapublic class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d("alarma: ", "MEHH");
        Toast.makeText(context, "ALARM!! ALARM!!", Toast.LENGTH_SHORT).show();
    }
}

public class Util {
    public static void scheduleJob(Context context,int time) {
        ComponentName serviceComponent = new ComponentName(context, MovilJobService.class);
        JobInfo.Builder builder = new JobInfo.Builder(0, serviceComponent);
        builder.setMinimumLatency(time * 1000); // wait at least
        builder.setOverrideDeadline(time*1000+5000); // maximum delay
        //builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED); // require unmetered network
        //builder.setRequiresDeviceIdle(true); // device should be idle
        //builder.setRequiresCharging(false); // we don't care if the device is charging or not
        JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
        jobScheduler.schedule(builder.build());
    }
}

Ejercicio yoga con notificaciones

Hacer una aplicación que cada 10 segundos nos vaya indicando un cambio de postura de yoga. Estos avisos serán hechos utilizando notificaciones en las que se oirá el sonido de la postura de yoga y se verá su fotografía. Además, al ir al activity de la aplicación, veremos la misma imagen que se mostraba en la notificación. Las notificaciones se ejecutarán aunque el móvil esté con la pantalla apagada o no estemos el el Activity de la aplicación.

Para ejecutar las notificaciones utilizaremos un servicio:

public class MovilJobService extends JobService {
    private static final String TAG = "SyncService";

    @Override
    public boolean onStartJob(JobParameters params) {
}

Cuando pulsemos un botón con el texto "terminar servicio" en el MainActivity, dejarán de mostrarse notifiaciones. Además, para poder modificar la imagen del Activity principal, haremos declararemos la variable vinculada a su ImageView pública y estática:

Main.javastartService(new Intent(this, CountDownTimerService.class));

Habrá que registrar el servicio en el AndroidManifest.xml

CountDownTimerService.javapublic class CountDownTimerService extends Service {
	public static CountDownTimer timer;
	@Nullable
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
    
	@Override
	public void onCreate() {
		super.onCreate();
		timer = new CountDownTimer(30000, 2000) {//90000
			private int counter;
			public void onTick(long millisUntilFinished) {
				Log.d("traza", "CounterTimer as service");
			}
			public void onFinish() {}
		}.start();
	}
}

Descargar recursos

Solicitar el servicio de wifi y comprobar su estado

AndroidManifest.xml<service android:name="com.pablomonteserin.notifications_and_services.mycountertimerdown_as_service.CountDownTimerService"/>

Habrá que añadir un permiso al AndroidManifest.xml que debe estar a la misma altura que el nodo manifest::

CountDownTimerServicepublic class CountDownTimerService extends Service {
	NotificationManager mNotificationManager;
	public static CountDownTimer timer;

	@Nullable
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}

	@Override
	public void onCreate() {
	super.onCreate();
		mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
		final Service service = this;
		timer = new CountDownTimer(30000, 10000) {
			private int counter;
			public void onTick(long millisUntilFinished) {
			...

Broadcast Receiver

Sirve para eventos del sistema ( batería baja, enchufar cargador, enchufar auriculares, etc. ) puedan conectarse con la aplicación.

botón derecho en el explorador de proyecto -> New -> Other -> Broadcast Receiver
- Exporter: permite que otras aplicaciones se comuniquen con la nuestra. Con esto, podríamos conseguir, por ejemplo, que los datos se compartan cuando nos logueamos en una aplicación y querramos acceder a otra (obviamente, las dos firmadas por el mismo desarrollador).
- Enable: permite que el sistema se conecte con nuesta aplicación cuando lo necesite.

MainActivity.javapublic class MainActivity extends AppCompatActivity {
	public static ImageView iv;
	public static Activity contexto;
	...
	public void cerrarServicio(View v){
		CountDownTimerService.timer.cancel();
		stopService(new Intent(this, CountDownTimerService.class));
	}

<service android:name="com.pablomonteserin.notifications.ejercicio_yoga.CountDownTimerService"/>

Notificaciones push

El código de nuestra clase en Android sería el siguiente. Con este código obtendremos un deviceToken que habrá que pegar a nuestro código PHP. En condiciones normales, este token serán almacenado en la base de datos en el servidor:
```
Servicio.javaIntent bc_intent = new Intent();
bc_intent.setAction("actualizar_foto");
bc_intent.putExtra("idDeLaFoto",R.drawable.torsion);
sendBroadcast(bc_intent);
```

Activity.java//Es necesario registrar un escuchador del broadcasterpublic void onResume(){
	super.onResume();
	IntentFilter intentFilter = new IntentFilter();
	intentFilter.addAction("actualizar_foto");
	registerReceiver(mMessageReceiver, intentFilter);
}
//Cuando el usuario cierre el Activity, dejaremos de escuchar el BroadcastReceiver
public  void onPause(){
	super.onPause();
	unregisterReceiver(mMessageReceiver);
}
private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
		ImageView iv = findViewById(R.id.imagen);
		iv.setImageResource(intent.getExtras().getInt("idDeLaFoto"));
	}
};
	Solicitar el servicio de wifi y comprobar su estado
	
public class Main extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        ConnectivityManager cm = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
        TextView tv =  findViewById(R.id.textView1);
        boolean wifi = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();
        if(wifi)tv.setText("El wifi está activo");
        else tv.setText("El wifi no está activo");
    }
}

Debemos crear un proyecto en firebase. Para ello, podemos loguearnos en el android studio en firebase y crear un nuevo proyecto.
 
Get started by adding Firebase to your app -> Android -> Nos pide los siguientes datos:

Android package name -> Lo obtengo en el build.gradle (del módulo) -> ApplicationId
Descargamos el fichero json. En el pantallazo se nos indica donde colocarlo.
Añadimos los códigos que nos da en el build.gradle (del proyecto) y en el buid.gradle (del módulo)




La siguiente clase tiene dos métodos importantes:

onMessageReceived: gestiona la recepción de las notificaciones push de Firebase.
showNotification: muestra una notificación en el móvil.

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
Con esto, ya podríamos probar nuestra aplicación en firebase llendo a firebase -> Grow -> Cloud Messaging -> Escribimos los datos del mensaje -> Send test message -> Escribimos el token del móvil al que mandamos el mensaje.
Desarrollamos un código php para enviar las peticiones a firebase y que este se las envíe al móvil. Para poder ejecutar el comando composer en la consola, previamnete necesitamos tenerlo instalado. Podemos descargarlo desde la página de composer.
Instalamos las librerías de composer en un proyecto de nuestro servidor Main.javapublic class Main extends AppCompatActivity {
    private MyReceiver receiver = new MyReceiver();

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

        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_POWER_CONNECTED);
        filter.addAction(Intent.ACTION_POWER_DISCONNECTED);
        this.registerReceiver(receiver, filter);
    }

    @Override
    protected void onDestroy() {
        this.unregisterReceiver(receiver);
        super.onDestroy();
    }
}
 MyReceiver.javapublic class MyReceiver extends BroadcastReceiver {

	@Override
	public void onReceive(Context context, Intent intent) {
		String message = "";
		String intentAction = intent.getAction();
		if (intentAction!=null) {
			switch (intentAction) {
				case Intent.ACTION_POWER_CONNECTED:
					message = "Conectado al cargador";
					break;
				case Intent.ACTION_POWER_DISCONNECTED:
					message = "Desconectado del cargador";
					break;
			}
		}
		Toast.makeText(context, message, Toast.LENGTH_LONG).show();
	}
}

AsynTask

Tendremos que tener los siguientes dos permisos configurados:

FirebaseInstanceId.getInstance().getInstanceId().addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
	@Override
	public void onComplete(@NonNull Task<InstanceIdResult> task) {
		if(!task.isSuccessful()){
			Log.w("TOKEN", "error al obtener el token");
			return;
		} else {
			Log.w("TOKEN", task.getResult().getToken());
		}
	}
});

Petición GET con AsynTask

build.gradle (module)dependencies {
...
implementation 'com.google.android.gms:play-services-auth:17.0.0'
implementation 'com.google.android.gms:play-services-base:17.1.0'

implementation 'com.google.firebase:firebase-auth:19.2.0'
implementation 'com.google.firebase:firebase-messaging:20.1.0'

}
apply plugin: 'com.google.gms.google-services'

Ejercicio petición GET con AsynTask

El código UPC que escribimos se lo mandaremos a la url
https://pablomonteserin.com/curso/php/res/miupcsearch.php?upc_code=1234

Para probar podremos utilizar el código:
upcCode=1234

Usaremos el permiso:

public class MyNotificationService extends FirebaseMessagingService {

    @Override
    public void onMessageReceived(@NonNull RemoteMessage remoteMessage) {

        RemoteMessage.Notification notification = remoteMessage.getNotification();
        if(notification!=null){
            String message = notification.getBody();
            showNotification(message);
        }
    }

    @Override
    public void onNewToken(@NonNull String token) {
    }

    private void showNotification(String message){
        Intent intent = new Intent(this, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_ONE_SHOT);
        String channelID = "channel";
        Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, channelID)
                .setSmallIcon(R.drawable.android1)
                .setContentTitle(getString(R.string.app_name))
                .setContentText(message)
                .setAutoCancel(true)
                .setSound(defaultSoundUri)
                .setContentIntent(pendingIntent);

        NotificationManager notificationManager =
                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        // Since android Oreo notification channel is needed.
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(channelID,
                    "Channel human readable title",
                    NotificationManager.IMPORTANCE_DEFAULT);
            notificationManager.createNotificationChannel(channel);
        }

        notificationManager.notify(0 /* ID of notification */, builder.build());

    }
}

Petición POST con AsyncTask

composer require kreait/firebase-php ^4.35.

Procesar un JSON

Si quiero acceder a elementos de un array, usaré, JSONArray, y si quiero acceder a propiedades de un objeto, usaré JSONObject

notificaciones.phprequire __DIR__.'/vendor/autoload.php';
use Kreait\Firebase\Messaging\CloudMessage;
use Kreait\Firebase\Factory;

$factory = (new Factory())->withServiceAccount('firebase-adminsdk.json');
$messaging = $factory->createMessaging();
$deviceToken = "fEC_mu5UsYk:APA91bFl1xyOWhPcqqEeZg8wj0Pm3_zHwTv8dxh5n7dHG_jXK1Liuxe4lFT8vLSCGnWR3JSKmfvv_HWVMRkj1AhlMlwUhgSkWDE2KONWZLxTmdDpi1cT9UoySQpIPZzjAAezgEkq3e4C";

$body = "this is body";
$title = "this is title";
$message = CloudMessage::fromArray([
	'token' => $deviceToken,
	'notification' => array("body"=>$body, "title"=>$title) // optional  
]);
var_dump($messaging->send($message));

Petición GET con Retrofit

Debemos importar las librerías de Retrofit

new MiAsyncTask().execute("https://pablomonteserin.com/curso/php/res/leer-valor.php");
//El primer parámetro es lo que recibe doInBackground
//El segundo parámetro es lo que recibe un método que no estamos utilizando
//El tercer parámetro es lo que devuelve doInBackground (una cookie es un String)

private class MiAsyncTask extends AsyncTask<String, Integer, String> {
	//doInBackground es un método que se ejecuta en el background. 
	//Aquí realizamos operaciones pesadas que pueden durar mucho tiempo dando lugar a una excepción
	//doInBackground no debe tocar nada de la interfaz visual. Estas operaciones serán hechas en onPostExecute
	protected String doInBackground(String... urls) {
		URL url = new URL(urls[0]);
		URLConnection urlConnection = url.openConnection();
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
		String line;
		while ((line = bufferedReader.readLine()) != null){
			content.append(line + "\n");
		}
		bufferedReader.close();
		return content.toString();
	}

	//El método onPostExecute debe recibir lo que devuelve el doInBackground (en este caso, un String)
	protected void onPostExecute(String txt) {
	}
}

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

Petición POST con Retrofit

El código es muy parecido al de la petición GET, pero cambiando el fichero API:

public class AsynTaskPorPOST extends AppCompatActivity {

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

public void hacerPeticion(View v){
	new MiAsyncTask().execute("https://pablomonteserin.com/curso/php/res/peticion-post-android.php","option=3");
}

private class MiAsyncTask extends AsyncTask<String, Integer, String> {

	protected String doInBackground(String... params) {
		StringBuilder content = new StringBuilder();

		try
		{
			URL url = new URL(params[0]);

			HttpURLConnection connection = (HttpURLConnection) url.openConnection();

			connection.setRequestMethod("POST");
			connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
			connection.setRequestProperty("Accept", "*/*");

			connection.setDoOutput(true);
			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream()));
			writer.write(params[1]);
			writer.close();
			connection.connect();

			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
			String line;
			while ((line = bufferedReader.readLine()) != null)
			{
				content.append(line + "\n");
			}
			bufferedReader.close();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		return content.toString();
	}
	protected void onPostExecute(String txt) {
//El método onPostExecute debe recibir lo que devuelve el doInBackground (en este caso, un String)
		Toast.makeText(AsynTaskPorPOST.this, txt,Toast.LENGTH_SHORT).show();
	}
}
}

JSONObject jObject = jObject = new JSONObject(respuesta);
JSONArray jArray = jObject.getJSONArray("results");
ArrayList<String> lista = new ArrayList<String>();
for (int i=0;i<jArray.length();i++) {
	String valor = jArray.get(i).toString();
	JSONObject jObject2 = new JSONObject(valor);
	lista.add(jObject2.getString("name"));
}

build.gradle (module)// Retrofit
api 'com.squareup.retrofit2:retrofit:2.3.0'
api 'com.squareup.retrofit2:converter-gson:2.3.0'

Subida de una imagen de la galería al servidor con Retrofit

Nesitaremos los siguientes permisos en el manifest:

public class GetRequest extends AppCompatActivity{
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_get_request);
	}

	public void hacerPeticion(View v){
		Retrofit builder = new Retrofit.Builder()
			.baseUrl("https://swapi.co/api/")
			.addConverterFactory(GsonConverterFactory.create())
			.build();

		PabloAPI api = builder.create(PabloAPI.class);
		api.peticionGET().enqueue(new Callback<ResponseBody>() {
		
		@Override
		public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
			try {
				String respuesta = response.body().string();
				Log.d("RESPUESTA", respuesta);
				Toast.makeText(getBaseContext(), respuesta, Toast.LENGTH_LONG).show();
				// Procesamos el resultado de la petición...
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		@Override
		public void onFailure(Call<ResponseBody> call, Throwable t) {
			Toast.makeText(GetRequestSimplificada.this, "Error", Toast.LENGTH_SHORT).show();
		}
	});
}
}

SubidaImagen.javapublic class SubirImagen extends AppCompatActivity {
private boolean isAndroid6;
private final int MY_PERMISSIONS_REQUEST_CAMARA = 1;
TextView image_name_tv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_subir_imagen);
image_name_tv = findViewById(R.id.nombreFoto);
if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
isAndroid6 = true;
askPermissionsIfneeded();
}
}
private void askPermissionsIfneeded(){
if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST_CAMARA);
}
}
@Override
public void onRequestPermissionsResult(int requestCode,
String permissions[], int[] grantResults) {
switch (requestCode) {
case MY_PERMISSIONS_REQUEST_CAMARA: {
// If request is cancelled, the result arrays are empty.	
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// permission was granted, yay! Do the
// contacts-related task you need to do.
}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
}
}
public void sacarFoto(View v){
Intent photoPickerIntent = new Intent(Intent.ACTION_PICK);
photoPickerIntent.setType("image/*");
startActivityForResult(photoPickerIntent, 1);
/*Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
startActivityForResult(takePictureIntent, 1);
}*/
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == 1)
if (resultCode == Activity.RESULT_OK) {
Uri selectedImage = data.getData();
String filePath = getPath(selectedImage);
String file_extn = filePath.substring(filePath.lastIndexOf(".") + 1);
image_name_tv.setText(filePath);
if (file_extn.equals("img") || file_extn.equals("jpg") || file_extn.equals("jpeg") || file_extn.equals("gif") || file_extn.equals("png")) {
File file = new File(filePath);
RequestBody requestFile =
RequestBody.create(
MediaType.parse(getContentResolver().getType(selectedImage)),
file
);
MultipartBody.Part body =
MultipartBody.Part.createFormData("sampleFile", file.getName(), requestFile);
String descriptionString = "hello, this is description speaking";
RequestBody description =
RequestBody.create(
okhttp3.MultipartBody.FORM, descriptionString);
RetrofitService retrofitService = RetrofitService.getInstance();
PabloAPI api = retrofitService.getApiProxyServer();
api.uploadFile(description,body).enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
Toast.makeText(SubirImagen.this, "Imagen subida", Toast.LENGTH_SHORT).show();
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
Toast.makeText(SubirImagen.this, "Error", Toast.LENGTH_SHORT).show();
}
});
} else {
//NOT IN REQUIRED FORMAT
}
}
}
public String getPath(Uri uri) {
String[] filePathColumn = { MediaStore.Images.Media.DATA };
Cursor cursor = getContentResolver().query(uri,filePathColumn, null, null, null);
cursor.moveToFirst();
int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
String picturePath = cursor.getString(columnIndex);
cursor.close();
return picturePath;
}
}

PabloAPIpublic interface PabloAPI {
@Multipart
@POST("subida/upload")
Call<ResponseBody> uploadFile(@Part("description") RequestBody description, @Part MultipartBody.Part file);
}

public class RetrofitService {
private static RetrofitService INSTANCE = null;
private static final String BASE_URL = "http://pablomonteserin.com:19139";
private PabloAPI apiService;
// Private constructor suppresses    
private RetrofitService(){
Retrofit builder = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
apiService = builder.create(PabloAPI.class);
}
// creador sincronizado para protegerse de posibles problemas  multi-hilo
// otra prueba para evitar instanciación múltiple
private synchronized static void createInstance() {
if (INSTANCE == null) {
INSTANCE = new RetrofitService();
}
}
public static RetrofitService getInstance() {
if (INSTANCE == null) createInstance();
return INSTANCE;
}
public PabloAPI getApiProxyServer(){
return apiService;
}
}

Servidor nodejs con Expressrouter.post('/upload', function(req, res) {
console.log(req.files);
console.log("amor");
if (!req.files)
return res.status(400).send('No files were uploaded.');
// The name of the input field (i.e. "sampleFile") is used to retrieve the uploaded file
let sampleFile = req.files.sampleFile;
// Use the mv() method to place the file somewhere on your server
sampleFile.mv('/usr/home/pablomonteserin/termine/public/subida/filename.jpg', function(err) {
var path = require("path");
console.log("./ = %s", path.resolve("./"));
console.log("__dirname = %s", path.resolve(__dirname));
if (err){
console.log("adasda")
return res.status(500).send(err);
}
res.send('File uploaded!');
});
});
router.get('/', function(req, res){
res.write(`<html>
<body>
<form ref='uploadForm' 
id='uploadForm' 
action='http://pablomonteserin.com:19139/subida/upload' 
method='post' 
encType="multipart/form-data">
<input type="file" name="sampleFile" />
<input type='submit' value='Upload!' />
</form>     
</body>
</html>`);
res.end();
});

app.jsconst fileUpload = require('express-fileupload');
app.use(fileUpload());

Subida de un fichero al servidor

public void subirFichero(View v){
File file = new File(this.getCacheDir(), "datos.txt");
copyFiletoExternalStorage(R.raw.datos, file.getAbsolutePath());
String mediaType = MimeTypeMap.getSingleton().getMimeTypeFromExtension("txt");
RequestBody requestFile =
RequestBody.create(MediaType.parse(mediaType), file);
MultipartBody.Part body = MultipartBody.Part.createFormData("nameDelObjeto", file.getName(), requestFile);
RetrofitService retrofitService = RetrofitService.getInstance();
PabloAPI api = retrofitService.getApiProxyServer();
api.uploadFile(body).enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
Toast.makeText(MainActivity.this, "Imagen subida", Toast.LENGTH_SHORT).show();
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
Toast.makeText(MainActivity.this, "Error:", Toast.LENGTH_LONG).show();
}
});
}
private void copyFiletoExternalStorage(int resourceId, String pathCacheDir){
try{
InputStream in = getResources().openRawResource(resourceId);
FileOutputStream out = null;
out = new FileOutputStream(pathCacheDir);
byte[] buff = new byte[1024];
int read = 0;
try {
while ((read = in.read(buff)) > 0) {
out.write(buff, 0, read);
}
} finally {
in.close();
out.close();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET, POST, OPTIONS");	
$errors= array();
$file_name = $_FILES['nameDelObjeto']['name'];
$file_tmp = $_FILES['nameDelObjeto']['tmp_name'];
$url = dirname(__FILE__)."/".$file_name;
if (empty($errors)==true) {
if(move_uploaded_file($file_tmp,$url)){
echo "subida con exito";
chmod($url, 0777);
}else{
echo "problema en la subida";
}
}
?>

Mapas

Recomendación

No probar ejercicios que impliquen geolocalización en el emulador. Unos funcionan, otros no, otros funcionan mal, etc.

Geolocalización

La podemos obtener por 3 medios:

GPS: (el más preciso y lento (puede tardar incluso más de un minuto)). 2 metros de error.
Red móvil: El móvil detecta 3 antenas, hace un triángulo (el método se llama triangulación) y detecta la posición (con un margen de error de 20, 50 m...) depende de la distancia con las antenas. En ciudad hay menos error que en el campo. Tarda unos segundos
Wi-Fi: Funciona si estoy conectado a una red WI-FI. El móvil detecta el SSID (nombre de la red) de la wi-fi y accede a una base de datos donde tiene registrada su ubicación.

La geolocalizacion del emulador no funciona correctamente pq no tiene ni gps, ni red movil ni han integrado la geolocalización por wi-fi.
Para falsear la geolocalización del emulador: window-> show view -> other -> emulator control
Habrá que asegurarse de tener el device seleccionado en el momento de pulsar el botón de send.

Habrá que añadir los siguientes permisos:<!--Localización usando la red WI-FI: -->
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<!--Localización usando el GPS -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Location Manager

Vamos a mostrar las coordenadas en un TextView

Tendremos que solicitar permisos al usuario de forma similar a como lo hicimos cuando queríamos acceder a los contactos.

private static final int MY_PERMISSIONS_CODE = 999;
private TextView coordenadas;
private LocationManager locationManager;
private LocationListener listener = new LocationListener() {
public void onLocationChanged(Location location) {
coordenadas.setText("Latitud: " + location.getLatitude() + "Longitud: " + location.getLongitude());
}
@Override public void onStatusChanged(String provider, int status, Bundle extras) {}
@Override public void onProviderEnabled(String provider) {}
@Override public void onProviderDisabled(String provider) {}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mapas_locationmanager);
coordenadas = findViewById(R.id.coordenadas);
locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
checkPermisions();
}
@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
switch (requestCode) {
case MY_PERMISSIONS_CODE: {
if (grantResults.length>0 && grantResults[0]==PackageManager.PERMISSION_GRANTED) {
requestLocation();
} else {
// permission denied, boo! Disable the  functionality that depends on this permission.
}
}
}
}
public void onResume() {
super.onResume();
requestLocation();
}
public void onPause() {
super.onPause();
locationManager.removeUpdates(listener);
}
private void checkPermisions() {
if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED ||
ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this,
new String[]{
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.INTERNET,
},
MY_PERMISSIONS_CODE);
} else {
requestLocation();
}
} else {
requestLocation();
}
}
@SuppressLint("MissingPermission")
private void requestLocation() {
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 500, 0, listener);
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 500, 0, listener);
}

Añadir un mapa

¿Qué es un fragmento?

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

Paso 1: Cargar las librerías

Obtener una Map API Key (modo debug): https://cloud.google.com/console → Seleccionamos en la barra horizontal superior el proyecto actual y se abrirá un panel que nos permitirá crear un nuevo proyecto → Create Project → APIs → go to the api's overview → enable API → Maps SDK for Android → Enable → Credentials → Credenciales en APIs y servicios → Create Credentials → Clave de API → anotamos la API key.

Vista Android → Gradle Scripts → build.gradle (de módulo) → en dependencias añado lo siguiente:

implementation 'com.google.android.gms:play-services-auth:17.0.0' implementation 'com.google.android.gms:play-services-base:17.1.0' implementation 'com.google.android.gms:play-services-maps:17.0.0'

Además, en el layout habrá que añadir el siguiente código que representará el mapa:

<fragment xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/map" android:layout_width="match_parent" android:layout_height="match_parent" class="com.google.android.gms.maps.SupportMapFragment"/>

Paso 2: modificar el AndroidManifest.xml

	<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="AIzaSyDKH-mnui5hMmO3wnTdrmXy4V5IVs6KTR8" />
<meta-data
android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />
</application>
</manifest>

Paso 3: Añadir el mapa en el código Java

public class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
SupportMapFragment mapFragment  = (SupportMapFragment)getSupportFragmentManager().findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
}

Paso 4: Centrar mapa en la posición del usuario y seguirlo

@SuppressLint("MissingPermission")
private void requestLocation() {
Location currentLocation = null;
for(String provider: locationManager.getAllProviders()){
Location aux = locationManager.getLastKnownLocation(provider);
if(aux!=null){
Log.d("traza", "best Provider " + provider);
currentLocation = aux;
break;
}
}
if (currentLocation!=null) {
updateMapaWith(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()));
}
Log.d("traza", "last location " + currentLocation);
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 500, 0, listener);
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 500, 0, listener);
}
private void updateMapaWith(LatLng latLng){
if (googleMap != null) {
CameraPosition camPos = new CameraPosition.Builder()
.target(latLng)   //Centramos el mapa en Madrid
.zoom(19)          //Establecemos el zoom en 19
.bearing(45)       //Establecemos la orientación con el noreste arriba
.tilt(70)          //Bajamos el punto de vista de la cámara 70 grados
.build();
CameraUpdate camUpd = CameraUpdateFactory.newCameraPosition(camPos);
googleMap.animateCamera(camUpd);
}
}

Añadir un marcador

googleMap.addMarker(new MarkerOptions()
.position(new LatLng(41.431725, 2.192188))
.snippet("Tadel Formació")
.title("Centre de formació")
.icon(BitmapDescriptorFactory.fromResource(R.drawable.escudo)));

Ejercicio Sqlite

Hacer una aplicación que utilizando una base de datos SqlLite situe en pantalla 3 puntos, identificados por el logo suministrado. Al pulsar sobre el logo, iremos a una pantalla dónde se mostrará información del enclave pulsado.

Recursos:

Utilizaremos el HashMap tabla para que al hacer click en un marker podamos obtener su id y a continuación pasársela al siguiente activity:

monumentos es un HashMap de objetos Monumento.

@Override
public boolean onMarkerClick(Marker arg0) {
int idMonumento = tabla.get(arg0);			
startActivity(new Intent(this,LugarActivity.class).putExtra(MONUMENTO, monumentos.get(idMonumento)));
return true;
}

Para recibir el monumento:Monumento monumento = (Monumento) getIntent().getExtras().getSerializable(GeolocalizacionCapasActivity.MONUMENTO);

Obtener la ubicación de cierto lugar

String direccion = "Camino de Rubin 2, Gijón";
Geocoder geocoder = new Geocoder(this);  
List<Address> addresses;
addresses = geocoder.getFromLocationName(direccion, 1);
if(addresses.size() > 0) {
double latitude= addresses.get(0).getLatitude();
double longitude= addresses.get(0).getLongitude();
tv.setText("Latitud="+latitude+" Longitud="+longitude);
}

Rutas

Debemos activar la Directions API en la sección API's overview de la Google Developer Console.

También debemos activar la facturación para esta cuenta. Ojo con todo lo que ello conlleva.

MainActivity.javapublic class MainActivity extends AppCompatActivity implements OnMapReadyCallback, TaskLoadedCallback {
private GoogleMap mMap;
private MarkerOptions place1, place2;
Button getDirection;
private Polyline currentPolyline;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rutas);
//27.658143,85.3199503
//27.667491,85.3208583
place1 = new MarkerOptions().position(new LatLng(22.3039, 70.8022)).title("Location 1");
place2 = new MarkerOptions().position(new LatLng(23.0225, 72.5714)).title("Location 2");
new FetchURL(MainActivity.this).execute(getUrl(place1.getPosition(), place2.getPosition(), "driving"), "driving");
SupportMapFragment miMapa = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
miMapa.getMapAsync(this);
}
@Override
public void onMapReady(GoogleMap googleMap) {
mMap = googleMap;
Log.d("mylog", "Added Markers");
mMap.addMarker(place1);
mMap.addMarker(place2);
CameraPosition googlePlex = CameraPosition.builder()
.target(new LatLng(22.7739,71.6673))
.zoom(7)
.bearing(0)
.tilt(45)
.build();
mMap.animateCamera(CameraUpdateFactory.newCameraPosition(googlePlex), 5000, null);
}
private String getUrl(LatLng origin, LatLng dest, String directionMode) {
// Origin of route
String str_origin = "origin=" + origin.latitude + "," + origin.longitude;
// Destination of route
String str_dest = "destination=" + dest.latitude + "," + dest.longitude;
// Mode
String mode = "mode=" + directionMode;
// Building the parameters to the web service
String parameters = str_origin + "&" + str_dest + "&" + mode;
// Output format
String output = "json";
// Building the url to the web service
String url = "https://maps.googleapis.com/maps/api/directions/" + output + "?" + parameters + "&key=AIzaSyBKJ43pjK3x1GQjnO0zaYUwDJHdy5LiooU";
return url;
}
@Override
public void onTaskDone(Object... values) {
if (currentPolyline != null)
currentPolyline.remove();
currentPolyline = mMap.addPolyline((PolylineOptions) values[0]);
}
}

TaskLoadedCallback.javapublic interface TaskLoadedCallback {
void onTaskDone(Object... values);
}

FetchURL.javapublic class FetchURL extends AsyncTask<String, Void, String> {
Context mContext;
String directionMode = "driving";
public FetchURL(Context mContext) {
this.mContext = mContext;
}
@Override
protected String doInBackground(String... strings) {
// For storing data from web service
String data = "";
directionMode = strings[1];
try {
// Fetching the data from web service
data = downloadUrl(strings[0]);
Log.d("mylog", "Background task data " + data.toString());
} catch (Exception e) {
Log.d("Background Task", e.toString());
}
return data;
}
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
PointsParser parserTask = new PointsParser(mContext, directionMode);
// Invokes the thread for parsing the JSON data
parserTask.execute(s);
}
private String downloadUrl(String strUrl) throws IOException {
String data = "";
InputStream iStream = null;
HttpURLConnection urlConnection = null;
try {
URL url = new URL(strUrl);
// Creating an http connection to communicate with url
urlConnection = (HttpURLConnection) url.openConnection();
// Connecting to url
urlConnection.connect();
// Reading data from url
iStream = urlConnection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(iStream));
StringBuffer sb = new StringBuffer();
String line = "";
while ((line = br.readLine()) != null) {
sb.append(line);
}
data = sb.toString();
Log.d("mylog", "Downloaded URL: " + data.toString());
br.close();
} catch (Exception e) {
Log.d("mylog", "Exception downloading URL: " + e.toString());
} finally {
iStream.close();
urlConnection.disconnect();
}
return data;
}
}

DataParser.javapublic class DataParser {
public List<List<HashMap<String, String>>> parse(JSONObject jObject) {
List<List<HashMap<String, String>>> routes = new ArrayList<>();
JSONArray jRoutes;
JSONArray jLegs;
JSONArray jSteps;
try {
jRoutes = jObject.getJSONArray("routes");
/** Traversing all routes */
for (int i = 0; i < jRoutes.length(); i++) {
jLegs = ((JSONObject) jRoutes.get(i)).getJSONArray("legs");
List path = new ArrayList<>();
/** Traversing all legs */
for (int j = 0; j < jLegs.length(); j++) {
jSteps = ((JSONObject) jLegs.get(j)).getJSONArray("steps");
/** Traversing all steps */
for (int k = 0; k < jSteps.length(); k++) {
String polyline = "";
polyline = (String) ((JSONObject) ((JSONObject) jSteps.get(k)).get("polyline")).get("points");
List<LatLng> list = decodePoly(polyline);
/** Traversing all points */
for (int l = 0; l < list.size(); l++) {
HashMap<String, String> hm = new HashMap<>();
hm.put("lat", Double.toString((list.get(l)).latitude));
hm.put("lng", Double.toString((list.get(l)).longitude));
path.add(hm);
}
}
routes.add(path);
}
}
} catch (JSONException e) {
e.printStackTrace();
} catch (Exception e) {
}
return routes;
}
/**
* Method to decode polyline points
* Courtesy : https://jeffreysambells.com/2010/05/27/decoding-polylines-from-google-maps-direction-api-with-java
*/
private List<LatLng> decodePoly(String encoded) {
List<LatLng> poly = new ArrayList<>();
int index = 0, len = encoded.length();
int lat = 0, lng = 0;
while (index < len) {
int b, shift = 0, result = 0;
do {
b = encoded.charAt(index++) - 63;
result |= (b & 0x1f) << shift;
shift += 5;
} while (b >= 0x20);
int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
lat += dlat;
shift = 0;
result = 0;
do {
b = encoded.charAt(index++) - 63;
result |= (b & 0x1f) << shift;
shift += 5;
} while (b >= 0x20);
int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
lng += dlng;
LatLng p = new LatLng((((double) lat / 1E5)),
(((double) lng / 1E5)));
poly.add(p);
}
return poly;
}
}

PointsParser.javapackage com.pablomonteserin.mapas.rutas2;
import android.content.Context;
import android.graphics.Color;
import android.os.AsyncTask;
import android.util.Log;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.PolylineOptions;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class PointsParser extends AsyncTask<String, Integer, List<List<HashMap<String, String>>>> {
TaskLoadedCallback taskCallback;
String directionMode = "driving";
public PointsParser(Context mContext, String directionMode) {
this.taskCallback = (TaskLoadedCallback) mContext;
this.directionMode = directionMode;
}
// Parsing the data in non-ui thread
@Override
protected List<List<HashMap<String, String>>> doInBackground(String... jsonData) {
JSONObject jObject;
List<List<HashMap<String, String>>> routes = null;
try {
jObject = new JSONObject(jsonData[0]);
Log.d("mylog", jsonData[0].toString());
DataParser parser = new DataParser();
Log.d("mylog", parser.toString());
// Starts parsing data
routes = parser.parse(jObject);
Log.d("mylog", "Executing routes");
Log.d("mylog", routes.toString());
} catch (Exception e) {
Log.d("mylog", e.toString());
e.printStackTrace();
}
return routes;
}
// Executes in UI thread, after the parsing process
@Override
protected void onPostExecute(List<List<HashMap<String, String>>> result) {
ArrayList<LatLng> points;
PolylineOptions lineOptions = null;
// Traversing through all the routes
for (int i = 0; i < result.size(); i++) {
points = new ArrayList<>();
lineOptions = new PolylineOptions();
// Fetching i-th route
List<HashMap<String, String>> path = result.get(i);
// Fetching all the points in i-th route
for (int j = 0; j < path.size(); j++) {
HashMap<String, String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
// Adding all the points in the route to LineOptions
lineOptions.addAll(points);
if (directionMode.equalsIgnoreCase("walking")) {
lineOptions.width(3);
lineOptions.color(Color.MAGENTA);
} else {
lineOptions.width(3);
lineOptions.color(Color.RED);
}
Log.d("mylog", "onPostExecute lineoptions decoded");
}
// Drawing polyline in the Google Map for the i-th route
if (lineOptions != null) {
//mMap.addPolyline(lineOptions);
taskCallback.onTaskDone(lineOptions);
} else {
Log.d("mylog", "without Polylines drawn");
}
}
}

Login con Google

Instalación

Tendremos que loguearnos en la consola de Firebase
Crear nuevo proyecto
google-services.json
1. Engranaje de settings -> Project Settings -> Download google-services.json
2. En Android Studio cambiamos el modo de visualización del proyecto a Proyecto.
3. Arrastramos el fichero creado (google-services.json) sobre la carpeta APP.
Pegamos en el build.gradle del módulo y proyecto las líneas que nos indica el asistente de configuración.
Abrimos el fichero Build.gradle del módulo y copiamos el valor del applicationID. Nos vamos a la página de firebase y lo pegamos en: Engranaje de settings -> Project Settings -> Package Name.

Habrá que añadir los siguientes repositorios:

build.gradle (project)allprojects { repositories { maven { url 'https://maven.google.com' } } }

build.gradledependencies { implementation 'com.google.android.gms:play-services-auth:17.0.0' implementation 'com.google.android.gms:play-services-base:17.1.0' implementation 'com.google.android.gms:play-services-maps:17.0.0' ...

Para poder recuperar datos del usuario como la contraseña, debemos ejecutar el siguiente código en nuestro ordenador:
```
$ keytool -genkey -v -keystore my-key.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000
```
y copiar el codigo SHA que genera en Consola de Firebase -> tuerquita de configuración -> Configuración del proyecto -> huella digital del certificado

Configuración

layout.xml<com.google.android.gms.common.SignInButton
android:id="@+id/sign_in_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>

Login.javapublic class MainActivity extends AppCompatActivity implements GoogleApiClient.OnConnectionFailedListener{ 
private GoogleApiClient googleApiClient;
private SignInButton signInButton;
private int SIGN_IN_CODE;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.login_google);
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestEmail() //Esta línea es opcional, por si quiero el mail del usuario
.build();
googleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this, this)
.addApi(Auth.GOOGLE_SIGN_IN_API)
.build();
signInButton = (SignInButton) findViewById(R.id.sign_in_button);
signInButton.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view) {
Intent intent = Auth.GoogleSignInApi.getSignInIntent(googleApiClient);
startActivityForResult(intent,SIGN_IN_CODE);
}
});
}
@Override
public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if(requestCode == SIGN_IN_CODE){
GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
manejaResultado(result);
}
}
private void manejaResultado( GoogleSignInResult result ){
if(result.isSuccess()){
Toast.makeText(this, "Exito en el Login",Toast.LENGTH_SHORT).show();
}else{
Toast.makeText(this, "Error en el Login",Toast.LENGTH_SHORT).show();
}
}

Recuperar los datos del usuario logueado con google

SecondActivity.java@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.login_google_second_activity);
photoimageView1 = findViewById(R.id.photoImageView1);
nombreTextView = findViewById(R.id.nombre);
emailTextView = findViewById(R.id.email);
id = findViewById(R.id.texto);
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestEmail()
.build();
googleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this, this)
.addApi(Auth.GOOGLE_SIGN_IN_API, gso)
.build();
}
public void desloguearse(View v){
}
@Override
protected void onStart() {
super.onStart();
OptionalPendingResult<GoogleSignInResult> opr = Auth.GoogleSignInApi.silentSignIn(googleApiClient);
if(opr.isDone()){
GoogleSignInResult result = opr.get();
manejarResult(result);
}else {
opr.setResultCallback(new ResultCallback<GoogleSignInResult>() {
@Override
public void onResult(@NonNull GoogleSignInResult googleSignInResult) {
manejarResult(googleSignInResult);
}
});
}
}
private void manejarResult(GoogleSignInResult result){
if(result.isSuccess()){
GoogleSignInAccount account = result.getSignInAccount();
nombreTextView.setText(account.getDisplayName());
emailTextView.setText(account.getEmail());
id.setText(account.getId());
}else{
startActivity(new Intent(this, SecondActivity.class));
}
}

Login con Facebook

Iniciamos sesión en developers.facebook.com. La documentación global está en este enlace.
Mis aplicaciones -> Agregar una aplicación
Panel -> Elegir plataforma -> Android -> Añadimos al build.gradle la dependencia que se nos indica
```
compile 'com.facebook.android:facebook-android-sdk:[4,5)'
```

Pegamos Añadimos el facebook id a nuestra aplicación:

res/values/strings.xml<string name="facebook_app_id">1508558065902615</string>

Modificamos el AndroidManifest.xml:

<meta-data android:name="com.facebook.sdk.ApplicationId" android:value="@string/facebook_app_id"/>

Introducimos en la página web los datos que se nos solicitan y que podemos recuperar de nuestra aplicación Android.
Seguimos las instrucciones que se nos indican apra generar un Key Hash.

Creamos una clase que hereda de Application y que tendrá la siguiente línea en el onCreate:

AppEventLogger.activateApp(this)

Draw

Ejercicio - Dibujar un círculo

res/layout/main.xml...
<com.pablomonteserin.Vista android:layout_width="match_parent" android:layout_height="match_parent" />
...

com.pablomonteserin.Vista.javapublic class Vista extends View{
Paint pincel;
int color;
public Vista(Context context){
super(context);
iniciar();
}
public Vista(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
iniciar();
}
public Vista(Context context, AttributeSet attrs) {
super(context, attrs);
iniciar();
}
private void iniciar(){
pincel = new Paint();
//Hay varias formas de definir los colores	
//color = Color.argb(127, 0, 255, 0);
//color = 0x7F00FF00;
color = Color.BLUE;
pincel.setColor(color);
pincel.setStrokeWidth(8);
pincel.setStyle(Paint.Style.STROKE);
}
protected void onDraw(Canvas canvas){
super.onDraw(canvas);
canvas.drawCircle(150, 150, 100, pincel);
}
}

La clase vista debe tener tres constructores:
El primero es para crear la vista desde código. Los otros dos son para inflar la vista llamándola desde un fichero xml.

Hay que procurar no hacer ninguna instancia e incluso tener el mínimo código posible dentro del método onDraw(), ya que será llamado varias veces por segundo y relentizaría la aplicación.

Ejercicio - Dibujar un Path (trazo)

trazo y pincel son dos objetos de las clases Path y Paint respectivamente.

protected void onDraw(Canvas canvas){
super.onDraw(canvas);
trazo.addCircle(150, 150, 100, Path.Direction.CCW);
pincel.setColor(Color.BLUE);
pincel.setStrokeWidth(8);	
pincel.setStyle(Paint.Style.STROKE);
canvas.drawPath(trazo, pincel);
pincel.setStrokeWidth(1);
pincel.setStyle(Paint.Style.FILL);
pincel.setTextSize(20);
pincel.setTypeface(Typeface.SANS_SERIF);
canvas.drawTextOnPath("Pablo Monteserín", trazo, 10, 40, pincel);
}

Ejercicio - Dibujar siguiendo un path II

protected void onDraw(Canvas canvas){
super.onDraw(canvas);
trazo.moveTo(50, 100);
strazo.cubicTo(60, 70, 150, 90, 200, 110);
strazo.lineTo(300, 200);
canvas.drawColor(Color.YELLOW);
pincel.setColor(Color.BLUE);
pincel.setStrokeWidth(8);
pincel.setStyle(Style.STROKE);
canvas.drawPath(trazo, pincel);
pincel.setStrokeWidth(1);
pincel.setStyle(Style.FILL);
pincel.setTextSize(20);
pincel.setTypeface(Typeface.SANS_SERIF);
canvas.drawTextOnPath("Pablo Monteserín", trazo, 10, 40, pincel);
}

trazo y pincel son dos objetos de las clases Path y Paint respectivamente. Sin embargo, no deben ser instanciados dentro del método onDraw(), ya que este es llamado varias veces por segundo y ralentizaría la aplicación.

Ejercicio - Dibujar un rectángulo

protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
pincel.setColor(Color.BLUE);
pincel.setStrokeWidth(8);
pincel.setStyle(Paint.Style.STROKE);
canvas.drawRect(0, 0, 200, 300, pincel);
}

Ejercicio - Dibujar un rectángulo con relleno

protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
pincel.setColor(Color.BLUE);
pincel.setStrokeWidth(8);
pincel.setStyle(Paint.Style.STROKE);
canvas.drawRect(10, 10, 200, 50, pincel);
pincel.setColor(Color.RED);
pincel.setStyle(Paint.Style.FILL);
canvas.drawRect(12,12,198,48, pincel);
}

Recuperar atributos del xml

private void iniciar(Context context, AttributeSet attrs){
pincel = new Paint();
TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.Monteserin_circle);
int color = attributes.getColor(R.styleable.Monteserin_circle_monteserin_color, Color.GREEN);
pincel.setColor(color);
}

res/values/attrs.xml<resources>
<declare-styleable name="Monteserin_circle">
<attr name="monteserin_color" format="color" />
</declare-styleable>
</resources>

Definir el tamaño del Canvas

Por defecto, el tamaño de una vista si no definimos otra cosa, será todo el alto de la pantalla. Por tanto, si ponemos dos elementos seguidos, el segundo no se verá porque el primero ocupará toda la pantalla.

La solución es definir una altura específica al escribir el código en el xml, o sobreescribir el siguiente método en el archivo de la vista:

 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//Estos valores definirán el tamaño de la vista
int desiredWidth = 100;
int desiredHeight = 50;
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
int width;
int height;
//Measure Width
if (widthMode == MeasureSpec.EXACTLY) {
//Must be this size
width = widthSize;
} else if (widthMode == MeasureSpec.AT_MOST) {
//Can't be bigger than...
width = Math.min(desiredWidth, widthSize);
} else {
//Be whatever you want
width = desiredWidth;
}
//Measure Height
if (heightMode == MeasureSpec.EXACTLY) {
//Must be this size
height = heightSize;
} else if (heightMode == MeasureSpec.AT_MOST) {
//Can't be bigger than...
height = Math.min(desiredHeight, heightSize);
} else {
//Be whatever you want
height = desiredHeight;
}
//MUST CALL THIS
setMeasuredDimension(width, height);
}

Ejercicio - Repintar con OnTouchEvent

Al pulsar sobre un rectángulo, este deberá repintarse en una posición diferente.

@Override
public boolean onTouchEvent(MotionEvent event) {
x = event.getX();
y = event.getY();
//Fuerzo el repintado
this.invalidate();
return super.onTouchEvent(event);
}

El relleno del rectángulo crece con un click del ratón


protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
pincel.setColor(Color.BLUE);
pincel.setStrokeWidth(8);
pincel.setStyle(Style.STROKE);
canvas.drawRect(10, 10, getWidth(), 50, pincel);
pincel.setColor(Color.RED);
pincel.setStyle(Style.FILL);
canvas.drawRect(12,12,getWidth()*this.width-3,48, pincel);
}
public void aumentarWidth(){
if(this.width<1){
this.width = (float) (this.width+0.1);
this.postInvalidate();
}
}

Este método fuerza a volver a llamar al método onDraw para que el dibujo se repinte. Si no lo llamamos, el repintado no estará asegurado.

Hacer un juego sencillo

Se trata de un juego en el que un monstruo (una clase que hereda de ImageView) va cambiando de posición en la pantalla y cada vez que pulsamos sobre él aumenta un marcador.

Para realizar una tarea cada x tiempo utilizaremos:

private Handler handler;
...
handler = new Handler();
handler.postDelayed(runnable, 1000);
...
private Runnable runnable = new Runnable() {
@Override
public void run() {
setRandomPosition(iv);
handler.postDelayed(this, 1000);
}
};
public void setRandomPosition(ImageView a1){
int x = random.nextInt(width);
int y = random.nextInt(height);
a1.setX(x);
a1.setY(y);
}

Detectar cuando se ha cargado la vista para recuperar tamaños y posiciones

@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
final View content = getWindow().findViewById(Window.ID_ANDROID_CONTENT);
view_width = content.getWidth()-a1.getWidth();
view_height = content.getHeight()-a1.getHeight()-getStatusBarHeight();
}
public int getStatusBarHeight(){
Rect rectangle= new Rect();
Window window= getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(rectangle);
int statusBarHeight = rectangle.top;
int contentViewTop = window.findViewById(Window.ID_ANDROID_CONTENT).getTop();
int titleBarHeight= contentViewTop - statusBarHeight;
return statusBarHeight+titleBarHeight;
}

Publicar

Publicar la aplicación en Google Play

Eliminamos todas las llamadas a las trazas (Log). Si no lo hacemos, la aplicación funciona pero el usuario de la misma tendría acceso a las trazas mediante logCat.
Android Manifest → Pestaña Application → Debuggable: false
Android Manifest → Pestaña Manifest → Aumentamos “Version code” y “Version Name”, según proceda.
Android Manifest → Pestaña AndroidManifest.xml → Cambiamos el nodo <uses-sdk android:minSdkVersion="8" /> (Buscar infor para saber en función de q)
AndroidManifest.xml → Pestaña Manifest → Exporting → Use the Export Wizard → Next → Create New keyStore Location: ruta en mi equipo dónde almacenaré el certificado.
Las siguientes veces que quiera subir mi aplicación al AndroidMarket.xml utilizaré el keyStore que se me va a proporcionar. Por tanto, es importante no extraviarlo. → Next → El password requerido ahora será el mismo que el de la pantalla anterior. Validity: 25 years (por ejemplo). → Next → Indico la ruta dónde se guardará el fichero .apk del programa. → Finish → El archivo de certificado y el .apk de la aplicación son salvados en las rutas indicadas.
Hago las fotos (resolución 72 pixeles/inch):
- feature.png (1024x500) foto que estará en la androidMarket web.
- promo.png (la misma foto que feature.png, pero con resolución 180x120) foto que estará en la androidMarket en un dispositivo de telefonía móvil.
- icon.png (512x512). El icono de la aplicación y que sustituirá al icon.png que por defecto coloca Android.
  También habrá que salvar el icono de android en las carpetas drawable-hdpi(72x72), drawable-mdpi(48x48), drawable-ldpi(36x36)
Hago un par de pantallazos de la aplicación funcionando: Arranco el emulador → voy a la pantalla de la que quiero sacar el pantallazo → voy a eclipse → window → show view → devices → selecciono el emulador → icono de screen capture
Vamos a https://market.android.com/publish/ y seguimos los pasos indicados.
Cuando lleguemos a una página con dos pestañas (Product details y APK files), debemos entrar en APK files para activar nuestro .apk subido.

Certificado de aplicaciones

Toda aplicación de Android, para poder ser desplegada debe ir firmada con un certificado.

El SDK de Android crea su propio certificado de debug, que será diferente para cada ordenador.

Por tanto si trato de instalar dos aplicaciones desde el mismo ordenador y estas tienen los mismos nombre de paquetes, para android estaré reinstalando la aplicación primera, en vez de instalando una nueva.

Por otro lado, si los certificados son diferentes pero los paquetes son iguales, obtendré un error al desplegar la aplicación.

Error típico – conflicto con el nombre del paquete repetido

Podemos cambiar el nombre del paquete en el AndroidManifest.xml de nuestro proyecto.

Eliminar una aplicación del Android Market

No es posible. Sólo es posible:

Despublicarla (en cuyo caso mantendríamos un conflicto con los nombres de los paquetes en caso de tenerlo con la aplicación que hemos despublicado).
Actualizarla con otra aplicación totalmente diferente. Los nombres de paquetes no deben coincidir.

Ejecutar y debugar una aplicación en el móvil

En el móvil: Ajustes → Aplicaciones → Desarrollo → Marco Depuración de USB.
Debemos tener la pestaña Devices activa (menu Window → Preferences → Show View → Other → Devices). Seleccionamos el device correspondiente a nuestro teléfono móvil (que debe estar conectado al ordenador).

No puedo instalar dos aplicaciones que utilicen los mismos nombre de paquetes.
Para poder hacerlo debo desinstalar la que ya tengo instalada, o cambiar el nombre del paquete.

Desinstalar una aplicación del teléfono móvil desde consola

Habrá que hacerlo cuando hayamos instalado la aplicación y queramos volver a instalarla sobrescribiendo la vieja aplicación.


/android-sdk-linux_x86/platform-tools$ ./adb uninstall com.pablomonteserin