Activitats

Creació de primera aplicació Android

L’objectiu d’aquesta activitat és crear una primera aplicació Android i executar-la a l’emulador des de l’Android Studio.

La millor forma de veure el funcionament de la plataforma és amb un petit exemple. En aquest cas crearem la típica aplicació de “Hola, món!”, amb la qual sol iniciar-se la programació amb una nova plataforma. L’aplicació que creareu s’executarà en un emulador d’Android.

Podeu crear un nou projecte des de:

  1. La pantalla principal de l’Android Studio, escollint l’opció Start a new Android Studio project.
  2. Si esteu en una finestra de projecte, des del menú File/New project

Se’ns obrirà un assistent de configuració de projecte, on haurem d’emplenar tres camps: Application name, Company Domain i Project Location.

  • Application name: nom del projecte d’Android Studio, que serà a la vegada el nom de l’aplicació d’Android. Escriviu: “Hola Android”.
  • Company domain: domini de l’empresa, que servirà per a generar el package name juntament amb el nom de l’aplicació. Escriviu: “exemple.com”.
  • Package name: sol ser el domini de l’empresa a la inversa, seguit pel nom de l’aplicació. Aquest és el namespace (l’espai de noms) del paquet on residirà el codi de l’aplicació; segueix les mateixes regles que per als paquets de Java. El nom del vostre paquet ha de ser únic entre tots els paquets instal·lats a Android, per aquest motiu és important fer servir el sistema de noms estàndard de paquets a Java, semblant als noms de domini. L’Android Studio ens suggereix el nom “com.exemple.holaandroid”, però el podem modificar fent clic a l’opció Edit.
  • Project location: estableix la ruta del sistema de fitxers on es guardaran tots els fitxers del projecte.
Figura Paràmetres del projecte

El resultat haurà de ser similar al de la figura.

En el següent pas de l’assistent configurarem la classe de dispositius per als quals habilitarem l’aplicació, i quina versió mínima d’API es requerirà per poder-la instal·lar.

Començarem creant una aplicació per a telèfons i tauletes amb un SDK mínim d’API 10: Android 2.3.3 (Gingerbread) que podrà ser instal·lada en més d’un 99% de dispositius. Si no sabem quina API escollir, fent click a help me choose se’ns mostrarà per cada API el percentatge de dispositius on podrà ser instal·lada i un resum de les novetats de cada versió (vegeu la figura).

Figura Percentatge i novetats en funció de l’API

A la següent pantalla se’ns proposen una sèrie d’activitats predefinides; de moment començarem amb una activitat buida, és a dir, una Blank Activity.

Finalment, a la darrera pantalla de l’assistent haurem de proporcionar la següent informació:

  • Activity Name: nom de la classe de l’activitat. Ha de ser un nom correcte de classe Java. Escriviu: “HolaAndroidActivity”.
  • Layout Name: nom del fitxer XML que contindrà les vistes. Deixeu el que ens proposa.
  • Title: títol de l’activitat. Poseu “Hola Android!”.
  • Menu Resource Name: fitxer que contindrà el menú, deixeu el que ens proposa.
Figura Final de l’assistent

Una vegada emplenats aquests camps (vegeu la figura), feu clic a Finish.

Ja heu creat el projecte d’Android. L’hauríeu de poder veure a la pestanya Project de l’esquerra. Obriu el fitxer “HolaAndroidActivity” que es troba dins d’app/java/com.exemple.holaandroid. Hauria de contenir el següent codi:

  1. package com.exemple.holaandroid;
  2.  
  3. import android.support.v7.app.ActionBarActivity;
  4. import android.os.Bundle;
  5. import android.view.Menu;
  6. import android.view.MenuItem;
  7.  
  8.  
  9. public class HolaAndroidActivity extends ActionBarActivity {
  10.  
  11. @Override
  12. protected void onCreate(Bundle savedInstanceState) {
  13. super.onCreate(savedInstanceState);
  14. setContentView(R.layout.activity_hola_android);
  15. }
  16.  
  17.  
  18. @Override
  19. public boolean onCreateOptionsMenu(Menu menu) {
  20. // Inflate the menu; this adds items to the action bar if it is present.
  21. getMenuInflater().inflate(R.menu.menu_hola_android, menu);
  22. return true;
  23. }
  24.  
  25. @Override
  26. public boolean onOptionsItemSelected(MenuItem item) {
  27. // Handle action bar item clicks here. The action bar will
  28. // automatically handle clicks on the Home/Up button, so long
  29. // as you specify a parent activity in AndroidManifest.xml.
  30. int id = item.getItemId();
  31.  
  32. //noinspection SimplifiableIfStatement
  33. if (id == R.id.action_settings) {
  34. return true;
  35. }
  36.  
  37. return super.onOptionsItemSelected(item);
  38. }
  39. }

