Introducción a Android y mis 25 consejos para los que empiezan en Android

1. Introducción a Android
Y mis 25 consejos para los
que empiezan en Android
MobileCONGalicia, Diciembre 2011
Alberto Alonso Ruibal
alberto.ruibal@mobialia.com
T: @mobialia @albertoruibal

2. Quién soy
Ingeniero de Telecomunicación
System Manager
J2EE Developer
Desarrollador Android @ Mobialia
Mobialia Chess / Internet Chess Club App
Gasolineras España / Connect-4 / Trivial / Slot Racing
MartinVars's RadioMe / Track my Followers
Mi blog: http://www.alonsoruibal.com
Mi empresa: http://www.mobialia.com

3. Estado de las plataformas móviles
(USA)

4. Y por qué Android
● Código abierto
● 550.000 activaciones diarias
● Diversidad de dispositivos, fabricantes...
● Porque tiene detrás a Google

5. Qué necesito para desarrollar
● Un ordenador con Windows, MacOSX o Linux
● Java SDK, y conocimientos de Java
● Android SDK
http://developer.android.com/sdk/index.html
● Eclipse + plugin ADT (es posible utilizar otros
IDEs). Recomiendo el “Eclipse IDE for Java
Developers”
http://www.eclipse.org/downloads/

6. Estructura del proyecto
src/ Código fuente
gen/ Archivos generados a partir de los recursos
assets/ Ficheros a los que va a acceder la aplicación
res/ Carpeta de recursos
drawable/ Imágenes
layout/ Disposición de elementos en pantalla
raw/ Archivos de datos (sonidos por ejemplo)
values/ Definición de textos, colores, estilos, etc
AnroidManifest.xml

7. Componentes de una aplicación
● Actividades: Cada pantalla que se muestra es
una “Actividad”, lo que muestra la actividad es
un “Layout”
● Servicios: Para aplicaciones que necesitan
estar ejecutándose en segundo plano
● Intents: Sistema de comunicación entre
aplicaciones / actividades

8. Las actividades y su ciclo de vida
Cada Actividad es una
clase Java con
métodos estándar que
son llamados en los
distintos cambios de
estado
Hay que definir cada
actividad en el
AndroidManifest.xml

9. Diseñando pantallas: layouts
● Se pueden crear desde código Java o bien
definirlos en un XML (lo recomendado)
● Todos los componentes de las pantallas pueden
ser:
● Viewgroups (cuando pueden tener “hijos”)
● Views
● El editor WYSIWYG incluido
en el ADT ahora funciona
y es usable

10. Los selectores de recursos
● Se le añaden a las carpetas de recursos:
● Por densidad de píxeles: -ldpi -mdpi -hdpi -xhdpi
● Por tamaño de pantalla: -small -normal -large -xlarge
● Por idioma: -es -pt -fr -it ...
● Por orientación: -port -land
● Se pueden combinar varios:
res/drawable-mdpi-es
● El sistema escoge el recurso adecuado en cada
momento, y hace auto-escalado de las imágenes

11. Tamaños de pantalla

12. Densidades de pantalla
HDPI MDPI LDPI
http://developer.android.com/guide/practices/screens_support.html

13. Empaquetado y distribución
● La aplicación se empaqueta en un APK que se
firma con un certificado
● En el Android Market nuestra aplicación
queda identificada con este paquete y este
certificado
● Ojo con perder el certificado o olvidar la
contraseña... no podríamos actualizar la
aplicación

14. Mis 25 consejos
Lo que me habría gustado saber hace dos años...

15. 1# Para qué versión de Android
desarrollar
● Yo recomiendo que las aplicaciones para
móviles sean compatibles con Android 1.6
● Salvo APIs muy específicas (cámara,
bluetooth..) suele llegar
● Y desarrollar usando el SDK de la versión 4,
ICS (por ejemplo la última versión de AdMob
requiere >= 3.2)
● Antes de publicar probar siempre
en un emulador 1.6

