Estudi d'entorns de programació per a...
81
Estudi d'entorns de programació per a Android. TITULACIÓ: Enginyeria Tècnica Industrial en Electrònica Industrial AUTORS: Sergi Domingo Porqueras . DIRECTORS: Ernest Gil Dolcet . DATA: Setembre / 2015.
Transcript of Estudi d'entorns de programació per a...
Estudi d'entorns de programació per a Android.
TITULACIÓ: Enginyeria Tècnica Industrial en Electrònica Industrial
AUTORS: Sergi Domingo Porqueras .
DIRECTORS: Ernest Gil Dolcet .
DATA: Setembre / 2015.
2
Dedicatòria:
Li dedico al meu avi, en pau descansi, i al meu fill. Entremig d’ells hi han algunes
generacions però també hi ha un fil conductor, en comú.
3
Agraïments:
Pricipalment agraeixo la infinita paciència del meu director de projecte, l’Ernest Gil i
a la meva dóna per el seu suport incondicional en tot moment. També, i com no, als meus
pares perquè fa molt de temps em van poder donar aquesta educació Universitària.
4
Figura 1. Logotip marca Android
Resum:
Android és un sistema operatiu de codi lliure
creat de la mà de Google i utilitzat principalment en
equips mòbils tàctils, bàsicament telèfons
intel·ligents i tauletes. En els darrers anys, aquest
sistema operatiu ha incrementat exponencialment la
seva participació en el mercat, convertint-se en una
de les plataformes líders en vendes d'equipaments i
comptant amb la major quantitat d’aplicacions
disponibles per a la seva descàrrega, al voltant del
milió d’aplicacions amb més de 50.000 milions de
descarregues.
D'acord amb l’exposat anteriorment, és clar,
que el desenvolupament d'aplicacions en Android
s'ha convertit en un dels camps de major interès per a
petites i grans empreses, les quals busquen tenir un
paper rellevant en aquest industria emergent.
És per aquesta raó, i en vista de l'àmplia oferta d'alternatives de programació i
d’entorns de treball existents en el mercat, que aquest treball intenta oferir una llista d’un
gran nombre del diferents marcs de programació que permeten desenvolupar aplicacions
sota aquest sistema operatiu, destacant l'abast i les limitacions de cadascun d’ells, i
brindant així, a tots els interessats, una guia bàsica de referència a l'hora de prendre la
decisió per escollir quina alternativa és la que s'adapta millor a les seves necessitats.
En primer lloc, intenta realitzar un anàlisi bàsic i general de moltes de les alternatives
diferents existents al mercat per a la programació d’aplicacions en Android, definint quins
llenguatges de programació utilitzen (Java, HTML, etc.) i algunes de les facilitats i
inconvenients que ofereixen alhora de dur a terme el desenvolupament d'aplicacions,
segons sigui l’objectiu d’aquestes o altres factors determinats.
Alhora, es seleccionen quatre de les alternatives més rellevants segons l’ús i es
realitza un estudi més detallat de les mateixes (Entorns natius: Android Studio/Eclipse,
jQuery Mobile, PhoneGap i App Inventor) en el qual s'analitza quins són els elements i
components als que es poden accedir des de cadascun dels entonrs, i quin d'ells és
recomanable utilitzar depenent de la categoria a la qual pertany l'aplicació que es vol fer i
els coneixements previs de què disposa el desenvolupador.
Com a resultat del treball, els desenvolupadors interessats tenen la facilitat de triar
l'alternativa de programació en Android que els garantirà el millor resultat amb el menor
esforç possible.
Més específicament, s’aprofundeix en l’entorn natiu, mostrant els procediments
d’instal·lació aquests Frameworks, tant del paquet Andoird Studio i com els diferents
paquets per l’ús de l’IDE Eclipse. Posteriorment, també s’estudia com s’estructura un
projecte per el desenvolupament d’una aplicació en aquests entorns esmentats i finalment
és crea una aplicació de comunicació bàsica a traves del Bluetooth, per intentar posar en
pràctica els conceptes teòrics explicats prèviament i mostra la forma de treball que utilitzen
aquets entorns.
5
Figura 1. Logotip marca Android
Resumen
Android es un sistema operativo de código
abierto creado por Google y utilizado principalmente
en equipos móviles táctiles, especialmente en
teléfonos inteligentes y tabletas. En los últimos años
este sistema operativo ha incrementado de forma
exponencial su participación en los mercados,
convirtiéndose en una de las plataformas líder en
ventas de equipamientos y que cuenta con el mayor
número de aplicaciones disponibles para su descarga,
aproximadamente un millón de aplicaciones, con
más de 50.000 millones de descargas.
De acuerdo con lo expuesto, es normal que el
desarrollo de aplicaciones para Android, se haya
convertido en uno de los campos con mayor interés,
tanto para pequeñas empresas como para grandes,
que buscan ocupar un sitio relevante en esta industria tan emergente.
Es por esta razón, y en vista de la amplia oferta de alternativas de desarrollo y
entornos de trabajo existentes en el mercado, que este trabajo intenta ofrecer una lista de
algunos de los distintos marcos de programación que permiten el desarrollo de aplicaciones
bajo este sistema operativo, destacando el alcance y las limitaciones de cada uno de estos,
y brindando así, a todos los interesados una guía básica de referencia a la hora de tomar
decisiones para escoger cual de las alternativas disponibles se adapta mejor a sus
necesidades.
En primer lugar, se realiza un análisis básico i general de muchas de las alternativas
distintas existentes en el mercado para la programación de aplicaciones en Android,
definiendo que lenguajes de programación utilizan (Java, HTML, etc…) i las facilidades e
inconvenientes que ofrecen en el momento de llevar a cabo desarrollos de aplicaciones,
según sea el objetivo de estas u otros factores también determinantes, etc.
A la vez, se seleccionan cuatro de las alternativas más relevantes básicamente por su
uso (entorno nativo, jQuery Mobile, PhoneGap i App Inventor), y se realiza un estudio más
detallado, en el que se analizan los elementos y componentes específicos a los que se
pueden acceder en cada uno de los distintos Frameworks y cuál de ellos es más
recomendable utilizar según la categoría a la que pertenece la aplicación que se quiere
desarrollar y los conocimientos previos de que dispone el desarrollador.
Como resultado de este trabajo, los desarrolladores interesados disponen de
herramientas para escoger la alternativa de programación para aplicaciones en Android que
les garantizará un mejor resultado con un esfuerzo más controlado.
Más específicamente, también se profundiza en el entorno nativo, mostrando los
procesos de instalación de estos entornos, tanto para el paquete de Android Studio como
para los distintos paquetes que conforman el framewrok Eclipse. Posteriormente también
se estudia cómo se estructura de un proyecto para el desarrollo de una aplicación en estos
entornos citados y finalmente se muestra el proceso de creación de una aplicación básica
de comunicación a través de la característica Bluetooth, que pretende poner en práctica
toda la información teórica previamente explicada así como la forma de trabajar en dichos
entornos.
6
Abstract
Android is an open source operating system created by Google which is used mainly
in mobile touch devices, especially smart and tablets. In last year’s, this operating system
has exponentially increased their market shares, becoming one of the leading platforms in
sales of equipment and having the highest number of applications available for download,
approximately one million applications and more than 50.000 millions of downloads.
According to the above, it is normal, that the applications development for Android
has become one of the most interesting fields for small and large companies, who seek to
occupy an important place in this emerging industry so.
It is for this reason, and in view of the wide range of development alternatives i
existing work environments in the market, this paper attempts to provide a list of some of
the various programming frameworks that enable the development of applications under
this operating system, highlighting the scope and limitations of each of these, and thus
providing to all stakeholders a roadmap of reference when making decisions to choose
which of the alternatives is best suited to your needs.
First, a basic and generic analysis of many of the existing alternatives on the market
for Android application programming is done, in which are defined programming
languages (Java , HTML , etc ... ) some benefits and inconvenient that offer in application's
development, depending on the purpose of these applications or other determinants.
At the same time, four of the most important alternatives, primarily by his use (native
environment: Android Studio and Eclipse, jQuery Mobile, PhoneGap and MIT App
Inventor) are selected, and a more detailed study is done, in which specific elements and
components are analyzed, can be accessed and which of the different Frameworks is better
to use depending on the application category you want to develop and prior knowledge
available to the developer belongs.
As a result of this work, interested developers have tools to choose between
alternative frameworks programming Android applications that will guarantee a better
result with a more controlled effort.
More specifically, it delves into the native framework, where showing the process of
installing these environments for both Android Studio package to the various packages that
make up the Eclipse framework. Later also it studies the project structure for the
development of an application in these aforementioned environments and finally the
process of creating a basic communication application via the Bluetooth feature, which
aims to put into practice all the theoretical information which is displayed previously
explained, as well as, how is to work in such environments.
7
Taula de contingut:
Dedicatòria: ..............................................................................................................2
Agraïments: ..............................................................................................................3
Resum: .....................................................................................................................4
Resumen ...................................................................................................................5
Abstract ....................................................................................................................6
1 Índex d’il·lustracions: ..................................................................................... 10
2 Introducció: .................................................................................................... 12
3 Propòsit del projecte: ...................................................................................... 15
4 Justificació ..................................................................................................... 15
5 Objectius ........................................................................................................ 15
5.1 Objectiu general: ..................................................................................... 15
5.2 Objectius específics: ................................................................................ 15
6 Limitacions. ................................................................................................... 16
7 Abast .............................................................................................................. 16
8 Base de coneixements: ................................................................................... 17
8.1 Tipologia de les Aplicacions mòbils: ....................................................... 17
8.1.1 Aplicació Nativa: ................................................................................. 17
8.1.2 Aplicació Web o WebApp: .................................................................. 18
8.1.3 Aplicacions híbrides: ........................................................................... 19
9 Arquitectura lògica del Sistema Operatiu Android. ......................................... 20
9.1 Model de Capes de l’arquitectura Android. .............................................. 20
9.1.1 Kernel de Linux o nucli de Linux:........................................................ 21
9.1.2 Capa de Llibreries o capa nativa: ......................................................... 21
9.1.3 Base de funcionament de la màquina virtual Dalvik. ............................ 22
9.1.4 Framework per aplicacions: ................................................................. 23
9.1.5 Capa d’aplicacions: .............................................................................. 23
10 Marc referencial ............................................................................................. 24
10.1 Entorns o Frameworks de programació. ................................................... 26
10.1.1 Android Studio / API natiu d’Android: ............................................... 26
10.1.2 MIT App Inventor (Google App Inventor) ......................................... 26
10.1.3 PhoneGap (Apache Cordova PhoneGap): ........................................... 27
10.1.4 jQuery ................................................................................................ 28
10.1.5 Basic4android (B4A): ........................................................................ 29
10.1.6 HyperNext Android Creator ............................................................... 30
10.1.7 Kivy ................................................................................................... 30
8
10.1.8 Qt para Android ................................................................................. 31
10.1.9 RFO Basic! ........................................................................................ 31
10.1.10 RubyMotion ..................................................................................... 32
10.2 Altres Frameworks més minoritaris: ........................................................ 32
10.2.1 Rebol 3Saphir .................................................................................... 32
10.2.2 Projecte Simple: ................................................................................. 33
10.2.3 WinDev Mobile ................................................................................. 33
10.2.4 GameSalad ......................................................................................... 33
10.2.5 Corona SDK ...................................................................................... 34
10.2.6 Altres entorns per al desenvolupament de jocs: .................................. 34
10.2.7 Entorns HTML5 i CSS: ...................................................................... 34
10.3 Quadre comparatiu entre Frameworks. .................................................... 36
10.4 Conclusions ............................................................................................. 37
11 Framework Natiu ........................................................................................... 39
11.1 Requisits per a la programació amb Api nativa: ....................................... 39
11.1.1 SDK: .................................................................................................. 39
11.1.2 IDE (Integrated Development Environment): ..................................... 40
11.1.3 JDK (Java Development Kit) ............................................................. 41
11.1.4 NDK (Native Development Kit) ......................................................... 41
11.2 Instal·lació del entorn natiu: .................................................................... 41
11.2.1 Instal·lació del paquet complet d’Android Studio: .............................. 41
11.2.2 Descàrrega i instal·lació de Java:........................................................ 42
11.2.3 Descarregar i instal·lar el paquet Android Studio ............................... 42
11.2.4 Configuració inicial de l’entorn Android Studio ................................. 46
11.2.5 Instal·lar/actualitzar els components del SDK de Android. ................. 46
11.3 Android per parts o en entorn Eclipse. ..................................................... 48
11.3.1 Descàrrega i instal·lació de Java. ........................................................ 48
11.3.2 Descàrrega i instal·lació d’Eclipse...................................................... 48
11.3.3 Descarregar el SDK d’Android. ......................................................... 49
11.3.4 Instal·lar els paquets addicionals del SDK. ......................................... 49
11.3.5 Configuració d’un AVD (Android Virtual Device) ............................. 50
11.3.6 Descarrega i instal·lació del Pluggin per Eclipse ................................ 51
12 Estructura d’un projecte en Android Studio. ................................................... 53
12.1 Creació d’un projecte en Android Studio pas a pas .................................. 53
12.1.1 Carpeta /app/src/main/java ................................................................. 58
12.1.2 Carpeta /app/src/main/res/ .................................................................. 58
12.1.3 Fitxer /app/src/main/AndroidManifest.xml ......................................... 59
9
12.1.4 Fitxer /app/build.gradle ...................................................................... 59
12.1.5 Carpeta /app/libs ................................................................................ 59
12.1.6 Carpeta /app/build/ ............................................................................. 60
12.2 Components d’una aplicació Android. ..................................................... 60
12.2.1 Activitat/Activity: .............................................................................. 60
12.2.2 Vista/View: ........................................................................................ 60
12.2.3 Servei/Service: ................................................................................... 60
12.2.4 Proveïdors de Continguts/Content Provider. ....................................... 60
12.2.5 Broadcast Reciver. ............................................................................. 61
12.2.6 Widget. .............................................................................................. 61
12.2.7 Intent. ................................................................................................ 61
13 Creació d’una aplicació senzilla ..................................................................... 62
13.1 Procés de creació de l’aplicació. .............................................................. 62
13.1.1 Fase I: Creació del projecte. ............................................................... 62
13.1.2 Fase II: Factors inicials. ..................................................................... 65
13.1.3 Fase III: Creació de la interfície gràfica. ............................................. 66
13.1.4 Fase IV: Creació de l’activitat principal. ............................................ 68
Conclusions finals: .................................................................................................. 71
Referències: ............................................................................................................ 73
Annex 1 .................................................................................................................. 74
Annex 2 .................................................................................................................. 75
Annex 3 .................................................................................................................. 77
Annex 4 .................................................................................................................. 78
10
1 Índex d’il·lustracions
FIGURA PG.
Figura 1. Logotip del Sistema Operatiu Android . 5, 6
Figura 2. Gràfic del creixement d’abonats a l’ample de banda mòbil a nivell
mundial. 12
Figura 3. Gràfic del creixement del consum de dades a nivell mundial. 12
Figura 4. Gràfic del usos dels diferents Sistemes Operatius Mòbils. 13
Figura 5. Representació de l’Arquitectura de capes del Sistema Operatiu
Android. 20
Figura 6. Representació comparativa compilació estàndard Java i Dalvik. 22
Figura 7. Ús dels diferents Frameworks els anys 2013 i 2012. 24
Figura 8. Logotip d’Android Studio. 25
Figura 9. Logotip MIT App Inventor. 26
Figura 10. Logotip PhoneGap. 27
Figura 11. Logotip JQuery. 28
Figura 12. Logotip Basic 4 Android. 29
Figura 13. Logotip HyperNext Studio. 30
Figura 14. Logotip del framework Kivy. 30
Figura 15. Logotip del framework Qt. 31
Figura 16. Logotip RFO Basic! 31
Figura 17. Logotip RubyMotion. 32
Figura 18. Logotip GameSalad. 33
Figura 19. Logotip Corona SDK. 34
Figura 20. SDK Maneger, on es veuen el paquest i llibreries disponibles en el
nostre SDK. 39
Figura 21. Captura de l’aspecte que ofereix l’IDE d’Android Studio. 40
Figura 22. Enllaç de descàrrega d’Android Studio al web
https://developer.android.com. 41
Figura 23. Captura en el procés d’instal·lació del paquet de Java. 42
Figura 24. Pantalla inicial del procés d’instal·lació d’Android Studio 43
Figura 25. Instal·lació en curs d’Android Studio. 44
Figura 26. Opció d’importar a Android Studio una configuració prèvia 44
Figura 27. Actualitzció automàtica del components recent instal·lats d’Android
Studio 44
Figura 28. Pantalla de Benvinguda / Inicial d’Andoid Studio. 45
Figura 29. Pantalla de configuració de la ubicació dels directoris SDL i Java a
Android Studio. 46
11
Figura 30. Captura del SDK Maneger. 47
Figura 31. SDK Maneger. 49
Figura 32. Captura de la informació mostrada per l’SDK en el procés
d’actualització. 50
Figura 33. Vista de l’emulador AVD amb dos dispositius configurats. 50
Figura34. Pantalla per a la configuració dels dispositius d’emulació al AVD. 51
Figura 35. Finestra de Benvinguda a Android Studio. 53
Figura 36. Captura d’una pantalla en el creació d’un nou projecte. 54
Figura 37. Exemple 1 de la configuració d’alguns paràmetres en un nou projecte. 55
Figura 38. Pantalla d’ajuda per a la selecció de paràmetres en la configuració del
nou projecte. 55
Figura 39. Exemple 2 de la configuració d’alguns paràmetres en un nou projecte. 56
Figura 40. Exemple 3 de la configuració d’alguns paràmetres en un nou projecte. 56
Figura 41. Aspecte del entorn de treball davant d’un nou projecte. 57
Figura 42. Captura del menú de carpetes de com s’estructura un projecte. 57
Figura 43. Llistat de les carpetes d’un nou projecte. 59
Figura 44. Captura dels components que conformen la carpeta build en un nou
projecte. 60
Figura 45. Pantalla de configuració del nom de l’aplicació a crear. 62
Figura 46. Pantalla de configuración del mínim SO amb el que serà compatible
l’aplicació a crear. 63
Figura 47. Pantalla de configuració del tipus d’activitat principal que tindrà la
nova aplicació. 64
Figura 48. Introducció dels paràmetres que defineixen el tipus d’activitat escollit. 64
Figura 49. Entorn de treball on es crearà la nova aplicació. 65
Figura 50. Previsualització de l’entorn gràfic de la nostra aplicació. 66
12
2 Introducció
La penetració de les telecomunicacions i la telefonia mòbil en aquesta última dècada
ha estat tan accelerada, que d’acord amb l’últim informe “Medición de la Sociedad de la
información (MSI)” de 2014, a finals d’aquest any, 2014, hi havia casi tants abonats a la
telefonia mòbil com habitants hi ha a la Terra, uns 6.900 milions. Directament relacionat
amb aquest creixement hi va vinculat el creixement encara més exagerat dels abonats a
l’ampla de banda mòbil, amb una penetració mundial del 32%, és per això, que resulta
innegable un creixement exponencial del mercat de les aplicacions mòbils en conjunt amb
la demanda de telèfons mòbils, convertint-se indubtablement en un dels sectors de més
interès per a petits i grans empresaris.
Figura 2. Gràfic del creixement d’abonats a l’ample de banda mòbil a nivell mundial.
Tan mateix, també es pot observar el fort creixement en volum de dades a nivell
mundial al llarg de la última dècada.
Figura 3. Gràfic del creixement del consum de dades a nivell mundial.
En resposta a aquest creixement desmesurat de la tecnologia mòbil sorgeixen al
mercat múltiples marques i sistemes operatius de telèfons mòbils, que utilitzen i aprofiten
els recursos de formes diferents d’acord amb les seves necessitats i possibilitats d’ofertes.
13
D’aquesta manera, Android, com a Sistema Operatiu mòbil, es posiciona actualment
com un dels més utilitzats per els telèfons intel·ligents i tauletes, de fet, a l’any 2014 un
47,45% dels dispositius a nivell mundial utilitzaven aquest sistema operatiu (segons dades
de NetMarketShare: http://www.netmarketshare.com/). Directament vinculat a aquest
creixement, Google Play s’ha convertit amb la plataforma amb major nombre d’aplicacions
que aproximadament aglutina més de 800.000 aplicacions disponibles i més de 50.000
millons de descarregues des dels seus inicis, fa aproximadament una dècada.
Figura 4. Gràfic del usos dels diferents Sistemes Operatius Mòbils.
La programació d’aplicacions en Andoird es realitza mitjançant una combinació de
comandes en Java juntament amb la utilització de llibreries natives que permeten manejar i
controlar els esdeveniments i accessoris del telèfon. Com a contrapartida a la programació
nativa, sorgeixen múltiples empreses, companyies i associacions d’usuaris dedicats a la
creació i desenvolupament de frameworks o entonrs de programació que ens permeten la
creació i elaboració d’aplicacions de forma alternativa a l’esdentada programació nativa,
fent servir altres llenguatges i lògiques de programació.
En aquest mateix ordre d’idees, segons un informe realitzat per Eclipse el juny de
2014, “Eclipse Open Source Developer Report 2014” tot i existir diferents opcions de
programació al mercat, casi el 60% dels programadors prefereixen utilitzar els entorns
natius, aproximadament un 28% utilitza jQuery Mobile, framework basat en HTML5 +
CSS + JavaScript, per una altre banda, un 7%, prefereix utilitzar PhoneGap, també basat
amb els mateixos llenguatges que el framework anterior. Finalment la resta de
programadors es divideixen en un gran nombre de marcs existents, que posteriorment
nombrarem.
És important remarcar que cadascun dels Frameworks, té les seves avantatges i els
seus inconvenients segons el tipus, objectiu i tipologia de l’aplicació que el usuari desitja
desenvolupar.
En aquest projecte, intentaré exposar les capacitats i limitacions d’alguns dels
Frameworks més representatius, explicant les seves avantatges així com els seu
inconvenients, basant-nos en la experiència de desenvolupadors experimentats com la
meva pròpia, més limitada. De la mateixa manera, intentaré establir criteris d’avaluació per
avaluar la conveniència d’utilitzar una plataforma o una altre segons l’objectiu de
l’aplicació, com també altres factors com poden ser els coneixements previs del
programador, el temps del que es disposa, etc.
14
Com a problemàtica tenim el gran nombre d‘entorns de treball existents al mercat, i
en conseqüència l’elevat nombre de llenguatges i lògiques diferents utilitzades, així com la
constant evolució de tots ells, fet que pot dificultar força l’anàlisi de tots ell,.
En conclusió, aquest treball intenta ser una guia bàsica per aquells usuaris que
desitgin desenvolupar aplicacions en Android i no saben quina alternativa escollir i en el
cas d’escollir un entorn natiu, també el serveixi com a guia inicial per començar a treballar
amb aquest entonrs.
15
3 Propòsit del projecte
Com ja s’ha mencionat amb anterioritat, aquest projecte intenta donar una amplia
informació dels diversos Frameworks de programació existents al mercat que permeten
desenvolupar aplicacions sobre el sistema operatiu Android, amb una posterior comparació
dels avantatges i inconvenients de la utilització de cadascun d’ells.
Particularment, el treball intenta realitzar un anàlisi detallat de les capacitats d’alguns
frameworks, i seguidament mostrar de forma simplificada i senzilla als desenvolupadors,
una varietat d’informació comparativa que els serveixi com a guia alhora de prendre
decisions al escollir entre les múltiples opcions disponibles combinades amb les seves
necessitats de desenvolupament, objectius de l’aplicació i coneixements del programador.
4 Justificació
Android, en els darrers anys, s’ha posicionat a nivell mundial com una de les
plataformes mòbils més utilitzades. Tot i que el propi Sistema Operatiu posa a disposició
una web amb documentació detallada, tutorials, etc. Sobre la programació d’aplicacions
amb els paquets natius, es possible trobar per la xarxa, moltes altres plataformes que ens
permeten també desenvolupar les mateixes aplicacions, però utilitzant llenguatges o
tècniques de desenvolupament diferents.
És per això, que degut a aquest gran nombre d’alternatives a la programació nativa,
que aquest projecte proposa la recopilació dels Frameworks més utilitzats per explicar els
avantatges i inconvenients de cascun d’ells respectivament i oferir al desenvolupador una
guia que l’ajudi en la presa de les decisions prèvies al desenvolupament d’aplicacions
mòbils.
5 Objectius
5.1 Objectiu general: Comparació de Frameworks existents al mercat per a la programació d’aplicacions
mòbils i un anàlisi més exhaustiu del que considerem més adequat per al nostre entorn.
5.2 Objectius específics:
Coneixements sobre l’arquitectura lògica del Sistema Operatiu Android.
Coneixement sobre la tipologia d’aplicacions mòbils existents.
Coneixement bàsics dels diferents entorns de treball existents al mercat per al
desenvolupament d’aplicacions mòbils.
Coneixement dels Frameworks natiu de desenvolupament.
Coneixement dels processos d’instal·lació dels dos entorns natius principals.
Coneixement de l’estructuració de projectes en els entorns natius principals.
Coneixements dels components que composen un aplicació Android.
Coneixements del procés de creació, compilació i emulació d’una aplicació
senzilla.
16
6 Limitacions
Existeixen al mercat una gran diversitat de Frameworks que ofereixen al públic en
general eines per al desenvolupament d’aplicacions mòbils compatibles amb el sistema
operatiu Android. Precisament, aquesta gran quantitat de Frameworks representen la
principal limitació en el moment de desenvolupar la primera part aquesta investigació. Es
per aquest motiu que es va decidir orientar l’estudi cap un anàlisis més general sobre una
gran nombre de Frameworks i un posterior aprofundiment sobre els més utilitzats, acabant
amb un anàlisi encara més acurat del Frameworks natius.
En la segona part del projecte, el desenvolupament d’una aplicació en Android
Studio, la limitació rau en els coneixements bàsics dels que disposo a nivell de
programació sobre aquest entorn.
7 Abast
Aquest treball s’emmarca sota la necessitat de proporcionar als nous
desenvolupadors interessats en la creació d’aplicacions mòbils sota el Sistema Operatiu
Android, una guia bàsica comparativa que els faciliti la elecció del Framework més idoni,
que s’amotlli a les seves necessitats. I en cas d’escollir l’entorn natiu ampliï aquesta
informació i col·labori en l’execució i elaboració de l’aplicació de forma més ràpida i
senzilla.
També intenta ser una guia per iniciar-se en el mon dels entorns natius, mostrant des
del procés d’instal·lació, entenent l’estructuració dels projectes en aquests entorns, passant
per el desenvolupament de l’estructura bàsica d’un projecte, coneixen el components
bàsics d’una aplicació fins arribar a ala creació d’una aplicació de comunicació força
senzilla on es posi en pràctica tota la informació teòrica desgranada.
17
8 Base de coneixements
Alhora de començà a desenvolupar una aplicació mòbil, a més d’escollir quin
Framework s’utilitzarà, també cal conèixer quin tipus d’aplicació es desenvoluparà,
aquesta elecció afectarà directament en la pròpia elecció del marc de treball, així com el
nivell de compatibilitat amb altres sistemes operatius, la plataforma de propagació de
l’aplicació i possiblement la tipologia de públic a la que anirà dirigida, etc...
La forma de classificar les aplicacions, pot ser segons el seu objectiu o ús, com per
exemple: aplicacions educatives, aplicacions empresarials, aplicacions per l’oci,
divulgatives, jocs, de música, etc., però també es poden classificar segons els seu mode de
construcció, que per al nostre objectiu és la millor forma de classificar-les.
És per això, que per escollir quin tipus de modalitat d’Aplicació és la més apropiada
per a definir l’aplicació que es té com objectiu desenvolupar, cal respondre a un sèrie de
preguntes, les respostes de les quals, en ajudaran a realitza una correcta planificació i a
escollir l’entorn de desenvolupament més adequat.
i. Quin cost s’està disposat a assumir per al desenvolupament de l’aplicació?
ii. L’aplicació a desenvolupar, requereix accedir a les característiques del
maquinari del dispositiu?
iii. A quin tipus de públic va dirigida l’aplicació?
iv. Requereix d’un disseny molt complex o molt personalitzat?
v. Es vol utilitzar les notificacions a l’aplicació?
vi. Es té pensat modificar les accions de l’aplicació mòbil i incorporar més
funcionalitats en un futur?
La resposta a aquestes preguntes ens indicarà de quina tipologia serà l’aplicació a
desenvolupar, per tant, les aplicacions es poden classificar de la següent manera,
classificació que és vàlida per qualsevol plataforma o sistema operatiu:
8.1 Tipologia de les Aplicacions mòbils:
8.1.1 Aplicació Nativa:
És aquella que es desenvolupa de forma específica per a un determinat Sistema
Operatiu, també anomenat Software Development Kit o SDK, com poden ser els coneguts
sistemes Android, iOS, Windows Phone, etc... Cadascun d’aquest tenen un sistema
diferent, que implica un desenvolupament propi i únic per a cadascuna d’elles, és a dir, si
es vol que un aplicació nativa funcioni en tots els sistemes operatius, caldrà realitzar un
desenvolupament complet d’aquest per cadascun.
Per exemple:
i. Les Apps per a iOS es desenvolupem en llenguatge Objective-C.
ii. Les Apps d’Android es desenvolupament amb llenguatges com per exemple
el Java.
iii. Les Apps amb Windoes Phone es desenvolupen en .Net.
Quan es parla de desenvolupament mòbil, quasi sempre es fa referència a aplicacions
natives. La principal avantatge d’aquest tipus de desenvolupament ne front la resta, és la
possibilitat d’accedir a totes les característiques de hardware de l’aparell: càmera, GPS,
Bluetooth, agenda, emmagatzemant, etc... Això afavoreix que l’experiència de l’usuari
sigui molt més positiva comparada amb altres tipologies d’aplicació.
18
A més, aquest tipus d’Apps no requereixen d’una connexió continua a Internet per a
que puguin funcionar.
La descarrega i instal·lació d’aquestes Apps es realitza a través de les tendes
d’aplicacions (app stores dels fabricants: AppStore, PlayStore, etc...
Avantatges:
Possibilitat d’accés complet a les característiques del maquinari del
dispositiu.
Millora l’experiència de l’usuari.
Visibilitat de l’aplicació en les plataformes de descarrega reconegudes.
Aprofitament de les notificacions i avisos.
Fàcil i constant actualització de l’aplicació a traves de la publicació de noves
versions.
Inconvenients:
Requereix d’un desenvolupament per a cadascuna de les plataformes
especifiques en les que es vol que funcioni.
Normalment tenen un cost més elevat de desenvolupament.
8.1.2 Aplicació Web o WebApp:
És aquella que es desenvolupa amb llenguatges majoritaris i molt coneguts per els
programadors, com per exemple HTML5, JavaScript, CSS. La principal avantatge respecte
el desenvolupament d’aplicacions natives és la possibilitat de programar independentment
del sistema operatiu on es farà corre l’aplicació. D’aquesta forma es pot executar
l’aplicació en diferents entorns sense la necessitat de fer un desenvolupament específic per
a cada SO.
Les aplicacions web, s’executen dins del propi navegador web del dispositiu o a
traves d’una URL, per exemple: a través de Safari per plataformes amb iOS, o Chrome en
Android, en aquests casos, el contingut s’adapta a la pantalla simulant l’aspecte de
navegació d’una App Nativa.
Una altra característica diferenciadora, és que aquest tipus d’aplicacions no
requereixen instal·lació, per tant, aquestes Apps no estan visibles a les botigues dels
fabricants, com a conseqüència, totes les tasques de promoció i comercialització s’ha de
realitzar de forma independent.
La manera de presentar-les com una aplicació nativa, és crear un accés directe que
seria l’equivalent al procés de instal·lació.
Avantatges:
El mateix codi font és vàlid per a tots els Sistemes Operatius.
Simplificació del procés de desenvolupament, tant a nivell tècnic com
econòmic.
No requereix de l’aprovació dels fabricants per a la seva publicació a les
botigues reconegudes.
Els usuaris sempre disposen de la última versió, ja que no cal actualització de
la pròpia aplicació.
Es poden utilitzar en llocs que ja han estat dissenyats de forma responsiva.
19
Inconvenients:
Requereix d’una connexió de dades continua per al seu funcionament.
L’experiència de l’usuari és menys satisfactòria deguda la dependència amb
la connexió de dades.
Requereix un major esforç en la promoció i comercialització ja que
l’aplicació no es publica en les Stores reconegudes.
8.1.3 Aplicacions híbrides:
Són aquelles que combinen les dues modalitats anteriors, és a dir, aprofiten les
millors característiques de cadascuna d’elles.
Per una banda aquestes aplicacions es desenvolupen amb els llenguatges propis de
les WebApps, com poden ser: HTML, CSS, Javascript..i com a conseqüència són
executables en els diferents sistemes Operatius, però a més, incorporen la possibilitat
d’accedir a les característiques Hard del dispositiu.
La principal avantatge, a més de les característiques esmentades, és que, en aquest
tipus de desenvolupament es possible agrupar els codis desenvolupats i distribuir-los a
traves de les tendes dels fabricants.
El grau d’integració amb el sistema Operatiu, dependrà del entorn o framework de
desenvolupament escollit, per exemple: PhoneGap, és un dels entorns de desenvolupament
(Frameworks) més utilitzats per als programadors d’aquest tipus d’Apps, tot i així,
n’existeixen molts altres que desenvoluparem en punts posteriors.
Avantatges:
Es possible distribuir-les a traves de les Apps Stores dels fabricants
L’entorn de treball es basa en una instal·lació nativa però construïda en –
Javascript, HMTL i CSS.
Un únic codi per a tots els Sistemes Operatius.
Possibilitat d’accedir a quasi totes les característiques hard del dispositiu.
Inconvenients:
L’experiència de l’usuari no es pot considerar del tot equivalent a les Apps
Natives.
20
Alhora de desenvolupar una aplicació sota el Sistema Operatiu Android cal tenir
alguns coneixements bàsics sobre aquest.
9 Arquitectura lògica del Sistema Operatiu Android.
Una de les característiques que fa tan atractiu aquest Sistema Operatiu, és que va ser
creat per ser independent de qualsevol tipus de hardware, sobretot en els dispositius
mòbils.
Aquesta característica fa que sigui necessari estudiar la seva arquitectura abans de
començar la programació, conèixer les seves característiques tant d’operació en temps real
com en el seu format d’encapsulament d’arxiu.
9.1 Model de Capes de l’arquitectura Android. Android es va construir amb una arquitectura de quatre capes o nivells
interelacionats amb la disposició que mostra el següent gràfic proposat per Marko
Gargenta y Masumi Nakamura en el seu llibre “Learning Android”.
Figura 5. Representació de l’Arquitectura de capes del Sistema Operatiu Android.
Com es pot observar al gràfic anterior, i de forma genèrica, l’estructura d’Android
recau sobre un Kernel de Linux, directament a sobre s’hi troba la capa de llibreries
relacionada amb una estructura administradora anomenada “Android runtime”.
En la següent capa hi trobem els “Frameworks” o entorns de desenvolupament,
objectes d’estudi en aquest projecte i que donen recolzament al desenvolupament de les
aplicacions que estan just en la següent capa.
21
Ampliant els conceptes anteriors:
9.1.1 Kernel de Linux o nucli de Linux:
En aquest cas es tracta de la base del Sistema Operatiu, aquest nucli ha estat
modificat per adaptar-se a dispositius mòbils. Es va escollir Linux com a base, basant-se en
la gran portabilitat, flexibilitat i seguretat que aquest sistema presentava.
Una de les conseqüències i a la vegada curiositat d’aquesta elecció, és que degut a
que Linux està sota una llicencia GPL (Licencia Pública General que es caracteritza per
que permet la còpia, distribució (comercial o no) i modificació del codi, sempre que
qualsevol modificació es continuï distribuint amb la mateixa llicència GPL), per tant,
Android també ho ha d’estar.
9.1.2 Capa de Llibreries o capa nativa:
En aquesta capa s’hi troben parts com:
la HAL (Hardware Abstraction Layer): component que permet la
independència del Hardware, aquest actua com una arquitectura genèrica
que representa a tots els possibles tipus de hardware existents en el mercat.
Tot i que actualment encara no existeixen estendards de construcció per al
hardware de dispositius mòbils, el Hal, és qui permet als fabricants ajustar
les seves preferències per a que Android pugui corre sobre els seus
dispositius. llibreries natives: són interfícies de codi obert que poden facilitar processos
com per exemple el renderitzat de gràfics en 3D (OpenGL), la gestió de
base de dades (SQLite), o d’altres com per exemple els serveis com la Wifi,
el posicionament, la telefonia, etc... Daemons (dimonis): aquests dimonis són porcions de codi que s’executen
per ajudar a serveis del sistema, per exemple, quan es requereix instalar o
actualitzar una aplicació s’executa un dimoni el qual administrarà tot el
procés, el mateix passa quan per exemple els programadors executen el
mode de depuració, des del pc s’executa el dimoni sobre el terminal per dur
a terme aquest procés. Alguns dels dimonis més coneguts o que hem comentat podrien ser: installd,
adbd (Android Debug Bridge Daemon)
les eines de consola: com molts altres sistemes operatius, Android també
permet l’ús de línies de comanda per a l’execució de processos de sistema o
per a la pròpia exploració del sistema.
els controladors en temps d’execució: si bé les aplicacions d’Android estan
escrites en llenguatge Java i són traduïdes a Bytecodes, aquestes no són
interpretades per la Maquina Virtual de Java. Android té la seva pròpia
màquina virtual interpretadora de bytecodes anomenada Dalvick.
22
9.1.3 Base de funcionament de la màquina virtual Dalvik.
Dalvik, no interfereix en un procés normal de compilació, senzillament intervé al
final del procés, intervé com a receptor d’un arxiu executable fruit de la re-compilació dels
arxius .class de Java. És a dir, dins les fases de construcció d’una aplicació Java, trobem:
i. en primer lloc, la generació del codi font (arxius .java).
ii. posteriorment, aquest es traduït per el Java Compiler (javac) obtenint un fitxer
de tipus Bytecode (arxius .class),
iii. finalment la màquina virtual de Java interpreta en temps real aquest arxius per
executar l’aplicació.
A partir d’aquest punt, Dalvik, simplement espera que JavaC tradueixi el codi a
Bytecodes (punt ii) i quan aquests estan llestos són compilats per el compilador Dex. Es
per això que Dalvik, tradueix els arxius bytecodes de Java a un estil d’arxius bytecode
natius que seran convertits a un executable “.dex”.
El següent gràfic intenta reproduir un procés comparant ambdós sistemes, per un
cantó el procés típic de Java i per l’altre el d’Android.
Figura 6. Representació comparativa compilació estàndard Java i Dalvik.
23
9.1.4 Framework per aplicacions:
Capa on s’hi poden trobar totes les llibreries Java necessàries per al desenvolupament
de les aplicacions, tot i que n’hi ha algunes de excloses. Els paquets més rellevants són els
Android.*, en els que s’allotgen totes les característiques necessàries per a construir de
qualsevol aplicació Android.
En aquesta capa, a més, també s’hi trobarà els controladors, serveis i proveïdors de
contingut que suportaran la comunicació de la nostra aplicació amb l’ecosistema
d’Android.
9.1.5 Capa d’aplicacions:
És la última instancia de funcionament d’Android, la qual es centra en l’execució,
comunicació i estabilitat de les aplicacions pre-instal·lades per el fabricant o bé les que es
van instal·lant o construint. A ella, hi poden accedir tots els usuaris d’Android degut al seu
alt nivell de comprensió i simplicitat.
Les aplicacions d’Android, són fitxers comprimits amb extensió .apk (Android
Application Package) dins les quals hi podem trobar:
Arxiu Android Manifest: aquest arxiu conté la definició de totes les
característiques principals que tindrà la nostra aplicació al executar-se en un
dispositiu mòbil, és a dir, contindrà els blocs, permisos, versions, versions
prèvies suportades, dimensions de les pantalla, etc...
Arxiu classes .dex: aquest és el fitxer compilat i preparat per executar-se en
la màquina virtual Dalvick. Carpeta Resources: carpeta on s’hi troben tots els arxius externs que
s’utilitzaran per a la construcció del nostre projecte, com per exemple: icones,
àudios, arxius plans de text, arxius xml de disseny, etc... Llibreries natives: llibreries referenciades a l’arxiu .apk de les quals depèn
l’aplicació. Carpeta META-INF: carpeta on s’emmagatzemen arxius que corresponen a
les Firmes Digitals de la nostra aplicació, és a dir, les especificacions que
indiquen qui és el creador i propietari de l’aplicació, la ID del desenvolupador
per a poder ser reconegut i autenticat en el procés de comercialització de
Google.
24
10 Marc referencial
Tot i que Android recomana el desenvolupament de les aplicacions utilitzant l’API
nativa mitjançant l’ús de comades en Java, existeixen moltes altres alternatives que
permeten programar en una variada diversitat de llenguatges (Java, HTML5, etc...) i
mètodes (Nadiu, hibrida, multi-plataforma) segons sigui l’objectiu de la programació, així
com els coneixements del programador.
Aquestes alternatives són els coneguts “Frameworks”:
D’origen anglès, la paraula Framework (marc de treballa) defineix, en termes
generals, un conjunt estandarditzat de conceptes, pràctiques i criteris per a enfocar un tipus
de problemàtica particular que serveix com a referència, i posteriorment poder afrontar i
resoldre nous problemes de caire similar.
“En el desenvolupament de software, un Framework o infraestructura digital, és una
estructura conceptual i tecnològica de suport definit, normalment es compon d’artefactes o
mòduls de software concrets, que poden servir de base per a la organització i
desenvolupament de software. Típicament, inclouen suport de programes de suport,
compiladors, biblioteques de codi, interfícies de programació (Api’s), llenguatges
interpretats, de entre altres eines, amb l’objectiu de facilitar el desenvolupament i unificar
els diferents components d’un projecte.”1
Una de les principals característica d’alguns Frameworks és la possibilitat de
treballar en múltiples plataformes, permetent la creació d’un codi font que podrà ser
executat en diferents sistemes operatius compatibles, és a dir, són Framworks que són
capaços de traduir un codi font, força estàndard a diferents sistemes operatius
simultàniament, com per exemple, Android, iOS, Windows Phone, etc...
A continuació es mostra un gràfic on es pot veure els frameworks de programació
més utilitzats, tot i que com es pot comprovar, una gran majoria prefereix desenvolupar de
forma nativa amb les pròpies eines proporcionada per Google:
1 Riehle, Dirk (2000), Framework Design: A Role Modeling Approach
25
Figura 7. Ús dels diferents Frameworks els anys 2013 i 2012.
L’entorn oficial actual de treball d’Android està desenvolupat per Google i disposa
d’un lloc web on s’explica de forma força detallada i amb gran quantitat d’exemples, l’ús
del seu API, actualment el conegut Android Studio. Tot i això, encara que aquesta és
l’opció més estable, completa i recomanable, existeixen múltiples opcions que permeten
als desenvolupadors programar aplicacions utilitzant altres mètodes o llenguatges de
programació, com a alternativa al Java, proposada per Google.
Figura 8. Logotip Android Studio
A continuació es presenta una llista d’alguns, d’entre tants, Frameworks que
permeten el desenvolupament d’aplicacions per a dispositius amb Sistema Operatiu
Android.
Començant per els entorns natius, aplicable a Android Studio com a Eclipse, pels
motius ja exposats anteriorment, a continuació tractarem el MIT App Inventor, també és un
Framework de Google, i, tot i que no és un dels entorns més utilitzats, és un dels més
curiosos degudes les seves característiques, Posteriorment, serà el torn del PhoneGap, que
tal com ja indicaven en el gràfic anterior (Figura 7) l’utilitza aproximadament un 12% dels
desenvolupadors i finalment tractarem el JQuery amb un 24, 5% de la quota de
programadors.
26
Figura 9. Logotip MIT APP Inventor
10.1 Entorns o Frameworks de programació.
10.1.1 Android Studio / API natiu d’Android:
Plataformes o marcs de treball de Google per al desenvolupament d’aplicacions per
aquest sistema operatiu. Ambdós es basen en llenguatge de programació “Java” més
algunes comandes pròpies que permeten accedir a les funcionalitats de telèfon permetent
executar diferents accions i esdeveniments.
Des de finals del 2014 existeix el paquet per a desenvolupadors Android Studio, que
agrupa totes les aplicacions necessàries per a la creació d’aplicacions, tot i que per a equips
que utilitzen Windows 7 o posterior i que substitueix el paquet d’Eclipse. En cas d’utilitzar
Windows XP cal fer la instal·lació per parts, instal·lant cadascuna de les aplicacions (SDK,
IDE, etc...) individualment.
Paquet Android Stuido que es el recomanat actualment per al desenvolupament,
incorpora:
Android Studio IDE.
Android SDK tools.
Android 5.0 (Lollipop) Platform.
Android 5.0 emulator system image with Google API’s.
En cas de no poder utilitzar aquesta paquet, Android Studio, es recomana la
instal·lació dels paquets bàsics SDK, ADT per separat,i la configuració d’una plataforma
integral de desenvolupament (IDE), com per exemple Eclipse o NetBeans.
Avantatges:
i. És gratuït
ii. Representa l’alternativa de desenvolupament amb més funcionalitats per
accedir als accessoris i al hardware del dispositiu, com poden ser: càmera,
GPS, acceleròmetre, etc...
iii. Actualment compta amb un paquet complet amb totes les eines necessàries
per al desenvolupament de fàcil instal·lació si es compleixen els
requeriments.
iv. És l’alternativa que compta amb major ajuda, documentació i suport per al
desenvolupament de les aplicacions, ja sigui oferta per el propi fabricant,
com per fòrums o usuaris.
Inconvenients:
v. Només permet el desenvolupament sobre el Sistema Operatiu d’Android, no
en permet d’altres com iOS, Windows Phone, etc...
vi. Calen coneixements de Java.
10.1.2 MIT App Inventor (Google App Inventor)
És una plataforma de Google Labs per a
crear aplicacions per Android d’una forma molt
visual a partir d’unes eines força bàsiques, en les
que l’usuari pot entrellaçar un sèrie de blocs al
estil trencaclosques (llenguatge de programació)
per a crear les aplicacions, sense la necessitat
27
d’escriure gens de codi.
App Inventor proporciona un ampli accés als components i funcions natives del
sistema, entre les que destaquen, l’accés al GPS, al acceleròmetre i a dades d’orientació, a
serveis web, com per exemple Twitter, entre d’altres.
Una de les particularitats d’aquest entorn, és que les aplicacions construïdes no estan
emmagatzemades al nostre disc dur, sinó que es troben a la xarxa, permetent accedir a elles
des de qualsevol punt amb accés a Internet.
És gratuït i es pot obtenir fàcilment de la web, és a dir, tal i com ja s’ha esmentat, la
programació es pot realitzar via web, només cal disposar d’un compte a Google i després
descarregar l’emulador per a fer les proves de funcionament.
Avantatges:
i. Gratuït, només cal tenir un compte a Google.
ii. Tot via web, no calen instal·lar programes ni interfícies, per tant, a part
d’una fàcil instal·lació també permet accedir des de qualsevol punt que
tingui connexió a Internet indiferentment del sistema operatiu o l’entorn de
treball
iii. Només cal instal·lar el simulador / emulador /connector per tal de dur a
terme les proves de les aplicacions, directament amb l’emulador o via USB
amb un terminal físic.
iv. Fàcil programació, que és divideix en dos apartats:
a. El dissenyador de pantalles
b. El dissenyador de blocs
Inconvenients:
i. Les aplicacions poden estar limitades una mica per la pròpia simplicitat del
llenguatge.
Enllaç: http://appinventor.mit.edu/explore/
10.1.3 PhoneGap (Apache Cordova PhoneGap):
És una plataforma que permet als programadors el desenvolupament d’aplicacions
per a múltiples plataformes /Sistemes Operatius, mitjançant eines genèriques tal com:
JavaScript, HTML5 i CSS3.
Les aplicacions resultants
no són realment aplicacions
natives al dispositiu, però
tampoc es tracta d’aplicacions
web.
A partir de la seva tercera
versió, PhonGap va incorporar
l’ús d’una interfície de comandes a traves d’una consola, una nova arquitectura de
complements descentralitzats i la possibilitat d’utilitzar un codi web unificat per a crear
múltiples projectes.
Permet APIs d’accés a elements com l’acceleròmetre, la càmera, els contactes, la
xarxa, l’emmagatzemen, les notificacions, etc...
Figura 10. Logotip PhoneGap
G
28
Figura 11. Logotip JQuery
També permet el desenvolupament de les aplicacions a traves del navegador sense
necessitat d’utilitzar un simulador/emulador dedicat i permet funcions com SenchaTouch o
JQueryMobile, com per exemple els Widgets d’alt rendiment, barres d’eines, formularis,
etc....
Avantatges:
i. Gratuït i de codi totalment obert.
ii. Gran compatibilitat amb els Sistemes Operatius majoritaris.
iii. Possibilitat d’accedir als elements de Hard mitjançant Javascript
iv. Utilització de llenguatges web molt comuns.
Inconvenients:
i. No crea Apps natives, sinó que requereix el motor de la plataforma web.
ii. No té un IDE propi.
iii. Tot i que permet l’accés als accessoris i a les característiques hard, aquest té
algunes limitacions.
iv. Requereix coneixements de llenguatges de programació HTML5, CSS i
JAvaScript.
Enllaç: http://phonegap.com/
Requeriments per al Desenvolupament:
i. Instal·lació d’un IDE extern. El més recomanat es Eclipse.
ii. Instal·lació del SDK de Android
iii. Instal·lació del ADT Plugin al IDE.
iv. Instal·lació de les llibreries Cordova als projectes.
v. Instal·lació del paquet JDK (Java Development Kit)
vi. De forma opcional, instal·lar l’emulador AVD Manager
10.1.4 jQuery
Es un framework basat en HTML5,
JavaScript i CSS que permet desenvolupar
aplicacions suportades en la majoria de
Sistemes operatius mòbils, implementant un
únic codi, ja que crea una App Híbrida o
WebApp.
JQuery és un software de codi obert. Al igual que altres biblioteques ofereix una
sèrie de funcionalitats pròpies basades en JavaScript, que simplifiquen molt el
desenvolupament i que aconsegueixen grans resultats en menys temps i espai.
La principal funcionalitat que destaca d’aquest Framework, és la que possibilita el
canviar el contingut d’una plana web, sense necessitat de recarregar-la, mitjançant la
manipulació de la estructura del DOM (Document Object Model, és un interfície que
proporciona conjunt estàndard d’objectes utilitzats per a representar documents HTML i
XML, un model estàndard de com aquest es poden combinar i una interfície estàndard per
accedir a ells i manipular-los) i amb peticions AJAX.
29
Avantatges:
i. Gratuït i de codi lliure.
ii. És compatible amb múltiples plataformes.
iii. Compta amb algunes llibreries de disseny que permeten crear aplicacions
amb una estètica intuïtiva d’una manera senzilla i ràpida.
iv. Aplicacions construïdes utilitzant llenguatges web molt comuns.
Inconvenients:
i. La aplicació es desenvolupa utilitzant el motor de la plataforma web i no
objectes individuals propis de d’interfície d’usuari nativa.
ii. No compta amb el seu propi IDE.
iii. Requereix de les llibreries de PhoneGap per a poder accedir als accessoris o
al hardware del dispositiu mòbil.
iv. Calen coneixements de llenguatges de programació: HTML5, CSS y
JavaScript
Requeriments per a la seva utilització:
i. Instal·lació d’un IDE, per exemple Eclipse.
ii. Instal·lació del SDK de Android.
iii. Instal·lar el ADT Pluggin al IDE.
iv. Descarregar les llibreries JQuery Mobile o indicar en el procés de
desenvolupament, on es troben aquestes a traves de rutes web.
v. Instal·lar el JDK.
vi. Opcional: instal·lar l’AVD manager si es vol utilitzar algun emulador.
vii. Opcional: Descarregar les llibreries Cordova, per accedir als accessoris del
dispositiu
Enllaç: https://jquery.com/
10.1.5 Basic4android (B4A):
Producte comercial de Anywhere Software
amb una versió gratuïta, que té com a limitació que
no permet la carrega de llibreries i una versió de
pagament ampliada (Developer estàndard o
Enterprise) que té un cost aproximat de 35 €.
Dirigit al desenvolupament d’aplicacions
natives, el tipus de programació està enfocat a
desenvolupadors habituats a utilitzar Visual Basic, ja
que està inspirat en Microsoft Visual Basic 6 o
Microsoft Visual Studio.
Tot i ser de pagament, existeix una gran
comunitat de desenvolupadors força activa.
Avantatges:
i. Llenguatge de programació orientat a objectes, no requereix saber programar
en XML.
ii. Existeix una gran comunitat de programadors i fòrums on obtenir
documentació.
Figura 12. Logotip Basic 4
Android
30
Inconvenients:
i. La versió gratuïta i limitada en actualitzacions només dura 30 dies, per tant,
per obtenir una versió estàndard o enterprise cal pagar llicencia.
Enllaç: http://www.b4x.com/b4a.html
10.1.6 HyperNext Android Creator
És un sistema dirigit a programadors que comencen, ja que els permet crear les seves
aplicacions sense necessitat de tenir cap coneixement ni Java ni el SDK d’Android.
Esta basat en la metodologia HyperCard, el qual gestiona el software construït com
una pila de targetes, en les que ,només una d’elles pot ser visible en un moment donat,
funcionament que encaixa perfectament amb el model d’aplicació mòbil, que només
disposen d’una finestra a la vegada.
El llenguatge de programació és l’anomenat HyperNext, que està relacionat
HyperCard (sistema hipermedia, és a dir sistema que es compon d’un conjunt de mètodes o
procediments per a escriure, dissenyar o compondre continguts que tinguin text, vídeo,
àudio, mapes o altres mitjans, i que a més, tingui la possibilitat d'interaccionar amb els
usuaris. ) i amb el llenguatge HyperTalk, llenguatge de programació d’alt nivell i similar a
l’Anglès, que a més disposa de moltes funcions específiques per a la creació aplicacions
Android.
Avantatges:
i. És gratuït.
ii. És multi plataforma
iii. Llenguatge de programació propi, però de senzill aprenentatge.
Enllaç: http://www.tigabyte.com/
10.1.7 Kivy
Kivy, és una llibreria Python (Llenguatge de
nivell alt) de codi obert especialitzada en el
desenvolupament d’aplicacions multitàctils amb un
interfície natural d’usuari (NUI, “natural user
interface” ), és a dir, desenvolupament d’aplicacions
que no fan servir dispositius d’entrada , com ratolins,
teclats, etc... sinó que utilitzen moviments gestuals,
en aquest cas dels dits, control per veu o control de
proximitat. És compatible amb una amplia gama de dispositius, i per tant, dona la
possibilitat de mantenir una mateixa aplicació corrent sobre nombrosos sistemes operatius.
Figura 13. Logotip HyperNext Studio
Figura 14. Logotip del Framework
Kivy
31
Avantatges:
i. És gratuïta.
ii. És multi plataforma
iii. EL propi fabricant aporta gran nombre de docuemntació.
Inconvenients:
i. Requereix coneixements de Python.
Enllaç : http://kivy.org/
10.1.8 Qt para Android
Plataforma originàriament creada per Nokia, i actualment de
l’empresa Digia. Qt és una infraestructura multi plataforma per
aplicacions amb o sense interfície gràfica, o eines per a línies de
comandes i consoles per a servidors, que pot abraçar des d’Android,
passant per Linux, iOS, Sailfish OS (https://sailfishos.org/) i Windows.
El desenvolupament d’aquestes aplicacions es fa en C++
estàndard i en Java.
Qt requereix el recolzament d’Android l’NDK i JDK, ja que ell
ja compta amb un potent IDE i un entorn visual.
Avantatges:
i. És gratuït.
ii. És multi plataforma
iii. Té una gran comunitat online de desenvolupadors
Inconvenients:
i. Instal·lació complexa, ja que requereix paquets externs: Andoird NDK,
Android SDK, Apache Ant v1.8 i Java SE Development Kit.
Enllaç: http://www.qt.io/
10.1.9 RFO Basic!
RFO Basic (un dialecte del Basic Dartmouth) és un intèrpret
lliure en el dispositiu, és a dir, que permet escriure i executar
aplicacions directament sobre el propi dispositiu. Aquesta interfície
es caracteritza perquè es capaç de proporcionar accés al hardware,
com per exemple: a la majoria de sensors, al so, gràfics, multi tàctil,
sistema de fitxers, grbació, etc... a més a nivell de elements de
software permet: SQLite, network sockets, FTP, HTTP, Bluetooth,
HTML, CGUI, encriptació, SMS, telèfon, correu, text a veu,
reconeixement de veu, GPS, funcions matemàtiques, funcions de
cadenes de caràcters, llistes i altres utilitats essencials.
És un projecte de codi obert i és també, una plataforma activa i que disposa d’una
gran comunitat de desenvolupadors actius.
Existeixen dues formes de poder executar les aplicacions desenvolupades:
Figura 15. Logotip del
Framework QT
Figura 16. Logotip
RFO Basic!
32
1. Un procés que crea la icona a la pantalla d’inici del dispositiu, i que com a
conseqüència requereix que RFO Basic estigui instal·lat.
2. O, un procés que com a resultat produeix fitxers .apk independents,
perfectament publicables als mercats d’aplicacions.
Enllaç: http://laughton.com/basic/
10.1.10 RubyMotion
Tot i que inicialment era una plataforma dirigida al
desenvolupament d’aplicacions per corre sota el Sistema
Operatiu iOS, l’aparició all mercat de Swift (llenguatge de
programació d’Apple) i altres moviments de la industria, van
provocar que aquesta plataforma, amb un extens nombre de
seguidors, amplies per poder suportar aplicacions sota
Android, cosa que el va fer més atractiu.
És una eina per a desenvolupar aplicacions natives en
Ruby. Ruby és un llenguatge de programació interpretat,
reflexiu i orientat a objectes.
Les aplicacions RubyMotion poden interactuar amb el
joc complet de Java Android APIs i altres les llibreries de Java de tercers que ja estan
compilades estàticament al codi màquina.
Compta amb una bona recopilació de documentació facilitada per el propi fabricant,
així com un gran xarxa de desenvolupadors que aporten més documentació i part de la seva
experiencia.
Enllaç: http://www.rubymotion.com/
10.2 Altres Frameworks més minoritaris:
10.2.1 Rebol 3Saphir
Rebol, es destaca de la resta de Frameworks, bàsicament, perquè té la capacitat de
reduir dràsticament les línies de codi i augmentar la productivitat com cap altre.
És un framework ideal per a desenvolupadors de nivell mig, així com per a
desenvolupar les versions Lite i aplicacions de negoci amb interfícies gràfiques senzilles.
Es basa en una interpretació del codi obert Rebol 3. Tota la funcionalitat de R3,
incloent la interfície gràfica, gràfics, accés a la xarxa, accés a fitxers, anàlisi sintàctic i
altres de les principals funcions portables per Android, Windows, Mac i Linux sense
necessitat de fer modificacions al codi font.
Aquesta plataforma utilitza plantilles “concise dialect” (SDL: Simple DirectMedia
Layer2 ) per a la construcció de interfícies gràfiques d’usuari i per a realitzar operacions
comuns, utilitzant una sintaxis breu i llegible.
2 SDL: llibreria multiplataforma de desenvolupament dissenyada per a proporcionar
accés a baix nivell per a àudio, teclats, ratolí, joystick i gràfics de hardware mitjançant
OpenGL y Dierct3D. La programació es fa bàsicament utilitzant C++, també es poden
utilitzar altres llenguatges com Python, etc..
Figura 17. Logotip
RubyMotion
33
10.2.2 Projecte Simple:
L’objectiu de Simple és ser un llenguatge senzill d’aprendre per al desenvolupament
en la plataforma Android. Es tracta d’un dialecte de BASIC que serveix tant per a
programadors professionals com per afeccionats que permetent escriure ràpidament
aplicacions que utilitzen els components d’execució d’Android.
Similar al Visual Basic 6 de Microsoft, els programes Simple consisteixen en
definicions de formularis (que contenen components) i codi (que conté la lògica de
programa), la interacció dels quals es realitza mitjançant el llançament de esdeveniments
lligats als components. La lògica del programa consisteix en gestors d’esdeveniments, que
executen el codi que tenen vinculat segons el esdeveniment.
Tot i la seva aparent senzilles, aquest projecte no té gaire activitat i la última
actualització del codi es va dur a terme al 2009.
10.2.3 WinDev Mobile
Es tracta d’un entorn de desenvolupament propietari, creat per PC Soft.
Com a llenguatge de programació utilitza Wlanguage, .Net, Java, etc...
És una eina concebuda per a realitzar el desenvolupament ràpid d’aplicacions,
principalment, orientades a dades.
El llenguatge de programació que utilitza, és el W-language, inclòs en el paquet i que
es caracteritza per ser un llenguatge de 4arta generació, simplificat i flexible que permet
obtenir resultats ràpidament.
WinDev, posseeix un IDE propi que permet crear fàcilment interfícies d’usuaris
gràfiques mitjançant drag/drop (arrastrar i deixar). També permet definir interactivament
diferents aspectes sobre l’entrada de dades: mida de la màscara, format automàtic, entrada
obligatòria, etc...
Tot i que inicialment va ser creat per a ser utilitzat sota Windows, WinDev permet
generar aplicacions en Java, així com aplicacions estàndards o aplicacions per a la
plataforma .NET o aplicacions Linux natives. Per al desenvolupament d’aplicacions mòbils
s’utilitza WinDevMobile, que utilitza els mateix llenguatge de programació i els mateixos
conceptes tant per a la generació d’aplicacions o llocs web.
Una tendència d’aquest llenguatge, sobretot a partir de la seva versió número 11, és
la seva especialització integrant funcionalitats dirigides a la domòtica.
10.2.4 GameSalad
Plataforma especialitzada per a la creació de jocs per a
programadors poc experimentats o principiants. És una
plataforma que permet crear les aplicacions utilitzant una
interfície d’arrastrar i deixar conjuntament amb editors
visuals.
Per a crear el jocs, utilitza sistemes lògics basats en el
comportament. Es utilitzada per als dissenyadors gràfics i
programadors per a crea jocs i mitjans interactius per a Figura 18. Logotip
GameSalad
34
diferents dispositius i plataformes (iOS, Android, web a través deHTML5, Kindle o Nook).
10.2.5 Corona SDK
Plataforma dirigida al desenvolupament
d’aplicacions executables sota iOS, Android, amazon
Kindle Fire i Burnes&Noble Nook. El tipus
d’aplicacions a la que va destinada aquesta plataforma
es principalment el desenvolupament de jocs, tot i que
també es pot usar en altres àmbist.
Es tracta en una plataforma basada en C++, però
alhora de desenvolupar es recolza en altres llenguatges,
com Lua3 (llenguatge de programació imperatiu,
estructurat i interpretat). O també amb els funcionament
“drag and drop”, que si es complementen amb diferents
pluggins, es converteix en un entorn molt atractiu per al
desenvolupament de jocs, com per exemple:
i. Kwik: per utilitzar els elements de Photoshop.
ii. Spriteloq: permet la inclusió de arxius Shockwave i l’animació.
iii. Pluggin Caramelo: per a l’obtenció de grans efectes (fum, foc explosions,
etc...)
En altres àmbits, també permet mesclar tecnologia HTML5 amb OpenGL, o utilitzar
funcionalitats empresarials com accedir a bases de dades locasl SQLite, llibreries JSON o
connectivitat asíncrona HTTP per a guarda dades al cloud.
També permet l’accés a algunes de les característ ques que porten actualment els
telèfons intel·ligents, com el GPS, la càmera, les fotos o els giroscopi.
Cal remarcar, que no es gratuït o de codi obert. Compta d’una versió de proba
gratuïta i limitada en el temps per a poder realitzar algunes proves. Per altra banda, si es
desitja distribuir l’aplicació als diferents mercats, és necessari obtenir una llicencia per uns
200€.
10.2.6 Altres entorns per al desenvolupament de jocs:
i. Unity 3D (Multiplataforma) ii. LimeJS
10.2.7 Entorns HTML5 i CSS:
i. Ionic: dedicada a la construcció de aplicacions híbrides. Tot i que treballa
sota PhoneGap o Cordova, ell té el seu propi instal·lador.
ii. Sencha Touch: permet als usuaris el desenvolupament d’aplicacions mòbils
natives per a iPhone, Android i Blacberry (tàctils)
iii. Sculpt: per a dispositius de pantalla petita.
3 Lua va ser creat al 1993 per Roberto Ierusalimschy, Luiz Henrique de Figueiredo y Waldemar Celes basat en C i Perl.
Figura 19. Logotip Corona
SDK
35
iv. Spine Mobile: és un Framework dirigit a la construcció d’aplicacions web
per a mòbils.
v. SideTap: Framework senzill i lleuger, també dirigit a la creació d’aplicacions
web per a mòbils. Aquets, bàsicament es centra en proporcionar una
navegació flexible i similar a la que ja coneixem com des de la creació de
l’aplicació de Facebook.
vi. Moobile: és un macro que es centra en oferir una experiència molt similar a
iOS.
vii. Zoey: creat per a la construcció d’aplicacions mòbils natives. Construït sobre
Zepto.js i amb opció multi plataforma.
viii. IIU: biblioteca de Java i CSS, per al desenvolupament de aplicacions web
amb tecnologia de pantalla tàctil, compatible amb la majoria de telèfons
intel·ligents i tauletes.
ix. Guiño: com en altres plataformes, està destinada bàsicament al
desenvolupament de aplicacions web i ofereix funcionalitats bàsiques com
poden ser la gestió d’events per contacte, manipulació d’objectes DOM, etc...
x. DHTMLX Touch: biblioteca per a la creació de aplicacions web.
xi. RestKit: framework de codi obert, que ha diferencia dels altres permet
interactuar amb els serveis web tipus RESTfull (Serveis que implementen
l’arquitectura REST).
xii. Joshfire: per a la creació d’aplicacions web que es poden executar en
multiplesplataformes com poden ser, ordenadors de sobretaula, telèfons
inteligents, televisors intel·ligents i aparells conectats a la xarxa.
xiii. ChocolateChip UI: ChocolateChip-UI es un marco per al desenvolupament
d’aplicacions web mòbil que utilitza HTML5, WAML, CSS y JavaScript. Es
basa en ChocolateChip Biblioteca JavaScript.
xiv. Zepto.js: biblioteca javascript minimalista per a navegadors moderns amb
una API compatible amb JQuery. També es multiplataforma.
xv. JO: Framework multiplataforma o multi sistema operatiu, vàlid per a crear
aplicacions per a iOS, Android, WebOS, BlackBerry, Chrome OS i qualsevol
altre cosa amb Widgets HMTL5. És de codi obert compatible amb PhoneGap
xvi. Enyo: funciona en tots els navegadores i disposa d’una amplia gama de
plataformes creuades UI widgets, com poden ser Widgets d’interfície
d’usuari, elements de formularis, barres de desplaçament, menús, informació
sobre eines i altres.
36
10.3 Quadre comparatiu entre Frameworks.
FRA
MEW
OR
K
Gra
tuït
o c
od
i Ob
ert
Llic
enci
a d
e p
agam
ent
S.O
. An
dro
id
Mu
lti p
lata
form
a (A
nd
roid
, iO
S, W
ind
ow
s P
ho
ne.
..)
Ap
licac
ion
s N
ativ
es
Ap
licac
ion
s H
íbri
des
Ap
licac
ion
s w
eb
Jocs
Acc
és a
to
t el
Har
dw
are
Fàci
l in
stal
·laci
ó i
pre
par
ació
de
l’en
torn
Gra
n d
ocu
men
taci
ó F
abri
can
t
Gra
n c
om
un
itat
o x
arxa
d’u
suar
is i
des
en
volu
pad
ors
Java
HTM
L 5
, CSS
Llen
guat
ge d
e d
ese
nvo
lup
amen
t p
rop
i
Llen
guat
ge d
irig
it a
ob
ject
es
Alt
res
llen
guat
ges
(Pyt
ho
n, C
++, B
asic
, etc
..)
Ento
rn P
rop
i
Req
uer
eixe
n S
DK
, ND
K..
. en
ton
r n
atiu
...
Android Studio X X X X X X X X X X
Eclipse X X X X X X X X X X X
MIT App Inventor X X X X X X X
PhoneGap X X X X X X X
JQuery X X X X X X X
Basic 4 Android X X X X X X
HyperNext Studio X X X X X X
Kivy X X X X X X X
Qt X X X X X X
RFO Basic X X X X X
RubyMottion X X X X X X
Rebolt 3 Saphir X X X X
Project Simple X X X
WinDev Mobile X X X
Game Salad X X X X X X
Corona SDK X X X X X X X X
37
10.4 Conclusions
Estudiat el sistema operatiu per a dispositius mòbils Android, les seves principals
característiques que poden oferir als usuaris, quines són les seves capacitats i limitacions, i
les diferents opcions que es poden utilitzar per a programar apliaccions en aquest sistema
operatiu, podem deduir que:
i. Android és un dels sistemes operatius amb el major número d’usuaris actius,
fet que garanteix un ampli mercat per als desenvolupadors d’aplicacions.
ii. Android compta amb API potent i en constant evolució, que permet crear
aplicacions utilitzant llenguatges coneguts i extensos. A més, aquest API,
ofereix múltiples opcions i comandes que permeten accedir, manipular i
obtenir dades dels accessoris del dispositiu.
iii. Android disposa al seu voltant de un extens nombre de Frameworks que
permeten desenvolupar aplicacions coma a alternativa al desenvolupament
natiu. Aquest marcs de treball solen utilitzar, de vegades, altres lògiques i
llenguatges de programació però aconseguint els mateixos resultats o els
resultats desitjats. Molts d’aquests frameworks, són multiplataforma,
característica que els fa molt atractius alhora de voler estalviar temps de
desenvolupament, però de vegades, aquests frameworks presenten limitacions
alhora d’accedir a algunes característiques que ens obligaran a tornar al
desenvolupament natiu.
iv. Els frameworks multiplataforma tenen la característica de permetre accés
únicament a les eines comuns a totes les plataformes, en alguna cas es permet
crear pluggins per accedir a elements que no es troben en aquell API, però
aquest pluggins poden eliminar la compatibilitat entre plataformes.
v. Segons els estudi realitzat per Eclipse els anys 2012 i 2013, la majoria de
desenvolupadors utilitzen llibreries natives per a desenvolupar les
aplicacions, tot i que existeix una gran part que prefereix utilitzar frameworks
alterns, generalment basats en HTML + CSS + Java, un clar exemple és
JQuery Mobile, que es la opció majoritària alternativa a la programació
nativa seguida de PhoneGap, amb un tant per cent menor de usuaris.
vi. Existeixen frameworks que utilitzan llenguatges de programació poc comuns
o minoritaris, fet que pot ser dissuasori alhora de escollir-los com a eines de
treball. Per altra banda, es ben conegut, que Java és el segon llenguatge de
programació més utilitzat, fet que podria afavorí la elecció de desenvolupar
aplicacions de forma nativa. App Inventor, per la seva part, proposa la
programació d’aplicacions mitjançant l´’us de blocs visuals, característica que
resulta interessant per a aquelles persones que no desitgen desenvolupar un
codi o no tenen coneixements dels llenguatges de programació.
vii. Cada Framework ofereix facilitats per que el desenvolupador pugui aprendre
a utilitzar-lo, ja sigui perquè el propi fabricant ofereix docuemntació, o
perqueè existeix una gran comunitat al voltant que comparteix les seves
experiencies. La documentació oficial d’Android, és sense dubte la que
compta amb el major suport per part del fabricant com de la xarxa d’usuaris
que conformen una comunitat al voltant d’aquest framework.
viii. L’IDE Eclipse representa l’entorn de desenvolupament integral més
recomanat per aquells frameworks que no compten amb entorn propi i en
necessiten un d’extern.
38
ix. La gran majoria de frameworks son completament gratuïts. Alguns, però,
com Corona SDK, permetent desenvolupar inicialment aplicacions sense cap
cost, però per a genera l’arxiu .apk, és necessari obtenir una subscripció. N’hi
d’altres que són gratuïts però cal pagar per rebre serveis de suport, segons la
versió amb la que es treballi, com per exemple el Sencha Touch.
x. En els casos en que l’aplicació requereixi de l’ús d’elements i eines del
dispositiu com poden ser: la càmera, el reproductor/grabador de só, els
sensors, etc.. sempre és més recomanable utilitzar la programació nativa, ja
que aquesta ofereix la forma més estable, eficaç i diversa d’accedir als
recursos i adaptar-los més facilment a la nostra aplicació, tal i com hem dut a
terme en el desenvolupament. Amb PhoneGap, no sempre es té accés a tots el
elements del dispositiu, per lo que cal utilitzar els coneguta pluggins, que de
vegades poden resultar complicats d’implementar. AppInventor, per la seva
part, només ofereix una fracció de otes les funcionalitats que es troben a les
llibreries natives, fet que el limita notablement. JQuery Mobile,compta amb
un API molt limitat, però per el contrari disposa de múltiples llibreries que li
donen moltes funcionalitats i disseny, això sí, per accedir a les eines i
funcions pròpies del sistema requereix la llibreria de PhoneGap.
xi. Per a escollir l’entorn de treball idoni cal tenir en compte, el temps del que es
disposa per a desenvolupar una aplicació, el tipus i objectiu de l’apliació i els
coneixements previs del programador.
Vistes les característiques d’un gran nombre dels Frameworks disponibles, tant els
avantatges i inconvenients tècnics dels més significatius per volum d’ús, les possibilitats
d’accés a les característiques hardware dels dispositius, les eines i recursos a nivell
formatiu, com poden ser el gran nombre documentació, exemples, tutorials que ofereix el
propi desenvolupador del Framework o la gran xarxa social de desevolupadors que hi ha al
voltant, es pot arribar a la conclusió que l’entorn de treball més recomanat, tot i tenir un
handicap important, que resideix en el nivell de coneixements previs del programador, és
l’Entorn Natiu, ja sigui utilitzant el paquet Android Studio en equips actualitzats (pc’s amb
Windows 7 o superior) o bé la versió Eclipse amb equips de desenvolupament més antics
(Windows XP).
Com he indicat significativament, aquest entorn requereix d’uns coneixements de
programació previs, tot i això, l’aprenentatge pot ser força ràpid degut a l’ajuda existen i de
tota la docuemntació disponibles a la xarxa, ja siguin ofertes per el propi desenvolupador
del Framework o per tota la xara de desevolupadors que hi podem trobar al voltant, que
aporten la seva experiència en l’ús d’aquest entorn.
Un cop assolits certs coneixements i amb més experiència, pot aparèixer l’oportunitat
d’utilitzar altres Frameworks més especialitzats, ja sigui per què em assolit un nivell alt de
programació i coneixement sobre l’entorn Android, perquè l’aplicació que es vol
desenvolupar ens requereix una sèrie d’eines més específiques que altres entorns no natius
en faciliten o perquè es vol que l’aplicació sigui compatible amb altres sistemes Operatius.
39
11 Framework Natiu
11.1 Requisits per a la programació amb Api nativa: Abans de començar, però, a utilitzar aquesta plataforma cal preparar els pc’s amb una
sèrie de programes i configuracions, que permetran usar les funcionalitats pròpies del
sistema Operatiu.
Aquest entorn de treball es pot crear mitjançant un paquet que aglutina quasi totes les
eines necessàries, com és, l’Andorid Studio, o instal·lant per separat i un a un tots els
components necessaris.
Aquests programes i eines són:
11.1.1 SDK:
L’SDK (Software Development Kit) d’Android, és l’encarregat de proporcionar les
biblioteques API i les eines necessàries per a crear, provar i depurar aplicacions per a
Android. Conté una llista amb totes les versions del sistema operatiu que han estat
desenvolupades, així com les seves utilitats i funcionalitats específiques de cadascuna de
les versions. Així doncs, sempre es possible obtenir versions més antigues del sistema
operatiu i poder-ne fer ús i proves.
A més, l’SDK, és l’encarregat de compilar l’aplicació amb tots els recursos i fitxers
en un únic arxiu executable amb extensió “.apk”, aquest arxiu, possibilitarà la instal·lació
de l’aplicació en qualsevol terminal que utilitzi un Sistema Operatiu Android compatible.
Figura 20. SDK Maneger, on es llisten el paquets i llibreries disponibles en el nostre SDK.
40
11.1.2 IDE (Integrated Development Environment):
L’Entorn de Desenvolupament Integrat, és l’encarregada de proporcionar serveis
integrals als programadors per facilitar el seu desenvolupament, per exemple, un dels més
coneguts històricament seria l’“Eclipse”, tot i que actualment ja existeix una nova versió
pròpia, que és l’Android Studio, que aglutina tots els elements necessaris que comentem en
aquest punt en un únic paquet d’instal·lació.
Un IDE, normalment consta de:
i. Editor de codi font.
ii. Un constructor automatitzat d’eines.
iii. Depurador.
Tot i que molts Frameworks d’Android compten amb el seu propi IDE, també
recomana la instal·lació del complement ADT (Android Development Tools Pluggin) que
amplia les capacitats entre l’SDK i l’IDE instal·lats, com per exemple:
i. la ràpida configuració de nous projectes.
ii. la creació de la interfície d’usuari de la aplicació.
iii. el mode d’agregar paquets basats en API’s de Android Framework.
iv. la depuració de les aplicacions utilitzant l’SDK.
v. L’exportació d’arxius .apk signats amb la finalitat de distribuir-los de forma
més massiva.
Figura 21. Captura de l’aspecte que ofereix l’IDE d’Android Studio.
41
11.1.3 JDK (Java Development Kit)
Com ja és ben conegut, és un software desenvolupat per Oracle, que té com objectiu
dotar de eines de desenvolupament per a la creació de programes en Java.
En el nostre entorn Android, s’utilitza bàsicament per crear i depurar aplicacions des
del terminal.
Aquest software no ve incorporat en el paquet Android Studio i cal instal·lar-lo
individualment.
11.1.4 NDK (Native Development Kit)
Són un conjunt d’eines que permeten als desenvolupadors de codi, implementar parts
d’una aplicació utilitzant codi natiu d’altres llenguatges de programació, com per exemple:
C, C++, Basic, etc... En alguns certs casos, aquest paquet ens pot ajudar força, tot i que, en
la majoria d’ocasions no és un paquet d’obligatòria instal·lació.
11.2 Instal·lació del entorn natiu:
11.2.1 Instal·lació del paquet complet d’Android Studio:
Figura 22. Enllaç descàrrega Andoird Studio a la web developers.android.com
Requeriments Windows:
Microsoft® Windows® 8/7/Vista/2003 (32 or 64-bit)
2 GB RAM mínim, 4 GB RAM recomanat
Espai lliure en disc dur: 400 MB
Mínim 1 GB per a l’Android SDK, l’emulador de sistemes d’imatge, i la
caché
Resolució mínima de pantalla: 1280 x 800
Indispensable la instal·lació del Java Development Kit (JDK) 7
Opcional, per a l’acceleració de l’emulador: Intel® processor amb suport per
a Intel® VT-x, Intel® EM64T (Intel® 64), and Execute Disable (XD) Bit
functionality.
42
Enllaç: http://developer.android.com/intl/es/sdk/index.html#win-bundle
Paquet de 820 MB
11.2.2 Descàrrega i instal·lació de Java:
Com a requeriment indispensable, molt remarcada per el fabricant, cal tenir
instal·lada una versió de JDK (Java Development Kit) la qual es pot descarregar fàcilment
des de la web oficial d’Oracle o des de la pròpia web d’Andoird Studio.
Tot i haver disponible la versió 8, el propi fabricant recomana utilitzar seguir
utilitzant la versió 7, dada que podem trobar on s’informa dels requeriments necessaris per
a la instal·lació (https://developer.android.com/intl/es/sdk/index.html#Requirements).
Detall força important alhora d’escollir la versió de Java, cal tenir en compte en
escollir la versió correcta per al nostre sistema operatiu (32 o 64 bits, Win...).
Figura 23. Captura en el procés d’instal·lació del paquet Java
La instal·lació no té cap dificultat, es tracta de un instal·lador estàndard de Windows,
només cal anar llegint les indicacions que ofereix i anar Acceptant, normalment les opcions
per defecte.
11.2.3 Descarregar i instal·lar el paquet Android Studio
Des de la web https://developer.android.com/intl/es/sdk/index.html, podem accedir a
l’instal·lador de la última versió del paquet Android Studio corresponen per al nostre
sistema operatiu.
43
Per a la instal·lació executem l’instal·lador descarregat i seguim les notificacions que
l’assistent ens va mostrant, Acceptant-les normalment les mostrades per defecte. Durant el
procés s’instal·larà el SDK d’Android, els components addicionals per al desenvolupament
sobre Android 5.0, l’emulador d’un dispositiu virtual (AVD) i per suposat tot l’entorn de
desenvolupament d’Android Studio (IDE).
Figura 24. Pantalla inicial del procés de instal·lació d’Andoird Studio.
Al llarg d’aquest procés també s’instal·larà i configurarà, sempre que el pc sigui
compatible, el paquet anomenat Intel Hardware Accelerated Execution Manager o
“HAXM”, que s’encarrega de millorar el rendiment del emulador i que cal activar
previament mitjançant l’accés a la Bios del sistema, on existeix com a funció avançada del
Chipset.
Un altra opció interessant que es pot decidir, és la quantitat de memòria que volem
reservar per al funcionament de l’emulador.
Figura25. Configuració de la memòria destinada a l’emulador en el procés d’instal·lació.
44
Decidides totes les opcions de configuració inicials, el procés d’instal·lació s’inicia i
aquest pot tarda uns quants minuts, depenen de l’equip que es disposi.
Figura 24. Instal·lació en curs Andorid Studio.
Un cop finalitzada la
instal·lació s’iniciarà automàticament
Android Studio i ens donarà l’opció
de reutilitzar la configuració d’alguna
versió anterior, en cas d’haver-ne
tingut alguna, sinó es pot escollir
l’opció de començar sense la
configuració de ninguna versió prèvia
(opció: “I do not have a previous
version of Android Studio or I do not
want to import my settings”.
En la primera execució, l’assistent s’encarregarà automàticament de descarregar i
instal·lar les últimes actualitzacions d’alguns dels components del SDK.
Figura 25. Opció d’importar a Android Studio
els paràmetres de configuració de versions
anteriors.
45
Figura 26. Actualització automàtica dels components recent instal·lats d’Android Studio
L’actualització dels components esmentats en el punt anterior, també es pot dur a
terme, un cop finalitzada la instal·lació, amb l’opció d’actualitzar mitjançant l’SDK
Maneger que podem trobar dins del menú “Configure”.
Figura 27. Pantalla de Benvinguda/ Inicial d’Android Studio.
Un cop finalitzada l’actualització, Android Studio es reiniciarà i tornarem al punt on
estàvem, és a dir, a la pantalla de Benvinguda de la figura anterior.
46
11.2.4 Configuració inicial de l’entorn Android Studio
Un altre factor recomanable un cop finalitzada la instal·lació, és comprovar si les
rutes tant del SDK com la del JAVA siguin les correctes. Per fer-ho,existeix l’opció
“Configure” de la pantalla de benvinguda, que ens donarà pas a la pantalla de “Project
Defaults” i després a la de “Project Structure”, on mitjançant la finestra d’opcions
revisarem l’apartat “SDK Location”, on podem introduir o editar les rutes dels mòduls
indicats.
Figura 28. Pantalla de configuració de la ubicació dels directoris SDK i Java a Andoird
Studio
Un cop feta la comprovació, acceptem els canvis mitjançant el botó OK i tornem al
menú de benvinguda.
11.2.5 Instal·lar/actualitzar els components del SDK de Android.
En aquest punt se’ns permet actualitzar els components bàsics del SDK o instal·lar
altres components addicionals que ens poden ser útils o necessaris per els desenvolupament
de la nostra aplicació. Aquest menú sempre és accessible i en qualsevol moment si pot
accedir per a poder complementar la nostra instal·lació inicial.
En cas de voler fer alguna de les accions esmentades, només cal accedir al menú
“Configure”, apartat “Configure SDK”, dins aquesta pantalla, anirem a l’opció “SDK
Manager”, eina que ens permet instal·lar, desinstal·lar o actualitzar qualsevol dels
components disponibles.
El propi fabricant recomana que com a mínim caldria instal·lar/actualitzar els
següents components:
i. Android SDK Tools: eines que donen accés a moltes de les característiques
per al desenvolupament, aixó com comandaments i altres facilitats per al
disseny de la interfície d’usuari.
ii. Android SDK Platform-tools
47
iii. Android SDK Buid-tools: component indispensable per a la construcció del
codi, per defecte, el SDK sempre utilitza la última versió descarregada i
instal·lada.
iv. Versions recents de la plataforma Andorid: força rellevant, degut a que
conté els components i llibreries necessàries per al desenvolupament sobre
les versions concretes d’Android, si volem que la nostra aplicació sigui
funcional en diferents versions, caldrà instal·lar totes les versions en les que
volguem que sigui compatible
v. Android Support Repository (opcional)
vi. Google Play Services (opcional)
vii. Google Repository (opcional)
Figura 29. Captura del SDK Maneger.
Un cop escollits els components, cliquem sobre el botó “Install Packages...”,
acceptem els llicenciaments corresponents i esperem que finalitzi el procés de descàrrega i
instal·lació.
48
En el cas de voler utilitzar l’IDE Eclipse, tot i que actualment Google ha deixat de
desenvolupar el pluggin per a Android, s’hauria de fer una instal·lació per parts seguint els
següents passos:
11.3 Android per parts o en entorn Eclipse.
11.3.1 Descàrrega i instal·lació de Java.
Per a realitzar la instal·lació i al igual que en el procés anterior,és imprescindible,
comprovar la versió del JDK (Java Development Kit) que tenim al pc i instal·lar la última
versió disponible que es pot trobar a la web d’Oracle.
Cal recordar, que cal instal·lar la versió adequada al processador dels nostres equips,
comprovant si es necessita una versió de 32 bits o 64 bits.
Un cop escollida i descarregada la versió correcte, només cal executar l’instal·lador
descarregat i seguir les instruccions que indicades, normalment escollint les opcions
mostrades per defecte.
11.3.2 Descàrrega i instal·lació d’Eclipse.
Per a instal·lar aquest mòdul cal descarregar-lo a la web oficial https://eclipse.org. Es
recomana descarregar la última versió del paquet anomenta “Eclipse IDE for Java
Developers” i la que correspongui al sistema on ha d’anar instal·lat, ja sigui de 32 o 64
bits, al igual que el Sistema Operatiu corresponent (Windows/Mac/Linux).
La instal·lació consisteix simplement en descomprimir el fitxer zip descarregat,
executar eclipse.exe i seguir les indicacions, com per exemple, indicar quina serà la carpeta
per emmagatzemar els projectes de les aplicacions, es pot deixar la que existeix per defecte
i marcar el checbox “Use this as the default“. És molt important saber quina es aquesta
ubicació, ja que si en algun moment es vol començar a fer servir Android Studio com a
eina de desenvolupament, existeix la possibilitat d’importar els projectes realitzats amb
Eclipse, tal i com s’indica al punt 11.1.2
Figura 30. Captura del procés d’instal·lació on s’ha d’indicar la ubicació dels projectes.
49
11.3.3 Descarregar el SDK d’Android.
Aquest paquet es pot descarregar a la web oficial http://developer.android.com, a
l’apartat de “Desarrollar/Herramientas/Installing the Android SDK”, en aquesta secció
caldrà escollir l’opció “Stand Alone SDK Tools”, en cas contrari s’escollirà el paquet
corresponent a Android Studio.
El paquet descarregat, només inclou les eines bàsiques del SDK, a les que es poden
accedir mitjançant línea de comandes o a també inclou un pliggin per poder utilitzar l’IDE
favorit, que es vulgui, en el nostre cas usarem Eclipse.
En la instal·lació, només cal seguir les instruccions pertinents que se’ns mostra a
l’executar l’instal·lador descarregat.
11.3.4 Instal·lar els paquets addicionals del SDK.
Per defecte, el SDK, no inclou totes les eines necessàries per a començar a
desenvolupar, l’SDK separa eines plataformes i altres components en paquets que es poden
descarregar segons les nostres necessitats, l’obtenció d’aquest compoenents es pot
gestionar a traves del gestor SDK Manager.
Per començar a descarregar la resta de components no instal·lats que es necessiten,
executarem l’arxiu SDL Maneger.exe que es pot trobar al directori arrel de la instal·lació
del SDK. El primer cop que s’executa aquest gestor, ja existeixen una sèrie de paquets
preseleccionats, els quals es recomana descarregar, a més de seleccionar els que
considerem necessaris per als nostres projectes.
Aquest procés és l’homòleg del punt 11.1.4, en la instal·lació d’Android Studio.
Figura 31. SDK Maneger.
50
Com es pot veure a la imatge anterior, a més de poder descarregar les eines com:
Android SDK Tools, o Android SDK Platform-tools, també es poden obtenir totes les
versions anteriors d’Android que considerem necessàries per a que la nostra aplicació
funcioni.
Aquest procés d’actualització pot ser força llarg tot depenent del nombre de paquets
a instal·lar.
Figura 32. Captura de la informació mostrada per l’SDK en el procés d’actualització.
11.3.5 Configuració d’un AVD (Android Virtual Device)
Alhora de provar i depurar les aplicacions creades, no és del tot necessari fer-ho
directament sobre un dispositiu físic, sinó que existeix la possibilitat d’utilitzar un
emulador o un dispositiu virtual (AVD).
Per això, és necessari accedir al AVD Maneger, i escollir l’opció Virtual Devices, en
aquesta secció es poden escollir tants dispositius com es necessitin, com per exemple, un
dispositiu per a cada versió d’Android que es vulgui utilitzar.
Figura 33. Vista de l’emulador AVD amb dos dispositius configurats.
51
Per a configurar cada dispositiu, nomes cal indicar el seu nom descriptiu, la versió de
Sistema Operatiu Android que es vol i les característiques de hardware del dispositiu
virtual, com per exemple: resolució i mides de la pantalla, capacitat de la targeta SD, etc...
Figura34. Pantalla per a la configuració dels dispositius d’emulació al AVD.
11.3.6 Descarrega i instal·lació del Pluggin per Eclipse
Tot i que des del web del proveïdor, insisteixen en migrar cap a Android Studio, es
permet descarregar aquest pluggin per seguir treballant amb Eclipse, sempre i quan aquest
cumpleixi els següents requisits:
i. Tenir instal·lat Eclipse 3.7.2 (Indigo) o posterior. (Eclipse 3.6, ja no és
compatible amb la última versió disponible de l’ADT)
ii. Eclipse JDT complet
iii. JDK 6, instal·lant únicament el JRE no és suficient.
Un cop es compleixen els requeriments indicats, caldrà agregar el pluggin a Eclipse,
per a dur a terme aquest procés seguirem les següents passes:
i. Arranquem Eclipse
ii. Al menú Ajuda, seleccionem Instal·lar nou software
iii. Cliquem el botó Add, que apareix a la cantonada superior dreta.
iv. EN el quadre de dialeg que apareix, escrivim el nom del paquet, per
exemple “ADT pluggin” al camp “Nombre” i afegim la següent adreça URL
de la ubicació:
https : //dl-ssl.google.com/android/eclipse/.
v. Acceptem
vi. A continuació anem avançant clicant el botó “Next” varies vegades.
vii. Llegim i acceptem els acords de llicencia i cliquem a “Finish” per tal de
finalitzar el procés.
52
viii. Un cop finalitzada la instal·lació, caldrà reiniciar Eclipse.
ix. Un cop es reinicia, cal especificar la ubicació del directori SDK de
l’Android, cosa que pot dur a terme des de la finestra de Benvinguda on
apareix l’opció “Use SDKs existentes”, seleccionant el directori on està
ubicat l’SDK.
53
12 Estructura d’un projecte en Android Studio.
El primer pas per a crear una aplicació en Android és necessari la creació d’un
projecte, en el nostre cas, el crearem amb l’Android Studio i per tant el nostre projecte
seguirà la estructura típica que crea el nostre Framework, en cas d’utilitzar una altre
Framework, aquesta estructura pot variar.
12.1 Creació d’un projecte en Android Studio pas a pas Per a la creació d’un projecte, ho farem des de la pantalla de benvinguda escollint
l’opció “Start a new Android Studio Project”.
Figura 35. Finestra de Benvinguda a Android Studio.
Un cop creat un projecte, és molt possible que a partir d’aquest moment, cada cop
que accedim a Android Studio, es precarregui el projecte creat, sense haver de passar per la
pantalla de benvinguda.
Si volem crear un projecte i no se’ns obra la pantalla de benvinguda, ho podrem fer
des del menu superior clicant sobre “File”, “New project”.
A partir d’aquí, l’assistent ens guiarà per escollir les diferents opcions que definiran
la nostra aplicació i per tant el nostre projecte.
En la primera pantalla que ens mostra l’assistent, és on indicarem el nom de
l’aplicació, el domini de la companyia, y la ruta on es crearà el nou projecte.
54
Figura 36. Captura d’una pantalla en el creació d’un nou projecte.
En la següent pantalla que ens mostrarà l’assistent, és on configurarem els dispositius
on s’utilitzarà la nostra aplicació, així com l’API mínima (versió d’Android mínima) que
soportarà la nostra aplicació. Alhora d’escollir aquesta opció, cal tenir en compte, que quan
més antiga sigui la versió que suporti, en més dispositius serà compatible la nostra
aplicació, però tindrem menys característiques de desenvolupament disponibles, cosa que
dificultarà que l’aplicació s’executi correctament en totes les plataformes.
55
En cas, de no tenir clara
quina versió escollir, sempre
podem clicar sobre l’opció
“Help me choose”, que ens
mostra una taula de distribució
percentual del nombre de
dispositius que utilitzan en
aquest moment cada versió de
Android, dades que es ajudaran
a decidir a escollir quina es la
versió mínima.
A més, si cliquem sobre
cada versió, se’ns mostra com
a informació addicional,
quines novetats s’han introduït
en cada versió.
Figura 38. Pantalla d’ajuda per a la selecció de paràmetres en la configuració del nou
projecte.
Per exemple, si escollim com a versió mínima, la 4.1 Jelly Bean, de nivell d’API 16,
estarem arribant a un 78,3% dels dispositius.
Figura 37. Exemple 1 de la configuració d’alguns
paràmetres en un nou projecte.
56
En la següent pantalla de l’assistent, escollirem el tipus d’activitat principal
(“activity”) de l’aplicació. Entendrem activitat, com “finestra” o “pantalla” de l’aplicació.
Normalment, seleccionarem l’opció per defecte “Blank Activity”.
Figura 39. Exemple 2 de la configuració d’alguns paràmetres en un nou projecte.
En la següent pantalla de l’assistent, omplirem les dades associades a l’activitat
principal seleccionada anteriorment, indicarem:
Activity Name: nom, que servirà per crear, també, la classe vinculada.
Layout Name: nom de la interfície gràfica
Title: el títol que apareixerà...
Menu Resource Name: Nom del menú principal.
Figura 40. Exemple 3 de la configuració d’alguns paràmetres en un nou projecte.
57
Un cop introduïdes tots aquestes dades, pitjarem el botó “Finish” i Android
s’encarregarà de crear tota l’estructura del projecte així com els elements indispensables
que ha de contenir.
Després d’una estona de processament, i si tot és correcte, apareixerà la pantalla
inicial del nou projecte creat.
Figura 41. Aspecte del entorn de treball davant d’un nou
projecte.
A la part esquerra, s’hi troben tots els elements creats
inicialment per al nou projecte Android seguint una de les
següents estructures segons com escollim la visió.
La estructura clàssica es caracteritza per tenir una
estructura jerarquia diferenciada, una carpeta única de
projecte i que engloba tots la resta de elements. Dins d’un
mateix projecte podem incloure diferents mòduls, que poden
representar diferents aplicacions, tot i que en la majoria dels
casos es recomana incloure una única App per projecte. EL
modul de l’aplicació s’ubica a la carpeta App. En l’exemple
de la imatge, tenim un projecte que es diu “XXXXX” que
conté la carpeta App que contindrà tot el software de
l’aplicació.
Dins la carpeta que conté l’aplicació (carpeta App) hi
trobarem una altra estructura que conté una sèrie de carpetes
que passem a detallar:
Figura 42. Captura del
menú de carpetes de com
s’estructura un projecte
58
12.1.1 Carpeta /app/src/main/java
Aquesta carpeta contindrà tot el codi font de l’aplicació, les classes auxiliars, etc...
Inicialment, Android Studio crearà per nosaltres el codi base de la pantalla principal de
l’aplicació (Activitat) en el nostre cas anomentat “MainActivity”.
12.1.2 Carpeta /app/src/main/res/
Conté tots els arxius de recursos necessaris per el projecte: imatges, layouts, cadenes
de text, etc.. Els diferents tipus de recursos es poden distribuir entre les diferents
subcarpetes.
CARPETA DESCRIPCIÓ
/res/drawable/ Conté les imatges i elements gràfics usats en la aplicació.
Normalment es diferencies els recursos segons la resolució i la
densista de la pantalla dels dispositius en subcarpetes:
/drawable: recursos independents de la densitat
/drawable-ldpi: baixa densistat
/drawable.mdpi: densitat mitja
/drawable-hdpi: densitat alta
/drawable-xhdpi: densitat molt alta
/drawable-xxhdpi: densitat molt molt alta
/res/layout/ Conté els arxius de definició XML de les diferents pantalles
de l’interficie gràfica. En aquesta carpeta també es diferencien
dues carpetes segons la orientació de la pantalla en l’aplicació:
/layout: orientació vertical
/layout-land: orientació horitzontal
/res/anim/
/res/animator/
Contenen les animacions utilitzades a la aplicació
/res/color/ xxxxxxxxxxxxxxxxxxxxxxxxx
/res/menu/ Conté la definició XML dels menús de l’aplicació
/res/xml/ Conté altres fitxers XML de dades utilitzats a l’aplicació
/res/raw/ Conté recursos addicionals de format diferent al XML i que
tampoc s’inclouen en cap de les altres carpetes específiques.
/res/values/ Conté altres fitxers XML on es defineixen alguns valors
dels recursos de l’aplicació, com per exemple:
cadenes de text (string.xml)
estils (styles.xml)
colors (colors.xml)
etc...
Per defecte, totes aquestes carpetes no tenen per que aparèixer en tots els projectes,
únicament apareixeran les que anem necessitant.
59
Per defecte les que apareixen en un projecte acostumen a ser:
Segons els tipus de compatibilitat escollit,
a vegades poden aparèixer carpetes amb un
sufix específic, com per exemple “values-
w820dp”, en les quals s’emmagatzemen
recursos específics per a dispositius, en aquest
cas, amb pantalles amb una amplitud major a
820 dp.
Un altre exemple molt típic, és el “values-
v11” on s’emmagatzemaran els recursos per a
dispositius amb versió d’Android 3.0 (API11) o
superior.
D’aquest sufixos n’hi ha una gran llista la
qual podem consultar a: http://developer.android.com/guide/topics/resources/providing-
resources.html, al punt “Table 2”
Entre els recursos creats per defecte, cal destacar els “layouts”, en el nostre cas
només tindrem, inicialment, el fitxer anomenat “activity_main.xml” , el qual conté la
definició de la interfície gràfica de la pantalla principal de l’aplicació. Si es clica sobre
aquest arxiu, Andoid Studio ens mostrarà en l’editor gràfic aquesta interfície.
12.1.3 Fitxer /app/src/main/AndroidManifest.xml
Aquest conté la definició en XML de molts aspectes principals de l’aplicació, com
per exemple: la seva identificació (nom, icona...), els seus components (pantalles, serveis,
....) o els permisos necessaris per a la seva execució.
12.1.4 Fitxer /app/build.gradle
Conté informació necessària per a la compilació del projecte, com per exemple la
versió del SDK d’Android utilitzada, la mínima versió d’Android que suportarà l’aplicació,
referencies a les llibreries externes utilitzades, etc...
En un projecte poden existir diferents fitxers build.gradle, per a definir determinats
paràmetres a diferents nivells. Per exemple, un que definirà els paràmetres globals de tots
els mòduls del projecte i un altre, situat a la carpeta App, que sols tindrà efecte sobre el
mòdul corresponent de la carpeta.
12.1.5 Carpeta /app/libs
Conté les llibreries java externes (fitxers “.jar”) que utilitzarà la nostra aplicació.
Normalment per a que aquestes llibreries entrin en el procés de compilació de l’aplicació
caldrà fer-ne referència al fitxer build.gradle.
Figura 43. Llistat de les carpetes
d’un nou projecte.
60
12.1.6 Carpeta /app/build/
Conté una sèrie d’elements de codi generats automàticament al compilar el projecte.
Cada vegada que es realitza una compilació del projecte, el compilador d’Android genera
per nosaltres una sèrie de fitxers font java dirigits, entre d’altres coses, al control dels
recursos de l’aplicació. Molt important i a tenir en compte: no modificar mai manualment
aquest fitxers generats automàticament després del procés de cada compilació.
Figura 44. Captura dels components que conformen la carpeta build en un nou projecte.
Destacar el fitxer, que podem observar que apareix desplegat en la imatge anterior,
anomenta “R.java” on es defineix la classe R, la qual, contindrà en tot moment una serie de
constants amb els identificadors (ID) de tots els recursos de la aplicació inclosos a la
carpeta /app/src/main/res/, de forma que podem accedir a ells fàcilment des del nostre codi
mitjançant aquesta dada.
12.2 Components d’una aplicació Android. En els punts anteriors, hem vist l’estructura bàsica d’un projecte d’Andorid i on
col·locar cada uns dels elements que componen l’aplicació, ja siguin elements de software
com elements gràfics o de dades. A continuació ens centrarem específicament, en els
elements de software, amb els que podrem construir la nostra aplicació.
Android disposa duna sèrie d’elements bàsics:
12.2.1 Activitat/Activity:
Les activiats (activities) representen els component principal de l’interficie grafica
d’una aplicació Android. Es pot fer l’equivalència com elements anàlegs entre activitat i
finestra o pantalla de l’aplicació.
12.2.2 Vista/View:
Les vistes són els components bàsics amb els que es construeix d’interfície gràfica
d’una aplicació. Android, posa a la nostra disposició una gran quantitat de control bàsics,
com per exemple: quadres de text, botons, llistes desplegables o imatges, tot i això, també
podem ampliar la funcionalitat d’aquest controls o crear-ne de porpis.
12.2.3 Servei/Service:
Són components sense interfície gràfica que s’executen en segon pla, com els de
qualsevol altre sistema operatiu. Els serveis poden realitzar qualsevol tipus d’acció, com
per exemple: l’actualització de dades, activar notificacions o inclús mostrar elements
visuals.
12.2.4 Proveïdors de Continguts/Content Provider.
Són el mecanisme que fan possible la compartició de determinades dades de la nostra
aplicació sense desvelar detalls sobre el mode d’emmagatzament intern, la seva estructura
61
o la seva implementació. De la mateixa forma, la nostra aplicació pot accedir a dades de
tercers utilitzan el mateix sistema de “Content Providers” que s’hagin definit.
12.2.5 Broadcast Reciver.
És un component que té com objectiu detectar i reaccionar davant determinats
missatges o events globals generats pel sistema, com per exemple: Bateria baixa, SMS
rebut, Targeta SD insertada, etc... o també generats per d’altres aplicacions, anomenats
“intents”, és a dir, missatges o events no dirigits a una aplicació concreta sinó a qualsevol
que els vulgui escoltar.
12.2.6 Widget.
Elements visuals, normalment interactius, que es poden mostrar en la pantalla
principal (home screen) i rebre actualitzacions periodiques. També permetent mostrar
informació de l’aplicació als usuaris directament sobre la pantalla prinicipal.
12.2.7 Intent.
Com ja comentàvem anteriorment, és tracta d’un element bàsic de comunicació entre
els diferents components Android que hem descrit. Es poden entendre com els missatges o
peticions que son enviats entre els diferents components d’una aplicació o entre diferents
aplicacions amb la finalitat de mostrar una activitat, iniciar un servei, enviar una missatge
broadcast, iniciar una altra aplicació, etc...
62
13 Creació d’una aplicació senzilla
Com exemple a totes les investigacions fetes fins al moment, intentaré crear una
petita aplicació bàsica que intenta crear una comunicació entre dos dispositius mitjançant
el bluetooth del dispositiu. Un cop creada, utilitzarem l’emulador del Framework prt
intentar provar el seu funcionament.
13.1 Procés de creació de l’aplicació.
13.1.1 Fase I: Creació del projecte.
Seguint les passes documentades en l’apartat “12.1 Creació d’un projecte en Android
Studio pas a pas”, comencem el procés de creació del nostre nou projecte. Un cop clicat
l’opció “Start a new Android Studio Project”, tal i com mostra la Figura 35, en apareix la
següent pantalla on definirem el nom de la nostra aplicació, en aquest cas s’anomenarà
“TFC Bluetooth”. En aquesta mateixa pantalla, també quedarà definit el Nom de la
Companya, que deixarem el que hi ha per defecte, i automàticament es definirà el nom de
l’empaquetament, una combinació entre el nom de l’aplicació i el Domini de la Companyia
Figura 45. Pantalla de configuració del nom de l’aplicació a crear.
63
Un cop complimentats els camps requerits, fem clic a “Next”, i s’ens mostrarà la
següent finestra.
Figura 46. Pantalla de configuración del mínim SO amb el que serà compatible l’aplicació
a crear.
En aquesta pantalla es defineixen les versions mínimes del SDK per a cadascuna dels
tipus de dispositius per al qual estiguem creant l’aplicació. En el nostre cas, únicament
estem desenvolupant un aplicació per a mòbil, per tant, només caldrà definir el mínim
SDK per aquesta plataforma, que seria l’opció Phone and Tablet.
Per aquesta aplicació, i degut a les característiques de l’aplicació, és a dir, que és una
aplicació força senzilla que no requerirà de cap característica especial, tant de hardware
com de libaries o mòduls externs per el seu desenvolupament, únicament requerià del
servei de Bluetooth i una mica d’interficie, podem escollir una versió que sigui compatible
per la majoria de dispositius, en aquest cas, si consultem les versions d’Android mitjançant
el “Help me choose...” ens mostra que la versió compatible amb la majoria de dispositius,
un 99,5%, es la versió Android 2.2 (Froyo) - API 8, que és la que escollim.
Per la resta de tipus de dispositius, com ja hem comentat, no escollim res ja que la
nostra aplicació no va dirigida a aquest tipus d’aparells.
64
En el la següent finestra, haurem d’escollir el tipus d’activitat principal, recordar que
l’activitat, o “Activity”, representen el component principal d’una aplicació i que es pot fer
l’analogia amb finestra o pantalla de l’aplicació.
Figura 47. Pantalla de configuració del tipus d’activitat principal que tindrà la nova
aplicació.
En el nostre cas escollirem l’opció per defecte, “Blank Activity” i clicarem sobre el
botó Next per continuar el procés.
Figura 48. Introducció dels paràmetres que defineixen el tipus d’activitat escollit.
65
En la finestra que ens trobem, és en la que es definirà algunes de les característiques
de l’Activitat que hem escollit, com per exemple el nom, el nom de la interfície gràfica
vinculada, el títol, etc... en el nostre cas, ja que és un cas d’exemple, deixarem tots els
valors per defecte, i així posteriorment podrem aprendre com canviar aquest valors des de
dins del projecte.
Finalment i després d’una estona en el que Android Studio realitza una sèrie de
processos interns per a construït totes les parts del projecte, apareixerà la pantalla principal
del nostre projecte per poder començar a crear la nostra aplicació.
Figura 49. Entorn de treball on es crearà la nova aplicació.
13.1.2 Fase II: Factors inicials.
En primer lloc i fonamental, alhora de crear una aplicació que utilitzi una
característiques de comunicació com el Bluetooth o qualsevol altre, sempre, cal comprovar
si la característica en qüestió està disponible, o no. Com a conseqüència, serà indispensable
afegir els permisos adequats accedir a les opcions que ens ofereix aquest dispositiu, això
cal fer-ho al fitxer AndroidManifest.xml.
Cal recordar, que el fitxer AndroidManifest.xml, és on es defineixen els principals
aspectes de la nostra aplicació, com per exemple: identificació, components, permisos, etc.
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
66
En l’Annex 1, es veu com queda l’arxiu definitiu AndroidManifest.xml una cop
acabat l’aplicació.
13.1.3 Fase III: Creació de la interfície gràfica.
Inicialment, voldrem que la nostra
aplicació realitzi diferents funciona bàsiques per
establir una comunicació:
1. Activar i desactivar el Bluetotth.
2. Mostrar dispositius disponibles.
3. Aparallar-se amb altres dispositius.
4. Llistar dispositius ja aparellats.
Per a dur a terme aquestes funcions
necessitarem alguna interfície gràfica que ens
permeti interactuar i realitzar les accions
definides anteriorment, a més de poder
comprovar en tot moment quin es l’estat del
nostre dispositiu en tot moment, per això
utilitzarem una sèrie de botons, llistats, etc. que
ens ho permetran.
Dins la carpeta “res/layout”, definirem
aquest elements, en el document
activity_main.xml (Annex 2), de tal manera que
ens quedaria una pantalla com la següent, que
ens mostra l’opció Preview d’Android Studio, en
aquest cas tenim definit un dispositiu tipus
Nexus 4, que és el que ve definit per defecte.
Començarem definint la pantalla i
capçalera on mostrarem el nom de l’aplicació i
que contindrà la resta d’elements:
<RelativeLayout
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=".MainActivity" >
. . .
</RelativeLayout>
Després definirem l’etiqueta que ens mostrarà l’estat del bluetooth del nostre
dispositiu en tot moment.
<TextView
Figura 50. Previsualització de
l’entorn gràfic de la nostra aplicació.
67
android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="@string/Text" / “Estat: -“ (valor)
/>
Continuarem amb els botons per activar i desactivar el Bluetooth:
<Button
android:id="@+id/BTOn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/on" / “Activar BT“ (valor)
/>
<Button
android:id="@+id/BTOff"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/off" / “Desactivar BT“ (valor)
/>
Ara seguirem amb el botó del Llistat de Dispositius Aparellats, que al clicar ens
mostrarà en la llista de la part inferior (ítem 1, ítem 2, ítem 3...) els aparells amb els quals
ens em aparellat en el passat i el botó per a la recerca de nous dispositius, els quals també
mostrarà en el mateix llistat un cop haguem fet clic sobre el botó.
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical"
android:layout_marginTop="80dp" >
<Button
android:id="@+id/paired"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
//Text: “Llistat de dispositius aparellats“
android:text="@string/List" />
<Button
android:id="@+id/search"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
//Text: “Troba nous dispositius / Cancel·la“
android:text="@string/Find" />
<ListView
android:id="@+id/listView1"
android:layout_width="fill_parent"
android:layout_height="200dp" >
68
</ListView>
</LinearLayout>
Per a una millor gestió dels texts utilitzats en l’aplicació, aquests, els definirem com
a variables les quals haurem de especificar posteriorment dins el fitxer xml que
anomenarem strings.xml (Annex 3) el qual trobarem dins la carpeta “res/values” i que
quedarà de la següent forma:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">BluetoothTest</string>
<string name="action_settings">Settings</string>
<string name="Text">Estat: -</string>
<string name="on">Activar BT</string>
<string name="off">Desactivar BT</string>
<string name="List">Llistat de dispositius aparellats:</string>
<string name="Find">Troba nous dispositius / Cancel</string>
</resources>
13.1.4 Fase IV: Creació de l’activitat principal.
Per comunicar-nos amb el dispositiu Bluetooth cal utilitzar una classe anomenada
BluetoothAdapter. Utilitzarem l’instancia getDefaultAdapter(), de la següent forma:
myBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
Segons el resultat que ens retorni prendrem diferents accions, en el cas que el valor
retornat sigui NULL, significarà que el nostre dispositiu no disposa de Bluetooth, i per
tant, desactivarem tots els botons, mostrarem “Estat: no disponible” i completarem la
informació mostrant un pop-up que indicarà: “El seu dispositiu no suporta el Bluetooth”
if(myBluetoothAdapter == null) {
onBtn.setEnabled(false);
offBtn.setEnabled(false);
listBtn.setEnabled(false);
findBtn.setEnabled(false);
text.setText("Estat: no disponible");
Toast.makeText(getApplicationContext(),"El seu dispositiu no
suporta el Bluetooth",
Toast.LENGTH_LONG).show();
}
69
Per activar el Bluetooth, el primer que ha de fer la nostra aplicació, es comprovar si
el aquest sí està activat. Sinó, cridem el procediment starActivityForResult() més l’acció
ACTION_REQUEST_ENABLE. El segon paràmetre del mètode aplicat, és un nombre
enter, el qual, si és major que zero el sistema torna cap oneActivityResult() per mostrar
l’estat del dispositiu, o per el contrari crida el disable() per tal de desactivar-lo.
public void on(View view){
if (!myBluetoothAdapter.isEnabled()) {
Intent turnOnIntent =
new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(turnOnIntent, REQUEST_ENABLE_BT);
Toast.makeText(getApplicationContext(),"Bluetooth Activat"
Toast.LENGTH_LONG).show();
}
else{
Toast.makeText(getApplicationContext(),"Bluetooth ja està
activat",
Toast.LENGTH_LONG).show();
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {
if(requestCode == REQUEST_ENABLE_BT){
if(myBluetoothAdapter.isEnabled()) {
text.setText("Estat: Activat");
} else {
text.setText("Estat: Desactivat");
}
}
Per a realitzar una connexió a un dispositiu mitjançant el Bluetooth és necessari
conèixer la direcció d’aquest i que a més es trobi disponible. Es possible realitzar un
aparellament (pairing) entre dos dispositius de tal manera que es “recordi” i s’autoritzi
aquest dispositiu per a futures connexions. Tot i això, sempre es necessari realitzar una
primera connexió, per dur-la a terme, utilitzarem el procediment starDiscovery()
Aquest procés de detecció triga aproximadament uns 12 segons, i es tracta d’un
element o dispositiu que realitza la recerca i un altre element o dispositiu que es deixa
descobrir. Cal tenir en compte que els dispositius Android, ja sigui per defecte o per motius
de seguretat, tenen el Bluetooth desactivat, romanent així, en estat ocult, de tal manera que
els altres dispositius que es troben realitzant operacions de descobriment no poden accedir
a la informació d’aquests. Per a poder ser descobert, cal canviar la visibilitat de forma
explicita.
public void find(View view) {
if (myBluetoothAdapter.isDiscovering()) {
70
// Si es prem el botó mentre està descobrint, aquest
procés es cancel·la
myBluetoothAdapter.cancelDiscovery();
}
else {
BTArrayAdapter.clear();
myBluetoothAdapter.startDiscovery();
registerReceiver(bReceiver, new IntentFilter
(BluetoothDevice.ACTION_FOUND));
}
}
Per recollir tota la informació del dispositius descoberts, farem ús d’un
BroadcastReciver, combinat amb l’accioó: ACTION_FOUND, que ens avisarà cada cop
que es descobreixi un dispositiu, del qual, emmagatzemarem el nom i la direccio Mac a la
taula creada (BTDispositius).
final BroadcastReceiver bReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
// Quan el process descobreix un dispositiu
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
// obté la info des del Intent
BluetoothDevice device =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
// Afeigeix al info a la taula (Nom i direcció Mac)
BTArrayAdapter.add(device.getName() + "\n" +
device.getAddress());
BTArrayAdapter.notifyDataSetChanged();
}
}
};
Finalment es recomana cancel·lar el procés de descobriment, ja que aquest
consumeix molts recursos, per lo que utilitzarem el cancelDiscovery()
myBluetoothAdapter.cancelDiscovery();
71
Conclusions finals:
El món de les comunicacions avança molt ràpidament, i cada dia és major el número
de programadors interessats a desenvolupar aplicacions per a sistemes operatius mòbils.
Android com una de les plataformes líder en aquest mercat i amb un nombre elevat
d’usuaris es converteix en un camp d’alt interès per als empresaris.
En aquest sentit, mitjançant aquest projecte hem pogut observar que a més de la
programació nativa, existeixen un gran nombre d’entorns i alternatives que permeten
arribar als mateixos resultats utilitzant lògiques i llenguatges diferents. Per tant, no es pot
considerar que existeix un framework que representi la millor alternativa per a
desenvolupar tot tipus d’aplicacions, sinó que l’elecció del millor framework depèn en
cada moment: segons el tipus i objectius d’aplicació i els coneixements previs dels
programadors. El cost del framework i les seves limitacions o facilitats que ofereix alhora
de desenvolupar aplicacions, són també altres factors determinats alhora de fer una elecció.
La programació nativa, és la que ofereix més amplia varietat de funcionalitats i
esdeveniments, convertint-se per aquest motiu amb l’opció escollida per a desenvolupar les
aplicacions que requereixen múltiples accessos a característiques i accessoris del
dispositiu.
També, el fet de que la programació nativa compti amb entorns de treball cada dia
més complerts i senzills d’obtenir, amb processos de instal·lació i actualització dirigits,
com el d’Android Studio, i a més, disposar d’una extensa documentació oficial i una gran
comunitat de desenvolupadors que aporten la seva experiència, fan que es converteixi
inicialment amb el sistema més escollit per aquesta comunitat de desenvolupadors.
Posteriorment, quan s’obté més experiència en el desenvolupament d’aplicacions
sota el sistema operatiu Android o es tenen altres necessitats o requeriments és quan els
desenvolupadors busquen altres entorns alternatius que els ofereixen millors condicions de
treball o optimització dels recursos. Per exemple, el desenvolupament en JQuery Mobile o
Sencha Mobile, els quals mitjançant l’ús de llibreries permeten obtenir aplicacions
personalitzables amb una bona interfície d’usuari i estètica, però invertint un esforç menor
i acceptant les limitacions que aquestes alternatives tenen.
Per altre banda, també existeixen frameworks, com l’AppInventor, senzills, que no
requereix de gaires coneixements de programació, amb moltes limitacions i que aposten
per una programació visual i no de codi, aquest tipus d’entorns van dirigits a un públic
força específic i totalment diferent al esmentat en els punts anteriors, però que
possiblement amb el temps i l’experiència, acabin utilitzant altres entorns més complexes.
També queda palès, que amb la potencia i capacitats que ofereixen avui en dia els
entorns de treball natius, sobretot el que em utilitzat, Android Studio, el desenvolupament
d’aplicacions mòbils requereix d’un esforç considerable d’aprenentatge per arribar a
dominar les eines que aquest ofereixen i poder conèixer quins són els límits de cada
dispositiu o sistema operatiu.
72
Com es tracta d’un camp quasi inabastable, el projecte deixa oberta moltes
possibilitat d’investigació, algunes poden ser:
Instal·lació i ús dels entorns alternatius a la programació nativa.
Comparació del tipus de programació entre entorns.
Diferencies entre les eines oferides en cada entorn
Exploració de la limitacions d’accés a les característiques dels dispositius que
tenen els entonrs multiplataforma quan es desenvolupen aplicacions
exclusives per a Android, val la pena utilitzar aquests frameworks en aquest
casos?
Etc...
Finalment, sota el meu punt de vista personal, la realització d’aquest projecte m’ha
despertat un gran interès en el desenvolupament d’aplicacions mòbils, tant per un
creixement a nivell de coneixements propis, com aplicat la opció d’aprofitar els
coneixements adquirits en el món laboral, ja que com hem vist aquest és un mercat en alça
i en continua evolució.
73
Referències: [1] https://es.wikipedia.org/wiki/Wikipedia:Portada [Informació General sobre Android] 2015
[2] Medición de la sociedad de la información 2013: Unión Internacional de Telecomunicaciones, 2013, https://www.itu.int/en/ITU-D/Statistics/Documents/publications/mis2013/MIS2013-exec-sum_S.pdf
[3] Informe sobre Medición de la socidad de la información 2014, Resumen ejecutivo: Unión
Internacional de Telecomuncaciones, 2014,
http://www.itu.int/en/ITU-D/Statistics/Documents/publications/mis2014/MIS_2014_Exec-sum-S.pdf
[4] 2014 Annual Eclipse Comunity Report: Eclipse Foundation, 2014,
https://eclipse.org/org/foundation/reports/2014_annual_report.php
[5] 2013 Annual Eclipse Comunity Report: Eclipse Foundation, 2013,
https://eclipse.org/org/foundation/reports/2013_annual_report.php
[6] 2013 Annual Eclipse Comunity Report: Eclipse Foundation, 2014,
https://eclipse.org/org/foundation/reports/2013_annual_report.php
[7] http://developer.android.com/intl/es/index.html [Informació general sobre Android Studio] 2015
[8] https://www.eclipse.org/home/index.php [Informació general sobre IDE Eclipse] 2015
[9] https://www.eclipse.org/forums/index.php/t/225513/ [Ajuda sobre instal·lació d’Eclipse] 2015
[10] http://appinventor.mit.edu/ [Informació general sobre MIT AppInventor] 2015
[11] http://appinventor.mit.edu/explore/ai2/tutorials.html [Tutorials d’AppInventor]
[12] http://phonegap.com/ [PhoneGap] 2015
[13] http://phonegap.com/blog/ [Blog de la Comunitat de PhoneGap] 2015
[14] https://jquery.com/ [Informació general JQuery Mobile] 2015
[15] http://www.b4x.com/ [Informació general sobre Basic 4 Android] 2015
[16] http://tigabyte.com/ [Informació general sobre HyperNext] 2015
[17] http://kivy.org/#home [Informació general sobre Kivy per Android] 2015
[18] http://www.qt.io/ [Informació general sobre Qt per Android] 2015
[19] http://laughton.com/basic/ [Informació sobre RFO Basic]
[20] http://rfobasic.com/ [Comunitat de RFO Basic] 2015
[21] http://www.rubymotion.com/ [Informació general sobre RubyMotion] 2015
[22] http://development.saphirion.com/rebol/saphir/ [Informació general sobre Rebolt 3 Saphir] 2015
[23] http://learnrebol.com/rebol3_book.html [Manual d’ús de Rebolt 3 Saphir]
[24] https://plus.google.com/communities/114791428968349268860 [Comunitat de desenvolupadors
d’Android] 2015
[25] http://android-developers.blogspot.com.es/ [Android Developers Blog]
[26] https://developer.android.com/intl/es/sdk/installing/create-project.html [Creació de projectes en
Android Studio] 2015
[27] http://developer.android.com/intl/es/tools/studio/index.html [Estructura dels projectes Android] 2015
[28] https://developer.android.com/intl/es/training/index.html [Iniciació a Android Studio]
[29] http://developer.android.com/intl/es/reference/android/bluetooth/package-summary.html
[Funcionalitats per al desenvolupament amb Bluetooth] 2015
[30] Por qué Android enamora a todo el mundo: Javier Elío, El Android Libre, 24/12/2014
[31] Sockets en Android: Sebastian Cipolat, Androidety.com, 05/08/2012
[31] http://developer.android.com/intl/es/samples/connectivity.html [Exemples de programes amb
Bluetooth] 2015
[32] Bluetooth (I): Activando y desactivando el Bluetooth en Android: Let’s Code Something Up!,
19/10/2014
[33] Ranking de Sistemas Operativos más utilizados en 2015: Nicolàs Montés, Blog de la Universidad
Cardenal Herrera, 02/2015
74
Annex 1
Codi referent al fitxer AndroidManifest.xml:
<? Xml version = "1.0" codificación = "UTF-8"?>
<Manifiestan xmlns: android =
"http://schemas.android.com/apk/res/android"
paquete = "com.javacodegeeks.android.bluetoothtest"
android: versionCode = "1"
android: VersionName = "1.0">
<Usos-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "19" />
<Usa-permiso android: nombre =
"android.permission.BLUETOOTH" />
<Usa-permiso android: nombre =
"android.permission.BLUETOOTH_ADMIN" />
<Aplicación
android: allowBackup = "true"
android: icon = "@ estirable / ic_launcher"
android: label = "@ string / nombre_apl"
android: tema = "@ style / AppTheme">
<Actividad
android: nombre =
"com.javacodegeeks.android.bluetoothtest.MainActivity"
android: label = "@ string / nombre_apl">
<Intención de filtro>
<Acción android: nombre =
"android.intent.action.MAIN" />
<Categoría android: nombre =
"android.intent.category.LAUNCHER" />
</ Intención de filtro>
</ Actividad>
</ Aplicación>
</ Manifiesto>
75
Annex 2
Codi referent al fitxer activity_main.xml:
<RelativeLayout
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=".MainActivity" >
<TextView
android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="@string/Text" />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:layout_marginTop="30dp" >
<Button
android:id="@+id/BTOn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/on" />
<Button
android:id="@+id/BTOff"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/off" />
</LinearLayout>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical"
android:layout_marginTop="80dp" >
<Button
android:id="@+id/paired"
android:layout_width="wrap_content"
76
android:layout_height="wrap_content"
android:text="@string/List" />
<Button
android:id="@+id/search"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/Find" />
<ListView
android:id="@+id/listView1"
android:layout_width="fill_parent"
android:layout_height="200dp" >
</ListView>
</LinearLayout>
77
Annex 3
Codi referent al fitxer strings.xml:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">TFC Bluetootht</string>
<string name="action_settings">Settings</string>
<string name="Text">Estat: -</string>
<string name="on">Activar BT</string>
<string name="off">Desactivar BT</string>
<string name="List">Llistat Dispositius Aparellats:</string>
<string name="Find">Toba nous dispositius / Cancel</string>
</resources>
78
Annex 4
Codi referent al fitxer Activity_main.xml:
package com.javacodegeeks.android.bluetoothtest;
import android.os.Bundle;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import java.util.Set;
import android.content.Intent;
import android.content.IntentFilter;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity {
private static final int REQUEST_ENABLE_BT = 1;
private Button onBtn;
private Button offBtn;
private Button listBtn;
private Button findBtn;
private TextView text;
private BluetoothAdapter myBluetoothAdapter;
private Set<BluetoothDevice> pairedDevices;
private ListView myListView;
private ArrayAdapter<String> BTArrayAdapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
myBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if(myBluetoothAdapter == null) {
onBtn.setEnabled(false);
offBtn.setEnabled(false);
listBtn.setEnabled(false);
findBtn.setEnabled(false);
text.setText("Status: not supported");
79
Toast.makeText(getApplicationContext(),"El seu dispositiu
no soporta el Bluetooth",
Toast.LENGTH_LONG).show();
} else {
text = (TextView) findViewById(R.id.text);
onBtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
on(v);
}
});
offBtn = (Button)findViewById(R.id.turnOff);
offBtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
off(v);
}
});
listBtn = (Button)findViewById(R.id.paired);
listBtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
list(v);
}
});
findBtn = (Button)findViewById(R.id.search);
findBtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
find(v);
}
});
myListView = (ListView)findViewById(R.id.listView1);
// crea una taula que contindra els dispositius, I els
// mostra en una
BTArrayAdapter = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1);
myListView.setAdapter(BTArrayAdapter);
}
80
}
public void on(View view){
if (!myBluetoothAdapter.isEnabled()) {
Intent turnOnIntent =
new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(turnOnIntent, REQUEST_ENABLE_BT);
Toast.makeText(getApplicationContext(),"Bluetooth activat"
Toast.LENGTH_LONG).show();
}
else{
Toast.makeText(getApplicationContext(),"Bluetooth ja
activat",
Toast.LENGTH_LONG).show();
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {
// TODO Auto-generated method stub
if(requestCode == REQUEST_ENABLE_BT){
if(myBluetoothAdapter.isEnabled()) {
text.setText("Status: Enabled");
} else {
text.setText("Status: Disabled");
}
}
}
public void list(View view){
// mostra els dispositius ja aparellats
pairedDevices = myBluetoothAdapter.getBondedDevices();
for(BluetoothDevice device : pairedDevices)
BTArrayAdapter.add(device.getName()+ "\n" +
device.getAddress());
Toast.makeText(getApplicationContext(),"Mostra dispositius
aparellats",
Toast.LENGTH_SHORT).show();
}
final BroadcastReceiver bReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
// Quant el process descobreix un dispositiu
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
// Obté un disposotiu des del “intent”
BluetoothDevice device =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
81
// Afegeix la informació del dispositiu a la taula
BTArrayAdapter.add(device.getName() + "\n" +
device.getAddress());
BTArrayAdapter.notifyDataSetChanged();
}
}
};
public void find(View view) {
if (myBluetoothAdapter.isDiscovering()) {
// si es torna a premer el botó, el procés es cancel·la
myBluetoothAdapter.cancelDiscovery();
}
else {
BTArrayAdapter.clear();
myBluetoothAdapter.startDiscovery();
registerReceiver(bReceiver, new
IntentFilter(BluetoothDevice.ACTION_FOUND));
}
}
public void off(View view){
myBluetoothAdapter.disable();
text.setText("Estat: Desactivat");
Toast.makeText(getApplicationContext(),"Bluetooth desactivat",
Toast.LENGTH_LONG).show();
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
super.onDestroy();
unregisterReceiver(bReceiver);
}
}