Fixeu-vos que la classe hereta d’ ActionBarActivity que és descendent d’Activity. Una activitat és una entitat del programa que es fa servir per realitzar tasques. Una aplicació pot tenir moltes activitats separades, però l’usuari únicament treballarà amb una en cada moment. El mètode onCreate() és cridat pel sistema Android quan s’engega la vostra activitat. És aquí on hauríeu d’incloure tota la inicialització i configuració de la interfície d’usuari.

Fixeu-vos com els elements que hem anat introduint en el procés de creació de l’aplicació a través de les finestres de l’Android Studio s’han aplicat directament en el codi:

Figura

Executeu l’aplicació des de Run/Run ‘app’ o directament amb Mayús+F10. Escolliu l’Android virtual device creat des de l’assistent inicial.

Si l’emulador funciona molt lent mireu de baixar la quantitat de memòria RAM assignada a la màquina virtual des de l’AVD Manager.

Una vegada engegat l’emulador, haureu de veure el dispositiu mòbil amb l’activitat que hem creat (vegeu la figura).

Figura Emulador executant la nostra activitat

Modifiqueu el codi perquè quedi de la següent manera:

  1. package com.exemple.holaandroid;
  2.  
  3. import android.support.v7.app.ActionBarActivity;
  4. import android.os.Bundle;
  5. import android.view.Menu;
  6. import android.view.MenuItem;
  7. import android.widget.TextView; //**
  8.  
  9.  
  10. public class HolaAndroidActivity extends ActionBarActivity {
  11.  
  12. @Override
  13. protected void onCreate(Bundle savedInstanceState) {
  14. super.onCreate(savedInstanceState);
  15. TextView tv = new TextView(this); //**
  16. tv.setText("Hola món!"); //**
  17. setContentView(tv); //**
  18. //setContentView(R.layout.activity_hola_android); //**
  19. }
  20.  
  21.  
  22. @Override
  23. public boolean onCreateOptionsMenu(Menu menu) {
  24. // Inflate the menu; this adds items to the action bar if it is present.
  25. getMenuInflater().inflate(R.menu.menu_hola_android, menu);
  26. return true;
  27. }
  28.  
  29. @Override
  30. public boolean onOptionsItemSelected(MenuItem item) {
  31. // Handle action bar item clicks here. The action bar will
  32. // automatically handle clicks on the Home/Up button, so long
  33. // as you specify a parent activity in AndroidManifest.xml.
  34. int id = item.getItemId();
  35.  
  36. //noinspection SimplifiableIfStatement
  37. if (id == R.id.action_settings) {
  38. return true;
  39. }
  40.  
  41. return super.onOptionsItemSelected(item);
  42. }
  43. }

Vegeu amb detall, en la figura següent, els canvis que hem realitzat en el codi:

Figura

Una interfície d’usuari d’Android està composta per jerarquies d’objectes anomenats Views (vistes). Una vista és un objecte dibuixable que es fa servir com a element en la nostra interfície d’usuari, com pot ser un botó, una imatge o, com en aquest cas, una etiqueta de text. Cadascun d’aquests objectes és una subclasse de la classe View, i la subclasse que es fa servir per treballar amb text és TextView.

En l’exemple hem creat un TextView amb el constructor de la classe, que accepta una instància de la classe Context. Un context és una referència al sistema i facilita serveis per trobar recursos i obtenir accés a les bases de dades i preferències. La classe Activity hereta les propietats de Context, i com que la nostra classe HolaAndroidActivity és una subclasse d’ Activity, també és un Context, i per tant la podem fer servir al constructor (per això cridem el constructor amb this). Una vegada creat, definim el contingut del text amb setText(). Finalment, passem el TextView al mètode setContentView() perquè es mostri com a contingut per a l’activitat de la interfície d’usuari. Si no es crida aquest mètode, no existirà cap interfície d’usuari i el sistema mostrarà una pantalla amb fons blanc.

Podeu depurar una aplicació d’Android quan treballeu amb l’Android Studio de la mateixa manera que depureu qualsevol altra aplicació, és a dir, afegint punts d’interrupció i executant l’aplicació en mode debug. D’aquesta manera podrem veure i seguir el fil d’execució de la nostra aplicació i ens facilitarà la detecció d’errors de programació. A la pàgina https://developer.android.com/tools/debugging/debugging-studio.html trobareu informació de com fer-ho.

El text que es veu a la caixa blanca és el que hem definit al TextView, mentre que el que es veu a la barra gris fosc és el nom de l’aplicació, tal i com es pot veure a la figura.

Podeu descarregar a continuació el codi corresponent a aquesta activitat:

01_HolaAndroid.zip ( 385.3 KB )

Configuracions i perfils

L’objectiu d’aquesta activitat és aplicar distintes configuracions i perfils a l’emulador per tal de comprovar el funcionament de la nostra aplicació en diversos contextos.