16. 2# Diseñar pensando en múltiples
tamaños de pantalla
Y dar siempre soporte a pantallas horizontales

17. 3# Usar estilos en los layouts
● Sistema similar a CSS en web
● Permite reducir drásticamente el tamaño de los XMLs
● Se define el estilo en styles.xml
<style name="WhiteText">
<item name="android:layout_width">wrap_content</item>
<item name="android:layout_height">wrap_content</item>
<item name="android:textStyle">bold</item>
<item name="android:textColor">@color/white</item>
</style>
● Y se usa con “style=”:
<TextView style="@style/WhiteText"
android:text="@string/text1"/>
http://www.alonsoruibal.com/using-styles-on-android-layouts/

18. 4# Usar includes
● Permiten crear componentes que podemos
reutilizar
● Ejemplo, en un layout ponemos:
<include layout="@layout/component"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
● Y definimos en component.xml el layout del
componente incluído
● Herramientas útiles del editor WYSIWYG del
ADT “Extract includes” y “Extract styles”

19. 5# Definir colores y dimensiones
● Definimos los colores en colors.xml
<resources>
<color name="text">#000000</color>
</resources>
● Y las dimensiones en dimens.xml
<resources>
<dimen name="text_size_small">14sp</dimen>
</resources>
● Los usamos desde los layouts con @color/ y @dimen/
<TextView android:layout_width="wrap_content" android:layout_height="wrap_content"
android:textColor="@color/text" android:textSize="@dimen/text_size_small"
android:text="Text" />

20. 6# No bloquear el thread principal
Dentro de una misma actividad:
onCreate() onResume() Handler.handleMessage()
t = new Thread(this) handler.sendEmptyMessage(code);
t.start();
Tarea pesada
● Realizar cualquier operación pesada en un thread separado
● Sólo podemos modificar el interfaz desde el thread principal

21. Si bloqueamos el thread principal...

22. 7# Usar las preferencias
● Forma fácil de almacenar propiedades sencillas
● Pantallas estándard de preferencias, se pueden
definir en XML
http://code.google.com/p/mobialia-wikiplaces/source/browse/trunk/res/layout/preferences.xml
● Para obtener preferencias:
SharedPreferences sharedPref =
PreferenceManager.getDefaultSharedPreferences(this);
boolean booleanValue = sharedPref.getBoolean("booleanValue", true);
int intValue = sharedPref.getInt("intValue", true);
● Truco: usar serialización JSON y luego guardar
en las preferencias

23. 8# Almacenando más datos
● Android integra SQLite DB
● Aunque es sencilla soporta grandes cantidades
de datos (en una aplicación mía hasta 500.000
datos por tabla)
● Si queréis algo parecido a Hibernate, tenéis el
Android Data Framework creado por
@javielinux
http://code.google.com/p/androiddataframework/

24. 9# Usar listviews y adapters
● Forma óptima de mostrar pantallas con muchos datos
● El ListView le pide al Adapter la View a mostrar en el
momento que es necesaria (ahorra memoria)
● Reutilizar views en el Adapter: mejora velocidad de la lista
public View getView(int position, View convertView,
ViewGroup parent) {
LinearLayout ll;
if (convertView != null) {
ll = (LinearLayout) convertView; // Reciclamos!
else {
ll = (LinearLayout) LayoutInflater.from(mContext)
.inflate(R.layout.wikiplaces_adapter,
parent, false);
}

25. 10# Internacionalización con
strings.xml
● Nunca meter cadenas en el código, ponerlas en
res/values con el selector de idioma (values-es,
values-pt...)
● Aplicación web para la traducción: PASTT
http://code.google.com/p/android-php-translator/
● Poner en un único XML las cadenas y los arrays a
traducir
● Crear un XML separado con las cadenas que no
necesitan traducción
● Sitio web con servicio de traducción gratuito
(thx @ilnuska) http://www.getlocalization.com/

26. 11# Pasar datos en el Intent
● Forma de enviar datos de una actividad a otra
(bien de nuestra aplicación o entre aplicaciones)
● En la actividad llamante:
Intent intent = new Intent(this, DemoActivity.class);
Bundle bundle = new Bundle();
bundle.putInt("intValue", 33);
bundle.putBoolean("booleanValue", true);
intent.putExtras(bundle);
startActivity(intent);
● Y en la que recibe los datos (en el onCreate()):
Bundle extras = getIntent().getExtras();
int intValue = extras.getInt("intValue");
boolean booleanValue = extras.getBoolean("booleanValue");

27. 12# Intents útiles ACTION_VIEW
● Abrir el navegador web del sistema:
String uri = "http://www.mobialia.com";
Intent myIntent =
new Intent(android.content.Intent.ACTION_VIEW,
Uri.parse(uri));
startActivity(myIntent);
● Abrir Google Maps Navigation:
String uri = "google.navigation:q=" + lat + "," + lon;
Intent myIntent =
new Intent(android.content.Intent.ACTION_VIEW,
Uri.parse(uri));
startActivity(myIntent);

28. 13# Intents útiles ACTION_SEND
● Share Intent (ACTION_SEND)
String shareText = "texto a compartir";
Intent intent = new Intent(android.content.Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(android.content.Intent.EXTRA_TEXT,
shareText);
startActivity(Intent.createChooser(intent,
getString(R.string.share_choose)));
● Email Intent...

29. 14# Interceptar URLs
● Podemos configurar actividades para que
intercepten determinadas URLs
● Añadimos un intent filter en el
AndroidManifest.xml:
<activity android:name =".MobialiaActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW"></action>
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="android.intent.category.BROWSABLE"/>
<data android:scheme="http" android:host="mobialia.com"/>
</intent-filter>
</activity>

30. 15# Usar el parser JSON
integrado
● Recomiendo usar JSON cuando haya que
obtener datos de un servicio externo
● Android tiene JSONObject y JSONArray para
parsear datos JSON
● Ejemplo de uso en WikiPlacesData.java:
http://code.google.com/p/mobialia-wikiplaces/source/browse/trunk/src/com/mobialia/wikiplaces/WikiplacesData.java
● Y en general antes de implementar algo,
buscar si hay una API o librería que lo hace

31. 17# Vigilar la memoria que
consume la aplicación
● Usar el Allocation Tracker del ADT para
detectar dónde ocupamos memoria
● Cada vez que entra el Garbage Collector
supone una pausa de la aplicación que puede
llegar hasta 100 ó 200 ms
● Esto mata el framerate de cualquier juego
http://developer.android.com/resources/articles/track-mem.html

32. 16# Cuidado al rotar la pantalla
● Cada vez que se rota la pantalla de destruye la
actividad y se vuelve a crear
● El sistema tiene una memoria limitada para
bitmaps, si se agota aparece el error:
Bitmap size exceeds VM budget
● Y suele aparecer en el rotado de pantalla
● Añadir al AndroidManifest.xml
android:configChanges="orientation" y
sobreescribir el método onConfigurationChanged()
(thx @luiskap)
http://www.alonsoruibal.com/bitmap-size-exceeds-vm-budget/

33. 18# Reproducir audio
● Establecer el stream que controlamos con las teclas de
volumen
setVolumeControlStream(AudioManager.STREAM_MUSIC);
● SoundPool: creamos un “pool” de sonidos
private SoundPool soundPool;
private HashMap<Integer, Integer> soundPoolMap;
private void initSounds() {
soundPool = new SoundPool(4, AudioManager.STREAM_MUSIC, 100);
soundPoolMap = new HashMap<Integer, Integer>();
soundPoolMap.put(66, soundPool.load(this, R.raw.click, 1));
}
● Y los vamos reproduciendo bajo demanda
soundPool.play(soundPoolMap.get(66), volume, volume, 1, 0, 1f);
● Para cosas más avanzadas: AudioTrack

34. 19# Crear aplicaciones 3D
● Se utiliza la API de OpenGL ES
● Librerías que facilitan su uso:
● JPCT-AE (Código cerrado)
http://www.jpct.net/jpct-ae/
● Min3D (Muy simple y de código abierto), mi favorita
http://code.google.com/p/min3d/
● Con ambas podemos cargar modelos .3ds, .obj
● Frameworks más complejos y multiplataforma: Unity

35. Un ejemplo de Min3D: Slot Racing

36. 20# Integrar anuncios de AdMob
● Forma fácil de obtener ingresos desde el primer
momento
● Pagan un mes a posteriori a través de Paypal
(a primeros de Diciembre se cobra la publicidad
de Octubre)
● CPMs entre 0,20 - 0,40 USD
● No funciona con apps locales
● Cómo integrarlo:
http://code.google.com/intl/es/mobile/ads/docs/android/
● Tiene House Ads para promoción cruzada

37. 21# Usar Google Analytics
● Las estadísticas de uso son imprescindibles
● Con AdMob ya tenemos estadísticas de uso de la
aplicación
● Obtener el Analytics SDK de:
http://code.google.com/intl/es/mobile/analytics/download.html
● Se registra la aplicación Android como un dominio más
● Ejemplo de uso:
tracker = GoogleAnalyticsTracker.getInstance();
tracker.start("UA-2360573-11", this);
tracker.trackPageView("/main");
tracker.dispatch();
tracker.stop();

38. 22# Publicar en el Android Market
● Sólo por 25 USD (un sólo pago)
● Cuidado con el certificado
● Aplicar IVA a las ventas en Europa, para
más temas fiscales:
http://www.alonsoruibal.com/vender-en-android-market-desde-espana/
● Los markets alternativos...
¡no funcionan!

39. 23# Implementar compras dentro
de la aplicación
● Las aplicaciones que obtienen más ingresos
usan compras dentro de la aplicación
http://developer.android.com/guide/market/billing/billing_overview.html
● Es complicado de implementar pero hay una
librería desarrollada por Robot Media
(@hpique) que lo simplifica:
https://github.com/robotmedia/AndroidBillingLibrary

40. 24# Usar el servicio de licencias
del Android Market
● Permite proteger nuestra aplicación contra la
piratería
● Sólo funciona en dispositivos con Android
Market
● Al integrarlo sólo podemos vender la app en en
Android Market, para markets alternativos hay
que adaptarla
● A veces falla...
http://developer.android.com/guide/publishing/licensing.html

41. 25# Dar soporte a los usuarios
● Ocupa el 25% de mi tiempo de trabajo
● Parte esencial del ciclo de vida de la aplicación:
● Detección de errores
● Consejos para mejoras
● Mejora visibilidad, ratings de los usuarios, etc
● En general la actualización frecuente de la
aplicación mejora el posicionamiento en el
Market

42. Dónde aprender más (I)
● http://developer.android.com/index.html
● http://android-developers.blogspot.com/
● http://www.guidetotheappgalaxy.com/
● http://stackoverflow.com
● http://androcode.com (@JMPergar @breogangf @kix2902)

43. Dónde aprender más (II)
Desarrollé la aplicación WikiPlaces como ejemplo para
LabAndroid Málaga. Esta aplicación contiene varios ejemplos
de cómo hacer muchas cosas comunes en Android
● Pantalla inicial con un Dashboard
● Crear pantallas de preferencias y obtener preferencias
● Usar la API de Google Maps API (incluyendo overlays) y la
Location API para obtener la ubicación
● Usar servicios JSON externos
● Listas y adapters
● Lanzar aplicaciones externas con Intents
● Integración con AdMob para mostrar anuncios
http://www.mobialia.com/labandroid

44. Dudas, preguntas...
Gracias por vuestra atención!
Alberto Alonso Ruibal
alberto.ruibal@mobialia.com
http://www.mobialia.com
T: @mobialia @albertoruibal