De vegades ens pot interessar provar la nostra aplicació en un terminal concret, ja sigui amb una versió anterior d’Android o amb una mida de pantalla concreta, per tal d’avaluar l’experiència de l’usuari. L’Android Studio ens permet tenir, des de l’editor XML, una representació de com es visualitzaria el nostre layout en diferents dispositius i en distintes versions de l’SDK. No obstant això, en ocasions el contingut es genera dinàmicament i amb aquesta representació no en tenim prou.

Seria aconsellable crear diversos emuladors per testejar les nostres aplicacions. Per tal de gestionar els dispositius que ja tenim creats o bé per crear-ne de nous, hem d’accedir a l’AVD Manager des del menú Tools/Android/AVD Manager o directament des de la barra d’eines.

Si fem clic a Create Virtual Device ens apareixerà una llista amb plantilles de dispositius ja existents. També podem crear dispositius nous, clicant el botó New Hardware Profile, o basant-nos en algun d’existent (botó Clone Device).

Si volguéssim crear un dispositiu nou hauríem de definir els següents paràmetres:

  • Nom del dispositiu
  • Mida de la pantalla en polzades
  • Resolució en píxels de la pantalla (horitzontal x vertical)
  • Memòria RAM assignada al dispositiu
  • Entrada: definirem si el dispositiu té botons físics, teclat físic o algun tipus de pad
  • Càmera i sensors: seleccionem les càmeres i sensors disponibles
  • Skin: definim el model de dispositiu que recrearà l’emulador; podem crear-ne de nous o escollir algun dels ja existents

És possible que calgui descarregar els fitxers corresponents des de l’SDK Manager si no ho heu fet abans. Necessitarem descarregar l’SDK Platform i la imatge del sistema: Intel x86 Atom System Image de la versió d’Android corresponent.

Quan ja hem decidit quin dispositiu volem, per exemple, un Nexus One, fem clic a Next i haurem d’escollir quina versió d’Android tindrà. Escolliu Gingerbread 2.3.3 i continueu.

A l’última finestra de l’assistent podrem canviar la configuració del dispositiu seleccionat i la seva representació per pantalla, tot i que caldrà accedir a la configuració avançada (Show advanced settings) per obtenir-ne una vista completa. Així, podrem configurar:

  • Scale: podem canviar la densitat de píxels del dispositiu respecte a la nostra pantalla. L’opció per defecte (Auto) ajusta l’emulador a la nostra pantalla.

  • Orientation: Definim quina serà l’orientació per defecte del dispositiu: portrait o landcape, és a dir: ‘retrat’ o ‘paisatge’. Amb la combinació de tecles Ctrl+F12 podrem canviar de l’una a l’altra.

  • Camera: si el dispositiu té definida alguna càmera (frontal o posterior) configurarem el seu comportament: l’opció Emulated simula una càmera per software, mentre que l’opció WebcamX fa servir un dispositiu de càmera connectat al nostre ordinador.
  • Network: configurem els paràmetres de la xarxa en iniciar l’emulador, pel que fa a la seva velocitat i la seva latència segons el tipus de connexió. Ens servirà per provar les aplicacions en determinades condicions de xarxa, un aspecte molt útil per aquelles aplicacions que tenen una dependència gran de la xarxa.
  • Emulated Performance: ens permet escollir entre utilitzar la GPU (graphic processing unit, unitat de procés gràfic) del sistema, incrementant així el rendiment de la màquina virtual, o guardar una instantània de l’emulador per iniciar la màquina virtual més ràpidament. Per fer servir la GPU del sistema necessitem una versió de l’API superior a la 15.
  • Memory and Storage: definim la quantitat de memòria RAM que tindrà la màquina virtual, la quantitat de memòria RAM de la qual disposarà la màquina virtual de Java (VM heap), així com la quantitat de memòria interna i si disposarà o no (posant el valor a 0 MB) de targeta SD i la seva capacitat.
  • Custom skin definition: establim el model de dispositiu que recrearà l’emulador.
  • Keyboard: si activem aquesta opció haurem de fer servir el teclat de l’ordinador per introduir informació; en cas contrari, apareixerà un teclat virtual en la pantalla del dispositiu.

Si engeguem el nostre emulador una vegada definits tots els paràmetres, visualitzarem una pantalla similar a la de la figura

Figura Emulador Nexus One amb Android 2.3.3

Per tal de controlar els dispositius que no disposen de teclat en pantalla, haurem de fer servir el nostre teclat. Podeu trobar a la Guia del desenvolupador d’Android http://developer.android.com/tools/help/emulator.html la correspondència entre el teclat i els botons en el sistema Android (volum +, volum -, home, back, etc.).

Anar a la pàgina següent:
Exercicis d'autoavaluació