IN1kCDUCCICN Androld es hoy por hoy uno de los slsLemas operaLlvos con ms oporLunldades, donde un desarrollador puede crear apllcaclones que sean conocldas a nlvel mundlal uuranLe 10 semanas hemos esLado publlcando en IAsAndro|d un curso en el que aprender a hacer una apllcacln desde cero. Pa sldo reallzado por kobert ., uno de los edlLores del blog que Llene a sus espaldas ya algunas apllcaclones, como Pu ConLacL hoLos. Ll curso ha sldo recopllado en esLe ul compleLamenLe graLulLo para Lenerlo a mano en un solo lugar. 1amblen hay a dlsposlcln de qulen qulera usarlo un nILC CIICIAL del curso en loromvlles.com: http:]]foromov||es.com]threads]479-Curso-de-programac|n-andro|d INDICL 1. lnsLalacln de Lcllpse y del Suk 2. LsqueleLo de una apllcacln 3. AcLlvldades y layouLs 4. anLallas de conflguracln de la apllcacln 3. 1hreads 6. CapLura de evenLos 7. Comunlcacln con oLras apps 8. WldgeLs 9. Servlclos 10. CbLener permlsos de superusuarlo www.FreeLibros.me
3
CAI1ULC 1 Insta|ac|n de| Andro|d SDk y Lc||pse Cada vez que Coogle publlca una nueva versln de su slsLema operaLlvo, y mucho anLes de que esLa llegue a cualqulera de sus Lelefonos de forma oflclal, los de MounLaln vlew publlcan el SDk (SofLware uevelopmenL klL) del slsLema, que conLlene una lmagen de esLe y Lodos sus programas, asl como del framework de Androld, y que slrve a los desarrolladores para adapLar sus apllcaclones a la nueva versln anLes de que esLa llegue al gran publlco. ara poder gesLlonar Lodo esLe slsLema de verslones y subverslones en un slsLema operaLlvo vlvo, como es el caso de Androld, resulLa necesarlo un sofLware que se encargue LanLo de la slncronlzacln de los paqueLes e lmgenes (denomlnamos lmagen a una copla compleLa de una parLlcln) ya lnsLaladas, como de la lnsLalacln de los nuevos de forma lo ms LransparenLe poslble. Ln este cap|tu|o aprenderemos a |nsta|ar e| gestor de paquetes SDk de Andro|d, fundamenta| para poder desarro||ar ap||cac|ones para este s|stema, as| como e| entorno de desarro||o de ap||cac|ones Lc||pse, que s| b|en no es e| ms senc|||o de ut|||zar, s| que es e| ms comp|eto y ut|||zado por desarro||adores de m|t|p|es p|ataformas.
Gestor de paquetes SDk ara ello Coogle proporclona el SDk Manager, un programa que se slncronlza con los servldores de Coogle y que nos lnforma LanLo de la dlsponlbllldad de nuevos paqueLes como del esLado de los que ya Lenemos. La apllcacln esL dlsponlble LanLo para enLornos Wlndows como MAC CS x y Llnux, sl blen eo este tototlol oos ceottotemos eo lo vetslo poto slstemos Mlctosoft wloJows. www.FreeLibros.me
4 Ln el caso de Wlndows la lnsLalacln de la apllcacln puede reallzarse medlanLe un arch|vo compr|m|do, en formato z|p, que deberemos descomprlmlr en el dlrecLorlo ralz del slsLema (hablLualmenLe c.\) o blen medlanLe un lnsLalador, lo que mlnlmlza no slo el Llempo ocupado en el proceso, slno Lamblen las probabllldades de error (en caso que opLemos por el lnsLalador, es convenlenLe lndlcar el dlrecLorlo c.\ooJtolJ- sJk-wloJows como dlrecLorlo de lnsLalacln cuando el slsLema nos lo pregunLe). una vez reallzada la lnsLalacln deberemos e[ecuLar el programa SDk Manager.exe que, al abrlrlo por prlmera vez, proceder a descargar e lnsLalar el resLo de archlvos necesarlos para la apllcacln y que no se lncluyen en la descarga lnlclal, para lo cual neceslLar acceder a lnLerneL. una vez que el gesLor de Suk esLe compleLamenLe lnsLalado, procederemos a lnsLalar las verslones del Suk que neceslLemos, dependlendo de las verslones del slsLema para las cuales vayamos a desarrollar (en nuesLro caso se recomlenda la lnsLalacln de la versln 13, correspondlenLe a Androld 4.0.3). Ls lmporLanLe que lnlclemos el gesLor de paqueLes varlas veces, lnsLalando las acLuallzaclones que hublera, hasLa que el slsLema gesLor lndlque que no hay acLuallzaclones dlsponlbles. Aslmlsmo, en deLermlnados ordenadores, dependlendo de la conflguracln de red, flrewalls, proxys, eLc puede ocurrlr que no se sea poslble esLablecer una conexln segura (hLLps), en cuyo caso es poslble forzar la descarga a Lraves de una conexln lnsegura (hLLp) accedlendo a la conflguracln del gesLor (1ools - Optloos) y marcando la casllla fotze bttps sootces to be fetcbeJ osloq bttp.
www.FreeLibros.me
3 A[ustes manua|es Ln algunos slsLemas Wlndows es necesarlo deflnlr una varlable de enLorno denomlnada ANukOlu_5uk_nOM, cuyo conLenldo ha de ser la ruLa compleLa al dlrecLorlo de lnsLalacln del 5uk, para que Lodo funclone correcLamenLe.
ue lgual manera, en los slsLemas unlx, deben anadlrse los dlrecLorlos [dlrecLorlo- lnsLalacln]/plaLform-Lools y [dlrecLorlo-lnsLalacln]/Lools al paLh de slsLema (varlable de enLorno lA1n). Insta|ac|n de Lc||pse Lc||pse es un entorno de desarro||o de ap||cac|ones muy potente y que d|spone de p|ug|ns para |a mayor|a de |os |engua[es de programac|n, entre e||os Andro|d, que de hecho es un subcon[unLo de un lengua[e mayor denomlnado !ava, que fue desarrollado orlglnarlamenLe por Sun y adapLado posLerlormenLe por Coogle. La lnsLalacln de Lcllpse es muy sencllla y cons|ste en descompr|m|r e| conten|do de un arch|vo z|p, que conLlene la apllcacln y las llbrerlas, en el dlrecLorlo de nuesLra eleccln (recomendamos c.\ecllpse). una vez lnsLalado, procederemos a acceder al mlsmo, haclendo doble cllc en el lcono de la apllcacln, que se encuenLra en el dlrecLorlo que hayamos creado para la mlsma (sl lo deseamos podemos crear un acceso dlrecLo al esctltotlo de la forma hablLual). www.FreeLibros.me
6
La prlmera vez que accedamos nos pregunLar por el dlrecLorlo de Lraba[o, que ser aquel en el que se ublcarn Lodos los programas que desarrollemos. or comodldad, resulLa convenlenLe marcar la casllla que lndlca al slsLema que nuesLra eleccln es deflnlLlva, lo cual lmpedlr que, en prxlmas e[ecuclones, se nos vuelva a pregunLar por dlcho dlrecLorlo. |ug|n AD1 para Lc||pse Como hemos lndlcado, Lcllpse es un enLorno de desarrollo muy poLenLe dlsponlble para gran canLldad de lengua[es, a Lraves de los pluglns correspondlenLes. Ll Au1 (Androld uevelopmenL 1ools) es el plugln desarrollado por Coogle para permlLlr la lnLegracln del Suk de Androld en Lcllpse, permlLlendo el desarrollo de programas Androld de forma naLlva desde Lcllpse. La lnsLalacln se reallza manualmenLe desde el proplo Lcllpse slgulendo los slgulenLes pasos: 1. Selecclonar nelp - lostoll oew softwote, 2. Pacer cllc en oJJ, en la parLe superlor derecha de la venLana, 3. Ln el dllogo lndlcar Au1 lugln" como oombte y hLLps://dl- ssl.google.com/androld/ecllpse como locollzoclo, 4. Pacer cllc en ok, 3. Ln la venLana que aparezca, marcar la casllla [unLo a uevelopet 1ools y hacer cllc en oext, 6. Pacer cllc en el boLn oext (cuando aparezca), 7. Leer y acepLar el acuerdo de llcencla y hacer cllc en flolsb, www.FreeLibros.me
7 8. Al acabar la lnsLalacln, y anLes de reallzar los pasos slgulenLes, relnlclar ecllpse. Al relnlclar Lcllpse, aparecer una venLana en la que nos lndlcar que, para desarrollar en Androld es necesarlo lnsLalar el Suk. Paremos cllc en la opcln use exlstloq 5uks" e lnLroduclremos la ruLa del dlrecLorlo de lnsLalacln que corresponda (comunmenLe c.\ooJtolJ-sJk-wloJows). Slo en caso que no apareclera el dllogo lndlcado en el aparLado anLerlor, deberemos enlazar el Au1 con el gesLor de paqueLes Suk de Androld manualmenLe, para lo cual reallzaremos los slgulenLes pasos (en Lcllpse): 1. Selecclonar wloJow - ltefeteoces, 2. Selecclonar AoJtolJ en el panel de la lzqulerda, 3. !unLo al cuadro 5uk locotloo, hacer cllc en 8towse y navegar hasLa selecclonar el dlrecLorlo en el que se ha lnsLalado el gesLor de Suk (comunmenLe c.\ooJtolJ-sJk-wloJows), 4. Pacer cllc en opply y despues en ok.
Creac|n de una mqu|na v|rtua| Ll gesLor de paqueLes Suk lncluye un emu|ador Andro|d que podremos e[ecuLar para probar nuesLras apllcaclones. ue hecho, e| gestor se |ntegra tan b|en con Lc||pse que podremos |nc|uso debugar las apllcaclones, generar punLos de parada, comprobar los valores de las dlferenLes varlables, eLc. www.FreeLibros.me
8 ara crear la mqulna vlrLual correspondlenLe a una versln concreLa de Androld deberemos abrlr el gesLor de paqueLes Suk y acceder a Moooqe Avus, denLro del menu tools.
ara crear una lnsLancla del emulador haremos cllc en el boLn oew en la venLana de gesLln de mqulnas vlrLuales, procedlendo a rellenar los campos correspondlenLes del formularlo con los valores que slgue: name: lCS 1argeL: Androld 4.0.3 - Al Level 13 Cu/A8l: A8M (armabl-v7a) Su Card: Slze 32 mb 1amblen ser necesarlo anadlr soporLe para la Lar[eLa de memorla, para lo cual haremos cllc en el boLn oew en el aparLado correspondlenLe a hardware del formularlo, procedlendo a selecclonar la propledad 5u cotJ 5oppott, Lras lo cual haremos cllc en ok y posLerlormenLe en cteote Avu. Andro|d en tu C una vez creado el emulador podemos e[ecuLarlo, para lo cual lo haremos cllc en su nombre (en la panLalla de gesLln de mqulnas vlrLuales, y posLerlormenLe selecclonaremos stott. Ls normal que el emulador Larde unos mlnuLos en arrancar, dependlendo de la poLencla del ordenador en el que lo e[ecuLemos. www.FreeLibros.me
9
Ln el prxlmo caplLulo hablaremos de las dlferenLes parLes de una apllcacln Androld y crearemos nuesLra prlmera apllcacln de prueba, que e[ecuLaremos en el emulador.
www.FreeLibros.me
10
CAI1ULC 2 Lsque|eto de una ap||cac|n Andro|d
La esLrucLura de las apllcaclones en Androld se orlenLa claramenLe al usuarlo, o qulzs serla ms exacLo declr a su dlsposlLlvo. Ln cualquler caso, usuarlo y dlsposlLlvo se expresan en una lengua, y esLe ulLlmo, adems, Llene unas caracLerlsLlcas flslcas deLermlnadas y e[ecuLa una u oLra versln del slsLema. Asl, como veremos a conLlnuacln, cuando creemos una ap||cac|n deberemos tener en cuenta |as caracter|st|cas de |os d|spos|t|vos a |os que se d|r|ge, tanto en |o re|ac|onado con e| hardware como con |a vers|n de Andro|d que |o contro|a.
L| man|f|esto L| man|f|esto (archlvo moolfest.xml en cualquler proyecLo Androld) es un arch|vo en formato kML (e\teoslble Motkop looqooqe) en e| que se def|nen |as caracter|st|cas genera|es de una ap||cac|n, a saber: Ll paqueLe: Ls una cadena que descrlbe de forma unlca a una apllcacln, no slendo poslble anadlr una apllcacln en la lay SLore sl ya exlsLe oLra con el mlsmo nombre de paqueLe. ue lgual manera, sl lnsLalamos en nuesLro dlsposlLlvo una app con el mlsmo nombre (de paqueLe) que oLra ya exlsLenLe, la nueva susLlLulr a la anLerlor. Ll nombre: Ls el nombre que aparecer en la Llenda, o el nombre que nos ensena el lnsLalador cuando nos dlsponemos a lnsLalar la apllcacln. La versln: Ll slsLema deflne dos numeros dlferenLes para la versln de una apllcacln: por un lado el numero de compllacln, que debe lncremenLarse en suceslvas acLuallzaclones (no es poslble acLuallzar en la Llenda una app con un numero de compllacln lnferlor al de la versln exlsLenLe). ? por oLro el numero de la versln, que es el numero que se mosLrar al usuarlo y sobre el que no hay resLrlcclones. La versln de Androld a la que se dlrlge: Se lndlca en esLe punLo la versln (mlnlma y mxlma) necesarla para que la apllcacln se e[ecuLe correcLamenLe, www.FreeLibros.me
11 no slendo poslble lnsLalar una apllcacln en un dlsposlLlvo que Lenga una versln de Androld que no se encuenLre en el rango especlflcado. Los permlsos: LlsLa de permlsos que neceslLa la apllcacln para e[ecuLarse correcLamenLe, y que se le presenLarn al usuarlo cuando lnsLale la apllcacln. 1al y como hemos lndlcado en alguna ocasln, Andro|d no soporta an que e| usuar|o se|ecc|one qu perm|sos desea otorgar, de entre |a ||sta de perm|sos so||c|tados, asl que esLe deber acepLarlos Lodos para poder lnsLalar la apllcacln. LlsLa de acLlvldades, servlclos y recepLores de mensa[es: Lnumeraremos en esLe aparLado las acLlvldades (venLanas) de nuesLra apllcacln, asl como los servlclos que esLa ofrecer y los procesos de recepcln de mensa[es, asl como los parmeLros que acLlvarn cada uno de ellos, sl los hublera.
L[ecutar un programa Ln Andro|d |os programas no s|o se e[ecutan cuando e| usuar|o |os |nvoca, haclendo cllc en el lcono correspondlenLe en el urawer, por e[emplo, s|no que stos tamb|n se act|van automt|camente depend|endo de| estado de| s|stema. Como veremos en las prxlmas seslones, es poslble lndlcar que una apllcacln, o un servlclo ofrecldo por esLa, debe e[ecuLarse auLomLlcamenLe cuando el dlsposlLlvo se lnlcle, o cuando se reclba una llamada o un mensa[e, por e[emplo. Id|omas Al prlnclplo de esLe arLlculo nos referlamos al ldloma del dlsposlLlvo, pues blen, en Andro|d podemos persona||zar |a |engua en |a que se muestra nuestra ap||cac|n de forma transparente tanto a| usuar|o como a |a prop|a ap||cac|n. www.FreeLibros.me
12 ara ello, lglcamenLe, deberemos lnclulr en nuesLra apllcacln las Lraducclones de las dlferenLes cadenas que vlsuallzamos en esLa. Ll dlrecLorlo tes, en un proyecLo Androld, conLlene Lodos los daLos relaclonados con los recursos de una apllcacln, Lales como lmgenes, a las que nos referlremos a conLlnuacln, y cadenas de caracLeres. Asl, deberemos crear un dlrecLorlo voloes-\\ (donde \\ es un cd|go de |d|oma) para cada una de las lenguas a las que Lraduzcamos nuesLra apllcacln, lncluyendo en dlcho dlrecLorlo un archlvo sttloqs.xml con la descrlpcln de Lodas las cadenas en ese ldloma concreLo. Ll proplo slsLema se encargar de acceder al archlvo correcLo dependlendo del ldloma que se encuenLre acLlvo en el dlsposlLlvo, sl es que hemos Lraducldo nuesLra apllcacln a ese ldloma, o al ldloma por defecLo (lncluldo en el dlrecLorlo voloes) en caso conLrarlo. Ls una norma no escrlLa que en el lengua[e por defecLo de una apllcacln Androld es el lngles, por lo que las cadenas en lngles se lnclulrn en el archlvo sttloqs.xml del dlrecLorlo tes/voloes. AdlclonalmenLe, y como veremos, Lamblen es poslble crear cadenas que varlen segun la versln de Androld del dlsposlLlvo en el que se e[ecuLe la apllcacln.
www.FreeLibros.me
13 Imgenes 1al y como ocurre con los ldlomas, es pos|b|e y en muchos casos necesar|o, espec|f|car |mgenes e |conos d|ferentes para cada una de |as reso|uc|ones de panta||a de Andro|d. no hacerlo supondr que nuesLra apllcacln se ver correcLamenLe en los dlsposlLlvos con una resolucln de panLalla slmllar a la usada duranLe el desarrollo pero no en dlsposlLlvos con panLalla ms pequena, o ms grande. La resolucln de una panLalla la deflne la relacln exlsLenLe enLre el Lamano de la mlsma (que se suele descrlblr segun el Lamano en pulgadas de esLa) y la densldad de plxeles (que es el numero de esLos que caben en una pulgada), lo que nos permlLe hablar de panLallas pequenas (lJpl), medlanas (mJpl), grandes (bJpl) y exLra grandes (xbJpl). lnclulremos las lmgenes relaLlvas a cada una de las resoluclones en el dlrecLorlo tes/Jtowoble-\\ (donde \\ es la resolucln de panLalla) que corresponda. ue lgual manera, el dlrecLorlo tes/Jtowoble lnclulr las lmgenes que no camblan al camblar la resolucln de la panLalla, sl las hublera.
www.FreeLibros.me
14 "no|a mundo" Crearemos a conLlnuacln una pequena apllcacln (de prueba), que no har nada salvo escrlblr un mensa[e en la panLalla de nuesLro emulador, o de nuesLro Lelefono sl la lnsLalamos en esLe, pero que nos permlLlr comprobar los concepLos expllcados en esLe caplLulo. ara ello reallzaremos los slgulenLes pasos: 1. Abrlr Lcllpse, 2. Selecclonar llle - New - AoJtolJ ptoject en el menu de Lcllpse, 3. Lscrlblr Ml ptlmet ptoyecto AoJtolJ" en el cuadro ltoject Nome" y hacer cllc en Next, 4. Selecclonar AoJtolJ 4.0.J en la llsLa y hacer cllck en Next, 3. lndlcar com.fopsAoJtolJ.nellowotlJ" en el cuadro lockoqe Nome" y hacer cllck en llolsb. Pecho esLo, comprobaremos que en la vlsLa lockoqe xplotet" de Lcllpse ha aparecldo un elemenLo denomlnado Ml ptlmet ptoyecto AoJtolJ", sobre el que podremos hacer doble cllc para ver los dlferenLes elemenLos que hemos comenLado en esLe LuLorlal. Ln cuanLo a los dlrecLorlos qeo y blo, son dlrecLorlos lnLernos de Lcllpse y no convlene ellmlnarlos nl modlflcarlos, mlenLras que el dlrecLorlo stc conLlene el cdlgo de nuesLro programa, que en esLe caso slo crea una venLana que muesLra un mensa[e de LexLo. Sl e[ecuLamos la apllcacln, comprobaremos que aparece en panLalla el anslado Pello World". Lllo es debldo a que el esqueleLo de una apllcacln Androld lncluye una unlca venLana que muesLra el menclonado mensa[e en panLalla. Sl lo desels, podels camblar el valor de la cadena bello" en el archlvo tes/voloes/sttloqs.xml. Ln prxlmos caplLulos aprenderemos a modlflcar esLe esqueleLo para adapLarlo a nuesLras necesldades concreLas, asl como a crear oLras venLanas segun nuesLras necesldades. L[ecuc|n en e| emu|ador ara e[ecuLar esLe programa en el emulador Lan slo es necesarlo hacer cllc con el boLn derecho del raLn en el nombre de nuesLra apllcacln y selecclonar koo As - AoJtolJ Appllcotloo en el menu emergenLe, o hacer cllc dlrecLamenLe en el boLn e[ecuLar de la barra de boLones de Lcllpse.
www.FreeLibros.me
13 L[ecuc|n en un d|spos|t|vo Sl por el conLrarlo, preferlmos e[ecuLar la apllcacln en nuesLro dlsposlLlvo, deberemos exporLarla, para lo cual reallzaremos los slgulenLes pasos: 1. Selecclonar el nombre de la apllcacln en la vlsLa lockoqe xplotet, 2. Pacer cllc con el boLn derecho del raLn en el nombre de la apllcacln y selecclonar xpott en el menu emergenLe. 3. Selecclonar AoJtolJ - xpott AoJtolJ Appllcotloo en la panLalla que aparezca y pulsar Next. 4. ulsar Next, La prlmera vez Lendremos que crear nuesLro olmoceo Je cloves, para lo cual selecclonaremos cteote oew keystote", selecclonaremos una ruLa para el almacen de claves (del que convendr|a tener cop|a de segur|dad) e lnLroduclremos la conLrasena del mlsmo, que guardaremos en lugar seguro, Lras lo cual haremos cllc en Next. Ln caso que ya hayamos flrmado alguna apllcacln (o esLa mlsma en alguna oLra ocasln), selecclonaremos use exlstloq keystote", procedlendo a lnLroduclr la ruLa del almacen en el cuadro correspondlenLe, asl como su conLrasena, Lras lo cual haremos cllc en Next. Ln la slgulenLe panLalla, en caso de que acabemos de crear el almacen de cerLlflcados, Lendremos que crear un cerLlflcado nuevo, para lo cual deberemos rellenar un formularlo con nuesLros daLos. Ls lmporLanLe que, por segurldad, la conLrasena no sea la mlsma que hemos puesLo en el paso anLerlor, mlenLras que el campo ollos nos servlr para ldenLlflcar el cerLlflcado en caso de que Luvleramos varlos. Ln caso que el almacen de claves ya exlsLlera, slmplemenLe selecclonaremos use exlstloq key", y procederemos a selecclonar el allas correspondlenLe, lnLroduclr su conLrasena y hacer cllc en Next, llnalmenLe, selecclonaremos la ruLa en la que debe almacenarse la apllcacln en el cuadro uestlootloo Alk llle" y hacer cllc en llolsb. uespues Lendremos que coplar el archlvo generado en el dlsposlLlvo e lnsLalarlo, para lo cual deberemos hablllLar la lnsLalacln de apllcaclones de fuenLes exLernas (hablllLar cooflqotoclo - seqotlJoJ - otlqeoes JescoooclJos en el dlsposlLlvo). Un apunte or eflclencla, Lcllpse uLlllza una cache lnLerna que le permlLe acceder a los archlvos muy rpldamenLe. Cuando reallzamos modlflcaclones a Lraves del proplo Lcllpse, LanLo la cache como los proplos archlvos se acLuallzan correcLamenLe, Lal y como debe ser. www.FreeLibros.me
16 Sln embargo, cuando acLuallzamos dlrecLamenLe los archlvos en el dlsco, medlanLe las uLllldades de coplar-pegar, mover, camblar de nombre, eLc del slsLema operaLlvo, Lcllpse no reacclona Lan blen como deblera y, en ocaslones, no deLecLa esLos camblos. ara evlLar esLo es convenlenLe forzar un refresco de la cache en Lcllpse cada vez que hacemos algun camblo desde fuera del enLorno, para lo cual haremos cllc en el boLn derecho del raLn enclma del nombre del proyecLo en la vlsLa lockoqe xplotet" y selecclonaremos la opcln teftesb. Ln el prxlmo caplLulo empezaremos el desarrollo de la apllcacln que servlr para presenLar los dlversos componenLes de Androld, un gesLor de archlvos, cenLrndonos en esa prlmera sesln en el dlseno de la panLalla. www.FreeLibros.me
17
CAI1ULC 3 Act|v|dades y Layouts en Andro|d
Una act|v|dad (del lngles octlvlty) es una tarea rea||zada por una ap||cac|n y que se centra en |a |nteracc|n con e| usuar|o, blen sea porque un proceso neceslLa unos daLos de esLe o por cualquler oLro moLlvo. Asl, Lodas las acLlvldades se basan en la creacln de una venLana (a panLalla compleLa o no), en la que se poslclonan los dlversos componenLes (boLones, cuadros de LexLo o edlcln, lmgenes, eLc) necesarlos para la comunlcacln con el usuarlo. Los |ayouts, que se asoclan a las dlferenLes venLanas o vlsLas, def|nen e| mapa que perm|te a Andro|d pos|c|onar cada uno de |os e|ementos en e| |ugar correspond|ente de |a panta||a. 1al como lndlcamos en el caplLulo anLerlor, |os |ayouts deben def|n|rse ten|endo en cuenta LanLo el Lamano de los elemenLos que conLlene como el Lamano del elemenLo, hablLualmenLe |a panta||a u oLro layouL, que hace de conLenedor del mlsmo, slendo poslble deflnlr layouLs dlferenLes dependlendo del Lamano de dlcho conLenedor. C|c|o de v|da de |as act|v|dades Ln lnformLlca exlsLen dos concepLos bslcos, que se expllcan enLre los Lres prlmeros dlas de carrera, y que nos acompanan duranLe Loda nuesLra vlda laboral, y que son los concepLos de pllo y colo. una pllo es una esLrucLura en la que el ulLlmo elemenLo que enLra es el prlmero que sale, el penulLlmo en enLrar es el segundo en sallr y suceslvamenLe. or conLra, una colo es una esLrucLura en la que el prlmer elemenLo en enLrar es Lamblen el prlmero en sallr, mlenLras que el ulLlmo en enLrar ser, lglcamenLe, el ulLlmo en sallr. Ln Androld el slsLema gesLlona las dlferenLes acLlvldades usando el concepLo de plla, de forma que, en un momenLo deLermlnado, s|o |a act|v|dad que se encuentra en |a c|ma de esta p||a se est e[ecutando, mlenLras que el resLo esLn en stooJby y la memorla que ocupan puede ser aslgnada a oLros procesos. Asl, cuando una acLlvldad se encuenLra en prlmer plano y oLra ocupa la clma de dlcha plla, aquella pasa a segundo plano y es suscepLlble de ser ellmlnada del slsLema, en lo que se denomlna clclo Je vlJo Je ooo octlvlJoJ" y que se expresa grflcamenLe en la slgulenLe lmagen. www.FreeLibros.me
18
Crear una act|v|dad uesgracladamenLe el Au1 no se lnLegra con Lcllpse Lan blen como deberla, asl que para crear una acLlvldad Lendremos que reallzar una serle de pasos (de forma manual): Crear |a c|ase asoc|ada a |a act|v|dad, y que |mp|ementar todos sus mtodos ara ello haremos cllc en llle - New - closs e lnLroduclremos los slgulenLes valores en la panLalla de creacln de la clase: ackage: Selecclonaremos el paqueLe al que perLenece la clase de enLre los deflnldos por nuesLra apllcacln, Name: lnLroduclremos el nombre de la acLlvldad, Lenlendo en cuenLa que no se acepLan espaclos nl caracLeres especlales. ue hecho, una buena prcLlca es www.FreeLibros.me
19 poner la prlmera leLra de cada palabra que forme el nombre en mayusculas y el resLo en mlnusculas (por e[emplo MlltlmetoActlvlJoJ), Superc|ass: lndlcaremos que la clase que esLamos creando es una acLlvldad lnLroduclendo el Llpo ooJtolJ.opp.Actlvlty. SeguldamenLe haremos cllc en flolsb para crear la clase, lo cual crear el archlvo asoclado a la clase y lo mosLrar en el edlLor de Lcllpse, para que podamos lmplemenLar sus meLodos.
ub||c|tar |a act|v|dad no obsLanLe, crear una acLlvldad no es slnnlmo de poder uLlllzarla, para lo cual es necesarlo anadlrla en el manlflesLo de nuesLra apllcacln (archlvo moolfest.xml). www.FreeLibros.me
20 Act|var una act|v|dad una funcln o procedlmlenLo se e[ecuLa de forma sloctooo cuando el flu[o de e[ecucln del programa en cuesLln no vuelve al procedlmlenLo prlnclpal (el que reallza la llamada) hasLa que la funcln que ha sldo llamada flnallza, mlenLras que una funcln se e[ecuLa de forma osloctooo cuando el proceso que reallza la llamada slgue e[ecuLndose aunque la funcln llamada no haya flnallzado. La creac|n y act|vac|n de una act|v|dad es un proceso as|ncrono que se reallza generalmenLe desde oLra acLlvldad, usando para ello las funclones stottActlvlty o stottActlvltylotkesolt, heredadas de la superclase, y que se dlferenclan en que la ulLlma permlLe obLener un resulLado, Lamblen de forma aslncrona. Los |ayouts Sl un acLlvldad deflne el conLenedor en el que se colocan los componenLes de una venLana, un layouL descrlbe cmo se colocan dlchos componenLes en la mlsma. Los |ayouts se estructuran en forma de rbo|, con un e|emento ra|z que se pos|c|ona sobre |a ventana, y suceslvos comparLlmenLos (nodos) en los que se colocan los elemenLos flnales u ho[as (lmgenes, cuadros de edlcln o de LexLo, boLones, eLc).
www.FreeLibros.me
21 Los conLenedores de elemenLos ms uLlllzados son los de Llpo lloeotloyoot y kelotlveloyoot. L|nearLayout Ls un conLenedor en el que los dlferenLes elemenLos se poslclonan uno deba[o del oLro, o uno a la derecha del oLro, dependlendo de sl se deflne de Llpo verLlcal u horlzonLal. ke|at|veLayout Se LraLa de un conLenedor ms comple[o en el que es poslble lndlcar la poslcln relaLlva de un elemenLo respecLo de oLro, permlLlendose lncluso el solapamlenLo de esLos. ue hecho, por defecLo Lodos los componenLes se allnean en la parLe superlor lzqulerda del conLenedor, slendo responsabllldad del dlsenador poslclonarlos convenlenLemenLe medlanLe el uso de aLrlbuLos y la deflnlcln de dependenclas, segun sea el caso. ara cada uno de |os contenedores, as| como para |os e|ementos f|na|es (botones, |mgenes, etc) es pos|b|e def|n|r mu|t|tud de atr|butos, como por e[emplo el Lamano horlzonLal o verLlcal, la vlslbllldad, el color o lmagen de fondo, eLc. Descarga de |a ap||cac|n de| curso
www.FreeLibros.me
22 Cs an|mamos a descargaros |a pr|mera parte de |a ap||cac|n que estamos desarro||ando en este curso Andro|d, que amplla los concepLos lnLroducldos en esLas prlmeras seslones y que conLlene un cdlgo LoLalmenLe funclonal que podrels probar en el emulador o en vuesLros dlsposlLlvos. una vez descarguels la apllcacln, deberels almacenarla en el dlrecLorlo de Lraba[o de Lcllpse (el que selecclonasLels duranLe el proceso de lnsLalacln). SeguldamenLe ser necesarlo lmporLarla desde Lcllpse, para que esLe la reconozca y podls acceder a la mlsma, blen sea para edlLarla o para e[ecuLarla en el emulador, para lo cual deberels segulr los slgulenLes pasos: 1. Selecclonar la opcln lmpott en el menu llle, 2. Ln la slgulenLe panLalla, selecclonar xlstloq ptoject loto wotkspoce" y pulsar oext, 3. Pacer cllc en btowse y navegar hasLa el dlrecLorlo en el que hemos almacenado la apllcacln (hay que enLrar en el dlrecLorlo, hasLa que veamos el archlvo manlfesL.xml), 4. Pacer cllc en flolsb. Ln el prxlmo bloque os expllcaremos cmo crear una panLalla de conflguracln para vuesLras apllcaclones, asl como los meLodos que usa el slsLema para faclllLar el acceso a los valores especlflcados por el usuarlo. www.FreeLibros.me
23
CAI1ULC 4 anta||as de conf|gurac|n
La prcLlca LoLalldad de las apllcaclones dlsponen de una o ms acLlvldades de conflguracln, y pese a que serla poslble lmplemenLarlas como sl se LraLara de una acLlvldad cualqulera, lo clerLo es que es mucho ms senc|||o usar |a AI de| s|stema s|empre que sta ex|sta, y en el caso de las acLlvldades de conflguracln el Lema esL resuelLo y muy blen resuelLo. Como veremos en esLa parLe del curso androld, esLe slsLema |ncorpora una AI espec|f|ca para tratar estas act|v|dades de conf|gurac|n que permlLe no slo vlsuallzar la propla venLana, que se muesLra de ldenLlca manera para Lodas las apllcaclones, proporclonando al usuarlo una sensacln de conLlnuldad que me[ora la experlencla de uso, slno que lncorpora adems funclones especlflcas para acceder fcllmenLe a los valores especlflcados por el usuarlo, asl como oLras que permlLen e[ecuLar dlferenLes acclones cuando esLe cambla alguna caracLerlsLlca conflgurable.
Cmo crear una panta||a de conf|gurac|n or comodldad, en esLe LuLorlal hablaremos de pootollos Je cooflqotoclo para referlrnos a las acLlvldades de conflguracln, y de cotoctetlstlcos o ptefeteoclos de usuarlo para referlrnos a cada uno de los valores que esLe puede conflgurar. Como hemos lndlcado anLes, |as panta||as de conf|gurac|n son ventanas, sl blen en esLe caso la superclase se denomlna ltefeteoceActlvlty y anade clerLas funclones y procedlmlenLos que permlLen LraLar correcLamenLe las acLlvldades de esLe Llpo aunque, en general, podemos asumlr que son slmplemenLe venLanas. ara crear una nueva panLalla de conflguracln deberemos segulr los pasos especlflcados en el LuLorlal anLerlor para la creacln de una acLlvldad generlca, pero Lenlendo en cuenLa que, en esLe caso, la superclase se denomlna ooJtolJ.ptefeteoce.ltefeteoceActlvlty. www.FreeLibros.me
24 no debemos olvldar que es necesarlo publlcar una referencla a la nueva acLlvldad en el manlflesLo de nuesLra apllcacln, ya que en caso que no lo hagamos nuesLro programa fallar cuando lnLenLemos acceder a la menclonada panLalla. Como descr|b|r |as opc|ones de conf|gurac|n Las dlferenLes opclones de conflguracln de nuesLra apllcacln se descrlben en un archlvo xML que se slLua en el dlrecLorlo tes/xml de esLa, slendo poslble edlLarlo manualmenLe o medlanLe la lnLerfaz de Lcllpse.
La creacln medlanLe Lcllpse se reallza medlanLe un aslsLenLe (ver lmagen ms arrlba para ver cmo acceder a esLe) en el que selecclonaremos los slgulenLes valores: kesource 1ype: reference, I||e: Ll nombre del archlvo. ComunmenLe preferences.xml, koot L|ement: Selecclonar referenceScreen. una vez creado el archlvo, esLe se abrlr en el aslsLenLe, a Lraves del cual podremos crear los dlferenLes elemenLos que lo formen. Ln la panLalla de edlcln deberemos Lener en cuenLa que en la parLe lzqulerda nos aparecern los dlferenLes elemenLos, esLrucLurados en forma de rbol, mlenLras que en la parLe derecha nos aparecern las caracLerlsLlcas del elemenLo concreLo selecclonado.
www.FreeLibros.me
23 1amblen podremos el boLn oJJ para anadlr un nuevo elemenLo, y los boLones temove, op y Jowo para ellmlnar, mover hacla arrlba o mover hacla aba[o el elemenLo selecclonado, respecLlvamenLe. uebe Lenerse en cuenLa que, Lal como se muesLra en el cdlgo de e[emplo, es convenlenLe lnlclallzar las caracLerlsLlcas de los dlferenLes elemenLos usando referenclas en lugar de cadenas de LexLo concreLas, ya que asl faclllLamos las modlflcaclones posLerlores, asl como la fuLura lnclusln de Lraducclones. Cmo detectar cuando |a panta||a de conf|gurac|n se c|erra Lo normal es que las acLlvldades de conflguracln sean lanzadas desde oLra acLlvldad, blen por la pulsacln de un boLn en dlcha acLlvldad, blen por la seleccln de la opcln correspondlenLe en el menu de la mlsma. Cuando una acLlvldad desea ser lnformada de que una acLlvldad que dependa de ella ha flnallzado debe lnlclarla usando el procedlmlenLo stottActlvltylotkesolt, que ya os comenLamos en la sesln anLerlor. Cuando una acLlvldad lnlclada medlanLe esLe procedlmlenLo acabe, el slsLema se encargar de acLlvar un evenLo (ooActlvltykesolt) en la acLlvldad orlglnadora que le permlLlr saber que aquella ha acabado, asl como recuperar los evenLuales resulLados de la e[ecucln.
www.FreeLibros.me
26 Cmo detectar cuando una caracter|st|ca de conf|gurac|n camb|a Los servlclos, que abordaremos en los slgulenLes caplLulos, se e[ecuLan sln la lnLervencln del usuarlo, blen por la acLlvacln de un evenLo en el dlsposlLlvo, como por e[emplo la recepcln de un mensa[e de LexLo, blen porque lmplemenLan acclones que se e[ecuLan en segundo plano y que no requleren la lnLervencln del usuarlo. Ls poslble que un servlclo, o cualquler oLra parLe de nuesLra apllcacln, neceslLe reclblr una noLlflcacln (evenLo) cuando el usuarlo camble alguna de las preferenclas de esLa, para lo cual deber e[ecuLar el meLodo teqlstetOo5boteJltefeteocecbooqellsteoet en una lnsLancla de la clase 5boteJltefeteoces. Ll programador debe Lener en cuenLa que es obllgaLorlo llamar al procedlmlenLo ooteqlstetOo5boteJltefeteocecbooqellsteoet cuando la necesldad de reclblr el evenLo acabe o, en ulLlmo Lermlno, cuando el ob[eLo que reclbe el evenLo se desLruya, ya que en caso conLrarlo la apllcacln fallar. Cmo acceder a un va|or de una caracter|st|ca concreta Ls poslble acceder a las preferenclas de usuarlo en cualquler momenLo duranLe la e[ecucln de nuesLras apllcaclones, para lo cual deberemos crear una lnsLancla de un ob[eLo de Llpo 5boteJltefeteoces, sobre la que usaremos los meLodos qet8ooleoo, qetlot, qetlooq, qetlloot o qet5ttloq segun corresponda.
www.FreeLibros.me
27 Cmo mod|f|car manua|mente e| va|or de una caracter|st|ca concreta Aunque no es usual, es poslble que en una apllcacln debls modlflcar manualmenLe una preferencla de usuarlo, por e[emplo para refle[ar la desacLlvacln de una propledad porque la apllcacln no ha sldo reglsLrada. Ll cdlgo que os mosLramos a conLlnuacln permlLe reallzar dlcha modlflcacln. publlc vold seLreference (ConLexL conLexL, SLrlng key, SLrlng value) [ Sharedreferences.LdlLor preferences_edlLor = referenceManager.geLuefaulLSharedreferences(conLexL).edlL(), preferences_edlLor.puLSLrlng(key, value), preferences_edlLor.commlL(), } u es e| contexto de una ap||cac|n Ln el cdlgo anLerlor hemos lnLroducldo una varlable de nombre cootext, de la cual no hablamos hablado con anLerlorldad, y que es de Llpo cootext. Ll Llpo cootext represenLa una lnLerfase de lnformacln global acerca de la apllcacln, y es usado slempre que se neceslLa acceder al slsLema o a daLos concreLos de esLa. Muy a ba[o nlvel, las venLanas son de Llpo cootext, por lo que heredan Lodas sus propledades. Asl, cuando llamemos a la funcln anLerlor desde una acLlvldad, podremos reallzar la llamada de la forma seLreference(Lhls, key, value), Ln e| prx|mo cap|tu|o os hab|aremos de |os threads, que permlLen e[ecuLar varlas parLes de cdlgo de forma concurrenLe (slmulLnea), y os expllcaremos las resLrlcclones que les afecLan. Cs recomendamos que os descargu|s |a nueva vers|n de |a ap||cac|n de prueba que esLamos desarrollando. www.FreeLibros.me
28
CAI1ULC S 1hreads
Algo que no hemos vlsLo hasLa el momenLo en nuesLro Curso Androld es la capacldad de Lener hllos paralelos de procesamlenLo. lnlclalmenLe, los slsLemas operaLlvos slo eran capaces de reallzar una unlca Larea de forma slmulLnea, lo que bloqueaba el proceso, y hasLa el ordenador, cuando esLe Lenla que reallzar clculos lmporLanLes o una operacln de enLrada/sallda. Ms adelanLe, los slsLemas fueron capaces de e[ecuLar varlos procesos dlferenLes a la vez, de forma concurrenLe, lo que permlLla opLlmlzar el uso de la Cu, aprovechando los Llempos en que esLa esLaba desocupada para e[ecuLar oLras Lareas.
Andro|d es un s|stema mu|t|-proceso, lo que qulere declr que es capaz de e[ecuLar varlos procesos (Lareas) de forma slmulLnea, y mu|t|-f|u[o, que slgnlflca que puede e[ecuLar de forma slmulLnea dos o ms porclones de cdlgo del mlsmo proceso. kecotJemos poe los ptocesos se ejecotoo eo cootextos sepotoJos, pot lo poe oo compotteo Jotos, mleottos poe los flojos o bllos Je oo mlsmo ptoceso se ejecotoo eo el mlsmo cootexto, pot lo poe compotteo el mlsmo espoclo Je memotlo y poeJeo lotetfetlt eotte ellos, lo poe Jebe set teolJo eo coeoto pot el ptoqtomoJot. Andro|d es un s|stema fuertemente or|entado a| usuar|o, y a la lnLeraccln de esLe con el slsLema, que se hace efecLlva por medlo de cllcs, pulsaclones en la panLalla o en los boLones, eLc. Cuando e| usuar|o |nteracc|ona con una ap||cac|n y sta est ocupada en otros quehaceres, e| s|stema |e as|gna un !"#$%& (# )*+,"+ para que f|na||ce |o que est hac|endo y at|enda a| usuar|o, asumlendo el slsLema que la apllcacln ha de[ado de funclona en caso que no lo haga, lo que provoca que el slsLema la flnallce www.FreeLibros.me
29 auLomLlcamenLe, lo que se conoce con el nombre de ANk y que, [unLo con el de sobras conocldo lc, es el mensa[e de error ms hablLual en Androld. Ll programador deber Lener en cuenLa esLe hecho y no reallzar en el hllo prlnclpal operaclones que puedan bloquear el proceso, Lales como bucles con un alLo numero de lLeraclones, operaclones de enLrada/sallda, accesos a lnLerneL, eLc.
Convert|r una ap||cac|n s|ng|e-thread en mu|t|-thread Andro|d d|st|ngue entre h||o pr|nc|pa| de un proceso y todos sus h||os secundar|os, perm|t|ndose n|camente a| h||o pr|nc|pa| acceder a |a |nterfase grf|ca. Asl, aunque podemos usar un hllo separado para calcular los dlferenLes elemenLos de una llsLa (llstvlew), deberemos usar el hllo prlnclpal para anadlr los dlferenLes elemenLos a la vlsLa y para redlbu[arla, sl es el caso. Ln realldad, converLlr una apllcacln que se e[ecuLa en un unlco hllo en mulLl-hllo es ms senclllo de lo que parece. La c|ase -.*#+( Androld lmplemenLa los dlferenLes Lhreads que se e[ecuLan en un deLermlnado momenLo usando la superclase 1bteoJ, que deflne un procedlmlenLo denomlnado too que conLlene Lodo el cdlgo que e[ecuLar un hllo concreLo. Asl, para lnlclar un nuevo hllo, Lan slo es necesarlo lnsLanclar una varlable de Llpo 1bteoJ, en la que habremos lmplemenLado convenlenLemenLe el procedlmlenLo menclonado en el aparLado anLerlor, y e[ecuLar la funcln stott, Lal como se muesLra ms aba[o.
class My1hread exLends 1hread [ publlc vold run () [ ... www.FreeLibros.me
30 } } 1hread my1hread = new My1hread(), my1hread.sLarL(), Ll programador debe Lener en cuenLa que Lras la llamada al procedlmlenLo stott, el proceso prlnclpal (el que ha hecho la llamada) conLlnuar su e[ecucln, que se reallzar de forma paralela a la del nuevo hllo. Aslmlsmo, debe Lener en cuenLa que e| s|stema no |e not|f|car cuando e| h||o f|na||ce (al acabar la funcln too), por lo que deber ser el proplo hllo el que envle la noLlflcacln, sl es el caso.
La c|ase /+0(1#* LxlsLen dlferenLes maneras de envlar mensa[es enLre los dlferenLes hllos que lmplemenLan un proceso, slendo la ms eleganLe, y comunmenLe uLlllzada, la que se lmplemenLa usando lnsLanclas de la clase nooJlet. un nooJlet es un ob[eLo de slsLema capaz de procesar los dlferenLes mensa[es que reclbe, segun el Llpo de esLos y los parmeLros adlclonales que se reclban. Ls el proplo slsLema el que se encarga de envlar, de forma aslncrona, los mensa[es al nooJlet adecuado, que lo procesa en el conLexLo del flu[o que lo ha creado, lo que permlLe conLexLuallzacln. kecotJemos poe ooo llomoJo o oo ptoceJlmleoto es osloctooo coooJo oo teoemos qotootlos Je poe el cJlqo llomoJo se ejecote ootes Je poe lo llomoJo floollce. www.FreeLibros.me
31
class MyPandler exLends Pandler [ publlc vold processMessage (Message message) [ swlLch message.whaL [ ... } } } Pandler myPandler = new MyPandler(), . Message message = new Message(), message.whaL = 1, myPandler.sendMessage(message), Cmo v|sua||zar datos en una ap||cac|n mu|t|-f|u[o Como hemos lndlcado, s|o e| h||o pr|nc|pa| puede acceder a |a UI, por lo que ser esLe el unlco que podr lnLeracLuar con los dlferenLes elemenLos que conformen las dlferenLes venLanas de nuesLra apllcacln.
ue hecho, es una buena prcLlca que el hllo prlnclpal se encargue solamenLe de procesar los dlferenLes evenLos que genere el usuarlo y/o la propla apllcacln, lnlclando hllos nuevos para lmplemenLar las operaclones de enLrada/sallda y/o www.FreeLibros.me
32 aquellas operaclones de proceso de daLos que no sean Lrlvlales, Lenlendo en cuenLa que el cosLe (en Llempo) de crear un nuevo hllo, aunque no es elevado, no es despreclable. ara ello deflnlremos una lnsLancla de la clase nooJlet en el hllo prlnclpal que se encargar de procesar (aslncronamenLe) los mensa[es que le envlan los dlferenLes hllos lndlcando que han flnallzado sus Lareas, procedlendo a redlbu[ar vlsLas, anadlr o ellmlnar elemenLos grflcos, eLc en el hllo prlnclpal. La c|ase kunnab|e Ln !ava no exlsLe la herencla mulLlple, por lo que cuando exLendemos una clase de Llpo 1hread perdemos la poslbllldad de hacer que exLlenda oLra, de ahl que los Lhreads se usen slo para lmplemenLar operaclones que emplezan y acaban, ya que cuando la funcln too flnallza Lamblen se acaba el ob[eLo que la deflne. ara evlLar esLo, se cre la clase kooooble, que no exLlende una clase, slno que permlLe lmplemenLar meLodos de acceso a la mlsma, lo que permlLe una mayor versaLllldad. Asl, la clase 1bteoJ se ocupa hablLualmenLe de lmplemenLar operaclones comple[as en Lareas, mlenLras que la clase kooooble lmplemenLa Lareas compleLas. Ls declsln del programador eleglr cundo uLlllzar una u oLra. Ln el prxlmo caplLulo veremos cmo capLurar los evenLos (de usuarlo y de slsLema), algunos de los cuales ya hemos lnLroducldo brevemenLe en seslones anLerlores. M|entras tanto, puedes descargar |a vers|n nmero 3 de |a ap||cac|n que estamos desarro||ando, en la que comprobars cmo obLenemos la llsLa de archlvos de un dlrecLorlo en un hllo separado y cmo envlamos un mensa[e al hllo prlnclpal cuando esLa llsLa ya esL compleLa, procedlendo esLe a acLuallzar la llsLa que se muesLra al usuarlo.
www.FreeLibros.me
33
CAI1ULC 6 Captura de eventos
Ln seslones anLerlores de nuesLro curso Androld Le hemos expllcado cmo crear Lu prlmera apllcacln, asl como la manera de opLlmlzarla usando mulLlples hllos de procesamlenLo, en esLa ocasln Le ensenaremos a reclblr evenLos del slsLema y/o de oLras apllcaclones. Ln Androld dlsLlngulmos dos Llpos de evenLos: Los relaclonados con la lnLerfaz grflca, como por e[emplo los relaclonados con el clclo de vlda de una acLlvldad y/o los cllcs en los dlferenLes elemenLos que conforman una venLana, y que son programables medlanLe el proplo lengua[e !ava. Ll resLo de evenLos, que no se refleren a la lnLerfaz grflca, y que no son dlrecLamenLe LraLables medlanLe las funclones y procedlmlenLos esLndar de !ava, como por e[emplo la deLeccln de la llegada de un nuevo mensa[e de LexLo o del apagado de la panLalla.
Lventos de |a ap||cac|n Como lndlcamos en el caplLulo anLerlor, el lengua[e de programacln !ava permlLe a una clase lncorporar las funclones y procedlmlenLos de oLra medlanLe la uLlllzacln de las dlrecLlvas exteoJs (exLlende, hereda) o lmplemeots (lmplemenLa). Las "0!#*2+,#3 son c|ases abstractas que se usan para def|n|r mtodos de enLrada (callbacks) que se cod|f|can en |a c|ase que |os |mp|ementa. Las lnLerfaces son uLlllzadas por el slsLema para lmplemenLar los evenLos (generalmenLe los cllcs en boLones, evenLos de los Lemporlzadores, eLc), y pueden www.FreeLibros.me
34 lmplemenLarse a Lraves de una clase o de forma annlma, Lal como se lndlca en los e[emplos que slguen. Imp|ementac|n a travs de una c|ase class MyClass lmplemenLs CnCllckLlsLener [ MyClass() [ 8uLLon buLLon, ... buLLon.seLCnCllckLlsLener(Lhls), } publlc vold onCllck(vlew vlew) [ ... } } Imp|ementac|n ann|ma class MyClass lmplemenLs CnCllckLlsLener [ MyClass() [ 8uLLon buLLon, ... buLLon.seLCnCllckLlsLener(new CnCllckLlsLener() [ publlc vold onCllck(vlew vlew) [ ... } }), } } Ctros eventos Los evenLos exLernos a la propla apllcacln se lmplemenLan a Lraves de una clase denomlnada 8tooJcostkecelvet, la cual lmplemenLa el meLodo ookecelve, que es el punLo de acceso a los ob[eLos de dlcha clase. S| e| programador desea que un evento concreto, por e[emplo el que se acLlva cuando el slsLema acaba de lnlclarse y esL preparado para e[ecuLar programas, se act|ve |nc|uso s| |a ap||cac|n que |o rec|be no se est e[ecutando, debe dec|arar|o en e| man|f|esto, lo que lndlcar al slsLema esLe hecho y lo preparar para e[ecuLarlo cuando sea necesarlo. <manlfesL ...> <appllcaLlon ...> <recelver androld:name=".8ooLCompleLed8roadcasL8ecelver"> <lnLenL-fllLer> <acLlon androld:name="androld.lnLenL.acLlon.8CC1_CCMLL1Lu" /> </lnLenL-fllLer> </recelver> </appllcaLlon> </manlfesL> Ll programador es el encargado de lncorporar a su proyecLo las clases que lmplemenLan cada uno de los 8roadcasL8ecelver que declare (en el e[emplo anLerlor habrla que deflnlr la clase 8ootcompleteJ8tooJcostkecelvet, que exLenderla las propledades de la clase 8tooJcostkecelvet). AdlclonalmenLe, debe Lenerse en cuenLa que a|gunos eventos son de acceso pr|v||eg|ado, por |o que neces|tan que el usuarlo sumlnlsLre a la apllcacln una ser|e de perm|sos cuando esLa se lnsLala, y que Lamblen deben enumerarse en el manlflesLo. <manlfesL ...> <uses-permlsslon androld:name="androld.permlsslon.8LCLlvL_SMS" /> </manlfesL> no obsLanLe, Lamblen es poslble deflnlr un tecelvet que monlLorlce evenLos slo cuando la apllcacln, o un deLermlnado servlclo o acLlvldad, se encuenLran en www.FreeLibros.me
33 e[ecucln, para lo cual debe lmplemenLarse la correspondlenLe lnsLancla de la clase 8tooJcostkecelvet e lnsLanclarse Lal como se lndlca en el e[emplo. class MyAcLlvlLy exLends AcLlvlLy [ class MyAcLlvlLy8roadcasL8ecelver exLends 8roadcasL8ecelver [ publlc vold on8ecelve(ConLexL conLexL, lnLenL lnLenL) [ ... } } prlvaLe 8roadcasL8ecelver l8roadcasL8ecelver = new MyAcLlvlLy8roadcasL8ecelver(), publlc vold on8esume() [ super.on8esume(), reglsLer8ecelver(l8roadcasL8ecelver, new lnLenLlllLer(lnLenL.AC1lCn_SC8LLn_Cll)), } publlc vold onause() [ unreglsLer8ecelver(l8roadcasL8ecelver), super.onause(), } } nLese que los evenLos empezarn a monlLorlzarse a parLlr de la llamada al procedlmlenLo teqlstetkecelvet (presenLe en las clases Actlvlty y 5etvlce) y de[arn de monlLorlzarse Lras la llamada a ooteqlstetkecelvet (que debe reallzarse forzosamenLe anLes de que el ob[eLo sea desLruldo, para evlLar errores posLerlores). kecepc|n de parmetros Ll procedlmlenLo ookecelve de la clase 8tooJcostkecelvet se e[ecuLa cuando se acLlva el evenLo para el cual ha sldo programado, reclblendo como parmeLros el cootexto de la apllcacln en el que se e[ecuLa y un loteot que conLlene el Llpo de evenLo acLlvado (loteot.qetActloo), asl como el resLo de parmeLros asoclados al mlsmo (acceslbles usando las funclones loteot.qet8ooleooxtto, loteot.qetlotxtto, eLc).
Ln cuanLo a la apllcacln de esLos a nuesLro programa de e[emplo, no hemos enconLrado la poslbllldad de apllcarlos, por |o que hemos creado un proyecto nuevo, en e| que detectaremos cundo se enc|ende o apaga |a panta||a de nuestro d|spos|t|vo. Cs recomendamos que hagls un segulmlenLo del archlvo de loq, para |o cua| pod|s usar e| comando "oJb loqcot". www.FreeLibros.me
36
CAI1ULC 7 Comun|cac|n con otras Apps
Ln el caplLulo anLerlor de nuesLro curso Androld vlmos cmo hacer que nuesLra apllcacln lnLeracLue con los evenLos del slsLema para, por e[emplo, e[ecuLar una accln cuando la panLalla se apaga, o se enclende. Ln esLa ocasln, usaremos el mlsmo prlnclplo para consegulr que dos apllcaclones dlferenLes se envlen mensa[es a Lraves del slsLema. Ln Androld, y en la mayorla de los slsLemas operaLlvos modernos, |as ap||cac|ones se e[ecutan en espac|os de memor|a separados, lo que aumenLa la segurldad de esLe al lmpedlr que una apllcacln mallnLenclonada, o no, afecLe al funclonamlenLo de oLra. ara las conLadas ocaslones en las que neceslLemos envlar mensa[es enLre apllcaclones, el slsLema provee de una lnLerfaz que permlLe LanLo la Lransmlsln como la recepcln auLomLlca de los mlsmos, slempre y cuando la apllcacln que reclbe el mensa[e esLe preparada para ello. Lnv|ar un mensa[e ara la Lransmlsln del mensa[e uLlllzaremos un ob[eLo que los seguldores de esLe curso ya conocen, el loteot, que permlLe el paso de lnformacln a Lraves de la colo Je eveotos Je AoJtolJ. Al lnlclallzar el ob[eLo slmplemenLe deberemos Lener en cuenLa que deberemos lndlcar el nombre del paqueLe y la clase que debe reclblr el mensa[e, asl como la accln concreLa que lmplemenLa el mensa[e, que permlLlr al recepLor obLener correcLamenLe los parmeLros que lncluyamos. lnLenL lnLenL = new lnLenL(), lnLenL.seLClassname(nCM88L_uLL_ACuL1L", nCM88L_uL_LA_CLASL"), lnLenL.seLAcLlon(nCM88L_uL_LA_ACClCn"), lnLenL.puLLxLra(nCM88L_uLL_A8ML18C_1", vALC8_uLL_A8ML18C_1"), . lnLenL.puLLxLra(nCM88L_uLL_A8ML18C_n", vALC8_uLL_A8ML18C_n"), llnalmenLe, envlaremos el mensa[e usando el procedlmlenLo aslncrono seoJ8tooJcost, que lncorpora la superclase cootext, y por ende Lamblen las clases Actlvlty y 5etvlce, que son las que hablLualmenLe LraLan esLos Lemas conLexL.send8roadcasL(lnLenL),
www.FreeLibros.me
37 kec|b|r un mensa[e ara la recepcln del mensa[e deberemos usar el mecanlsmo lndlcado en la sesln anLerlor para la recepcln de evenLos del slsLema, es declr, deflnlr la accln en el manlflesLo de nuesLra apllcacln, asoclndolo a la mlsma clase que se usa al envlarlo, Lal como se lndlca a conLlnuacln. <recelver androld:name="nCM88L_uL_LA_CLASL" androld:exporLed="Lrue"> <acLlon androld:name="nCM88L_uL_LA_ACClCn" /> </recelver> 1al como se lndlca en el e[emplo anLerlor, no deberemos olvldar anadlr el aLrlbuLo expotteJ que lndlca que la clase puede ser acLlvada desde oLras apllcaclones, Lal como es el caso.
www.FreeLibros.me
38 Devo|uc|n de resu|tados Ln caso que la apllcacln que reclbe el mensa[e deba devolver algun Llpo de resulLado, deberemos uLlllzar el mlsmo mecanlsmo descrlLo anLerlormenLe (creacln de un nuevo loteot y envlo a la prlmera apllcacln, en la cual habremos deflnldo un 8tooJcostkecelvet que se encargar de procesar el resulLado, de forma aslncrona). Act|var otras ap||cac|ones Ln ocaslones puede resulLar uLll que vuesLra apllcacln acLlve oLras apllcaclones, blen se LraLe de apllcaclones de slsLema o de apllcaclones que hayls descargado de la lloy 5tote, o de alguna oLra Llenda oflclal. Ln general Androld no ofrece una lnLerfaz de acLlvacln para las apllcaclones de slsLema, por lo que un meLodo que funclona correcLamenLe en una versln puede no funclonar en la slgulenLe acLuallzacln del slsLema, no obsLanLe, los e[emplos que os proporclonamos a conLlnuacln se han mosLrado funclonales. Act|var |a bande[a de entrada de mensa[es de texto lnLenL lnLenL = new lnLenL(), lnLenL.seLClassname("com.androld.mms", "com.androld.mms.ul.ConversaLlonLlsL"), lnLenL.seLAcLlon(lnLenL.AC1lCn_MAln), lnLenL.addCaLegory(lnLenL.CA1LCC8?_uLlAuL1), lnLenL.seLllags(lnLenL.lLAC_AC1lvl1?_nLW_1ASk | lnLenL.lLAC_AC1lvl1?_SlnCLL_1C | lnLenL.lLAC_AC1lvl1?_CLLA8_1C | lnLenL.lLAC_AC1lvl1?_nC_PlS1C8? | lnLenL.lLAC_AC1lvl1?_CLLA8_WPLn_1ASk_8LSL1), Act|var e| reg|stro de ||amadas lnLenL lnLenL = new lnLenL(), lnLenL.seLAcLlon(lnLenL.AC1lCn_vlLW), lnLenL.seL1ype(CallLog.Calls.CCn1Ln1_1?L), lnLenL.seLllags(lnLenL.lLAC_AC1lvl1?_nLW_1ASk | lnLenL.lLAC_AC1lvl1?_SlnCLL_1C | lnLenL.lLAC_AC1lvl1?_CLLA8_1C | lnLenL.lLAC_AC1lvl1?_nC_PlS1C8? | lnLenL.lLAC_AC1lvl1?_CLLA8_WPLn_1ASk_8LSL1), odels enconLrar lnformacln sobre la acLlvacln de oLras apllcaclones de slsLema en Cooqle, para lo que os recomendamos la slgulenLe busqueda: opeo NOM8k_AlllcAclN -loteot" o en el foro de desarro||adores stackoverf|ow.com Ln cuanLo a las apllcaclones de usuarlo, y pese a que las lnLerfases de acceso Lamblen pueden varlar, el mecanlsmo es el slgulenLe: 1. uecompllar la apllcacln para acceder al manlflesLo de la mlsma. 2. Abrlr el manlflesLo con un edlLor de LexLo. www.FreeLibros.me
39 3. Los poslbles punLos de enLrada a la mlsma son aquellos que Lengan aslgnado el aLrlbuLo exporLed, Lal como hemos lndlcado anLerlormenLe. LglcamenLe, habr que perder algun Llempo en comprobar los efecLos que Llene la acLlvacln de cada uno de ellos, hasLa enconLrar el que hace lo que queremos que haga, sl es que lo hay. Algunas apllcaclones, como por e[emplo el calendarlo, generan mensa[es que pueden ser capLurados por oLras apllcaclones, lo que permlLe no slo su monlLorlzacln, slno Lamblen su susLlLucln, segun el caso. uado que esLos mensa[es no son parLe del nucleo de Androld, no es poslble obLener documenLacln de Coogle sobre esLe Lema, por lo que su deLeccln no es fcll y se reallza medlanLe la mon|tor|zac|n de |os |ogs de s|stema y el segulmlenLo del cdlgo fuenLe de las proplas apllcaclones, que es poslble obLener en d|versos repos|tor|os, como e| de CyanogenMCD. www.FreeLibros.me
40
CAI1ULC 8 W|dgets
Ln los dos ulLlmos caplLulos de nuesLro curso Androld hemos expllcado como el programador puede hacer que las apllcaclones capLuren los evenLos que genera el slsLema, u oLras apllcaclones, asl como la manera en que deben generarse los evenLos para que puedan ser capLurados por oLras apllcaclones, lo que se aparLaba un poco del Lema prlnclpal del curso pero que conslderbamos lnLeresanLe para enLender el funclonamlenLo de Androld. nos dlsponemos ahora a conLlnuar desarrollando nuesLro exp|orador de arch|vos, a| que en este cap|tu|o proveeremos de un w|dget que permlLlr al usuarlo crear accesos dlrecLos a un dlrecLorlo concreLo, lo que nos permlLlr no slo expllcaros cmo se crea y dlbu[a el wldgeL, slno Lamblen cmo se vlsuallza la pglna de conflguracln del mlsmo. Ln Androld, un w|dget es un cuadro grf|co que se pos|c|ona en e| escr|tor|o, y en algunos casos Lamblen en la panLalla de bloqueo, y que perm|te a |as ap||cac|ones mostrar |nformac|n, a menudo d|nm|ca, y a |os usuar|os acceder a func|ones espec|f|cas de sta.
www.FreeLibros.me
41 ara poder dlsenar un wldgeL es necesarlo responder prlmero a las slgulenLes pregunLas: Cue queremos mosLrar en el wldgeL, Se puede conflgurar la lnformacln que aparece en el wldgeL, Cuando se refrescar la lnformacln del wldgeL, Cmo lnLeracLuar el usuarlo con el wldgeL, sl es que eso es poslble, Adems, y como veremos a conLlnuacln, ser necesarlo Lener en cuenLa al lnlclar el proceso de acLuallzacln que e| usuar|o puede haber aad|do ms de un w|dget. u queremos mostrar en e| w|dget L| conten|do de| w|dget se def|ne de lgual manera que el conLenldo de una acLlvldad (venLana), es declr, med|ante un |ayout que conLendr los dlferenLes elemenLos de esLe. Aslmlsmo, Lamblen deberemos deflnlr el wldgeL en el manlflesLo de la apllcacln, Lal como se lndlca a conLlnuacln. La accln capLurada (ooJtolJ.oppwlJqet.octloo.AllwluC1_uluA1) slrve para lndlcar al slsLema que la clase debe reclblr los evenLos de acLuallzacln del wldgeL, Lal y como ya lndlcamos en clases anLerlores. AdlclonalmenLe, deberemos lndlcar las caracLerlsLlcas bslcas del wldgeL, Lales como el Lamano, el Llempo Lras el cual debe acLuallzarse el wldgeL y el layouL lnlclal en el archlvo tes/xml/wlJqet.xml (o el nombre que hayamos lndlcado en el manlflesLo). Se puede conf|gurar |a |nformac|n que aparece en e| w|dget Ln caso que nuesLro wldgeL sea conflgurable, deberemos lndlcarlo en el archlvo tes/xml/wlJqet.xml, lo cual forzar la creacln de una acLlvldad lnlclal en la que el usuarlo lnLroduzca los parmeLros de conflguracln de aquel. Aunque podemos usar cualquler mecanlsmo para almacenar los parmeLros de conflguracln del wldgeL, lo ms convenlenLe es uLlllzar la clase Sharedreferences, cuyo funclonamlenLo ya conocels. AdlclonalmenLe, deberemos Lener en cuenLa que lnLernamenLe Androld lmplemenLa la llamada a la acLlvldad de conflguracln medlanLe la e[ecucln del procedlmlenLo ooActlvltykesolt, por lo que sl la acLlvldad de conflguracln acaba con un cdlgo de e[ecucln (tesoltcoJe) dlferenLe de Actlvlty.k5ul1_Ok, la adlcln del wldgeL se cancelar.
www.FreeLibros.me
42 Cundo se refrescar |a |nformac|n de| w|dget Ll wldgeL se refresca cuando se acLlva el evenLo ooJtolJ.oppwlJqet.octloo.AllwluC1_uluA1, que deberemos capLurar convenlenLemenLe en el cdlgo que lmplemenLe nuesLro wldgeL (ver procedlmlenLo ooupJote de la clase wlJqet en el e[emplo). Ls poslble forzar la acLlvacln de dlcho evenLo medlanLe el broadcasL correspondlenLe, Lal y como se muesLra en el cdlgo de e[emplo. Cmo |nteractuar e| usuar|o con e| w|dget, s| es que eso es pos|b|e Los wldgeLs son ob[eLos dlnmlcos en el senLldo que su conLenldo puede ser modlflcado dlnmlcamenLe por la apllcacln, medlanLe la capLura del evenLo AllwluC1_uluA1 enunclado en los prrafos anLerlores.
no obsLanLe, lo ms probable es que nos lnLerese la lnLeraccln con el usuarlo, hablLualmenLe medlanLe el evenLo ONcllck sobre la vlsLa que conLlene a nuesLro wldgeL, para lo cual deberemos usar el procedlmlenLo setOocllckleoJloqloteot, que usaremos para que al cllcar el wldgeL se genere un broadcasL, se acLlve una venLana, eLc. www.FreeLibros.me
43
CAI1ULC 9 Serv|c|os
Un serv|c|o es una sub-ap||cac|n que se e[ecuta en segundo p|ano, norma|mente s|n |nteracc|n con e| usuar|o, y que rea||za una ser|e de tareas depend|endo de |a act|vac|n de determ|nados eventos externos (aquellos para cuya aLencln ha sldo programado), Lales como la recepcln de un correo elecLrnlco, la acLlvacln de un Lemporlzador, eLc. Ln Andro|d |os serv|c|os se e[ecutan en e| contexto de| proceso a| que pertenecen, que no es ms que aquel que los ha creado, por lo que pueden acceder a cualqulera de los ob[eLos creados por esLe, a excepcln de los relaclonados con la lnLerfase grflca, que Lal como sucedla con los 1hreads, son acceslbles unlcamenLe desde el flu[o prlnclpal. 1al y como se aprecla en la lmagen lnferlor, el clclo de vlda de un servlclo se slLua enLre la acLlvacln de los evenLos onCreaLe y onuesLroy, garanLlzando el slsLema que una acLlvacln del evenLo onCreaLe asoclado a un servlclo se complemenLar medlanLe la acLlvacln del evenLo onuesLroy correspondlenLe.
www.FreeLibros.me
44 Aunque no es obllgaLorlo, lo hablLual es que el evenLo oocteote asoclado a un servlclo se encargue de la lnlclallzacln de un ob[eLo de Llpo 8tooJcostkecelvet que se encargar de monlLorlzar los evenLos (exLernos o lnLernos) que acLlven o desacLlven el servlclo, mlenLras que el evenLo oouesttoy se encargar de desLrulr el menclonado ob[eLo. Def|n|c|n de un serv|c|o Al lgual que ocurre con las acLlvldades, los servlclos deben deflnlrse en el moolflesto de nuesLra apllcacln, Lal como se lndlca a conLlnuacln, Lenlendo en cuenLa que la clase que lmplemenLe el servlclo deber heredar de la superclase 5etvlce. <servlce androld:name=".ServlceClassname" /> Instanc|ac|n de un serv|c|o Al lgual que ocurre con las acLlvldades, no pueden cohex|st|r en e| s|stema dos serv|c|os de |a m|sma c|ase, por lo que anLes de lnsLanclar un servlclo deberemos comprobar sl esLe ya se esL e[ecuLando, procedlendo a acLlvarlo medlanLe un evenLo o a lnsLanclarlo segun sea el caso, Lal como se muesLra en el e[emplo. boolean ls_runnlng = servlce8unnlng(), lnLenL lnLenL = ls_runnlng ? new lnLenL() : new lnLenL(conLexL, servlce_class), lnLenL.seLAcLlon(acLlon), lf (ls_runnlng) conLexL.send8roadcasL(lnLenL), else conLexL.sLarLServlce(lnLenL), Destrucc|n de un serv|c|o La acLlvacln de un evenLo provoca que una porcln de cdlgo asoclada a un servlclo se e[ecuLe, pero esLe permanece resldenLe en memorla, a la espera de que el mlsmo u oLro evenLo se acLlve, hasLa que el servlclo es expllclLamenLe desLruldo, lo cual puede hacerse medlanLe la llamada stop5etvlce (a la que se le pasa como parmeLro el Llpo de servlclo a deLerner) o medlanLe la llamada al procedlmlenLo stop5elf asoclada al servlclo. proLecLed synchronlzed sLaLlc vold sLopServlce(SLrlng servlce_name, Servlce servlce) [ uebug.d(servlce_name, "SLopplng servlce"), servlce.sLopSelf(), } proLecLed synchronlzed sLaLlc vold sLopServlce(ConLexL conLexL, SLrlng servlce_name, Classservlce_class) [ uebug.d(servlce_name, "SLopplng servlce"), conLexL.sLopServlce(new lnLenL(conLexL, servlce_class)), } Act|vando un evento en un serv|c|o 1al como hemos lndlcado con anLerlorldad, lo hablLual es que Lodo servlclo lleve asoclado un ob[eLo 8tooJcostkecelvet que slrve como punLo de enLrada al servlclo. LsLa lnsLancla de la clase 8tooJcostkecelvet lmplemenLa el cdlgo asoclado al procesamlenLo de los evenLos exLernos (del slsLema) que aLlende el servlclo, asl como www.FreeLibros.me
43 el cdlgo asoclado a los evenLos de la propla apllcacln que pueden modlflcar el comporLamlenLo del servlclo, que suelen asoclarse a evenLos exLernos que se procesan parclalmenLe en oLros conLexLos o a camblos en los parmeLros de conflguracln de la apllcacln. Aunque no es obllgaLorlo, es una buena prcLlca deflnlr una operacln esLLlca asoclada al servlclo para cada uno de los punLos de enLrada al mlsmo, de forma que sea en ese procedlmlenLo en el que se compruebe sl esLe se encuenLra o no en e[ecucln y se proceda a su creacln o acLlvacln, segun el caso. publlc sLaLlc synchronlzed vold screenlsCff(ConLexL conLexL) [ boolean ls_runnlng = ls8unnlng(), lnLenL lnLenL = ls_runnlng ? new lnLenL() : new lnLenL(conLexL, ScreenSLaLeServlce.class), lnLenL.seLAcLlon(ln1L8nAL_AC1lCn_SC8LLn_Cll), lf (ls_runnlng) conLexL.send8roadcasL(lnLenL), else conLexL.sLarLServlce(lnLenL), } Ln el e[emplo anLerlor, el 8tooJcostkecelvet asoclado al servlclo capLura los evenLos de Llpo lN1kNAl_Ac1lON_5ckN_Oll, lo que provoca la e[ecucln de la lnsLancla del servlclo, mlenLras que sl el servlclo no exlsLe se procede a crearlo medlanLe el procedlmlenLo stott5etvlce. nLese que el procedlmlenLo scteeolsOff se deflne como stotlc, lo que permlLe que sea e[ecuLado fuera del conLexLo de un servlclo, y como syocbtoolzeJ, lo que lmplde que oLro 1bteoJ e[ecuLe cualquler oLro procedlmlenLo de la clase marcado como syocbtoolzeJ hasLa que la e[ecucln de esLe acabe, lo que garanLlza acceso excluslvo a la clase mlenLras el servlclo se crea.
www.FreeLibros.me
46 r|mera act|vac|n de un serv|c|o tras su |nstanc|ac|n Al lnsLanclar un servlclo, y [usLo despues de acLlvarse el evenLo oocteote, se produce la acLlvacln del evenLo oo5tottcommooJ, que reclbe como parmeLro un loteot que puede procesarse usando el 8tooJcostkecelvet que asoclemos al servlclo. publlc lnL onSLarLCommand(lnLenL lnLenL, lnL flags, lnL sLarL_ld) [ l8roadcasL8ecelver.on8ecelve(Lhls, lnLenL), reLurn super.onSLarLCommand(lnLenL, flags, sLarL_ld), } ? hasLa aqul las caracLerlsLlcas prlnclpales de los servlclos, que podrs ver en deta||e en nuestro programa de e[emp|o, que hemos adapLado para que el replnLado del wldgeL se asocle a uno, lo que en condlclones reales permlLlrla e[ecuLar procedlmlenLos y clculos comple[os ya que, como recordars, e| t|empo de proceso mx|mo asoc|ado a |os eventos de| s|stema es de c|nco segundos. www.FreeLibros.me
47 CAI1ULC 10 Cbtener perm|so de superusuar|o (root)
Ln el curso Androld que acabamos en esLe caplLulo hemos expllcado las esLrucLuras bslcas que os permlLlrn lmplemenLar vuesLras apllcaclones, pasando por las acLlvldades y los Lhreads, y sln olvldar los servlclos, los permlsos y el paso de mensa[es enLre apllcaclones. Ln esLe bloque, y pese a que probablemenLe no os ser de uLllldad ms que en unos pocos casos, queremos expllcaros cmo consegulr prlvlleglos de admlnlsLrador en vuesLras apllcaclones, lo que os permlLlr desarrollar apllcaclones que se e[ecuLen sln las resLrlcclones lmpuesLas por el slsLema. Como hemos lndlcado en muchas ocaslones en nuesLros posLs de lndole general, Andro|d es un s|stema estructurado en capas, cada una de |as cua|es |nteracc|ona con |as capas super|or e |nfer|or e |ncorpora un n|ve| de abstracc|n d|ferente. Ln concreLo, |as ap||cac|ones se e[ecutan sobre Da|v|k, |a mqu|na v|rtua| que |ncorpora Andro|d y que se encarga de la e[ecucln de las apllcaclones, lncluyendo LanLo las que perLenecen al slsLema como al usuarlo, y delegando en el slsLema la gesLln de procesos y memorla. Da|v|k e[ecuta |as ap||cac|ones en e| contexto de| usuar|o a| que pertenecen, que se crea en el momenLo en que esLas se lnsLalan y esLo no puede camblarse, |o que |mpos|b|||ta |a |nc|us|n de cd|go pr|v||eg|ado d|rectamente en |as ap||cac|ones y ob||ga a |a creac|n de un proceso separado, como veremos ms adelanLe.
www.FreeLibros.me
48 Cmo func|ona e| root La adqulslcln del rooL en Lermlnales Androld es realmenLe lngenlosa, y se dlvlde en dos parLes claramenLe dlferencladas. or un |ado un programa que pertenece a| usuar|o root y que t|ene act|vo e| b|t SUID, lo cual permlLe que su e[ecucln se reallce usando el cdlgo de usuarlo al que perLenece el programa (rooL en esLe caso) y no el cdlgo de usuarlo que reallza la llamada (el aslgnado a nuesLra apllcacln), y que lo unlco que hace es e[ecuLar el programa que reclbe como parmeLro, hablLualmenLe un shell, una vez comprobado que el usuarlo ha decldldo permlLlrlo, or otro |ado una ap||cac|n, con |nterfaz grf|ca, y que no d|spone de n|ngn pr|v||eg|o espec|a|, que se encarga de mosLrar un dllogo al usuarlo cada vez que una apllcacln desea obLener prlvlleglos de superusuarlo y que slmpllflca la gesLln de dlchos permlsos, la vlsuallzacln de logs, eLc. Ap||cac|ones como SuperUser y SuperSU |mp|ementan esta |nterfaz grf|ca, Lodo y que, ba[o deLermlnadas slLuaclones, son capaces de acLuallzar y/o descargar Lamblen el archlvo blnarlo asoclado. Cbtenc|n de| root en una ap||cac|n Como hemos lndlcado anLerlormenLe, |a obtenc|n de |os perm|sos de superusuar|o no puede hacerse en e| contexto de| proceso que se est e[ecutando, slno que deberemos e[ecuLar un proceso exLerno, que ser el que e[ecuLe el cdlgo prlvlleglado y del que deberemos capLurar la sallda para comprobar sl la e[ecucln ha sldo correcLa o no. ese a que podemos e[ecuLar un comando cada vez, |o ms hab|tua| es que e| comando que se e[ecute sea una she||, |o que perm|t|r |a e[ecuc|n de var|os comandos de forma secuenc|a|, pudlendo capLurar la sallda de cada uno de ellos de forma separada. LsLa forma de acLuar permlLe, adems, que |a so||c|tud de |os perm|sos de superusuar|o (por medlo de la apllcacln SuperUser o SuperSU) se rea||ce una unlca vez, cuando se |n|c|a e| she||, y no cada vez que se e[ecuLa un comando. lrocess = 8unLlme.geL8unLlme().exec(su -c sh"), Capturando |a sa||da de| proceso pr|v||eg|ado 1odo proceso Un|x estndar d|spone de dos cana|es por |os que expu|sa e| resu|tado de |as operac|ones que e[ecuta: e| cana| de sa||da, que es aquel en el que se lmprlmen el resulLado de las operaclones prlnL, wrlLe y, en general, aquellas funclones y procedlmlenLos que lmprlmen resulLados y, e| cana| de errores, en el que se escrlben los cdlgos y mensa[es de error y adverLenclas. www.FreeLibros.me
49 Ad|c|ona|mente, es necesarlo abrlr un canal que permlLa envlar los comandos al proceso prlvlleglado que acabamos de crear, y que en unlx se conoce como cana| de entrada de| proceso. luaLaCuLpuLSLream = new uaLaCuLpuLSLream(lrocess.geLCuLpuLSLream()), luaLalnpuLSLream = new uaLalnpuLSLream(lrocess.geLlnpuLSLream()), luaLaLrrorSLream = new uaLalnpuLSLream(lrocess.geLLrrorSLream()), Lnv|ando comandos a| proceso pr|v||eg|ado una vez ablerLo el canal de enLrada esLndar del proceso prlvlleglado, la e[ecucln de comandos se reallza cada vez que envlamos una llnea de LexLo por dlcho canal. publlc boolean execuLe(SLrlng command) [ luaLaCuLpuLSLream.wrlLe8yLes(command n"), luaLaCuLpuLSLream.flush(), } kec|b|endo resu|tados de| proceso pr|v||eg|ado uel mlsmo modo, la recepcln de resulLados se reallza leyendo de los canales de sallda y errores, Lal como se muesLra ms aba[o. publlc LlsL geLSLandardCuLpuL() [ LlsL resulLs = new ArrayLlsL(), SLrlng llne, whlle (Lrue) [ llne = luaLalnpuLSLream.readllne(), lf (llne == null) break, resulLs.add(llne), } reLurn resulLs, } publlc LlsL geLSLandardLrrorsCuLpuL() [ LlsL resulLs = new ArrayLlsL(), SLrlng llne, whlle (Lrue) [ llne = luaLaLrrorSLream.readllne(), lf (llne == null) break, resulLs.add(llne), } reLurn resulLs, } Comprobac|n de |os perm|sos Ll meLodo ms senclllo para comprobar sl la obLencln de los permlsos de superusuarlo ha sldo exlLosa es la e[ecucln del comando lJ, que nos proporclonar lnformacln sobre el usuarlo que esL e[ecuLando la apllcacln y que deberla ser 0 en caso aflrmaLlvo. execuLe(ld"), LlsL ouLpuL = geLSLandardCuLpuL(), lf ((ouLpuL == null) || (ouLpuL.lsLmpLy())) Lhrow new LxcepLlon("CanL geL rooL access or denled by user"), lf ( ouLpuL.LoSLrlng().conLalns("uld=0")) Lhrow new LxcepLlon("8ooL access re[ecLed by user or devlce lsnL rooLed"), Acabar |a ses|n una vez que se han e[ecuLado Lodos los comandos necesarlos, ser convenlenLe flnallzar la sesln de shell, medlanLe la e[ecucln del comando exlt, que provocar la flnallzacln del proceso asoclado y el clerre de los canales de comunlcaclones asoclados al mlsmo. www.FreeLibros.me
30
Con esLo damos por flnallzado nuesLro curso Androld, no sln anLes agradeceros vuesLra aLencln y anlmaros a descargaros |a |t|ma vers|n de| m|smo, que lncluye el cdlgo compleLo necesarlo para consegulr permlsos de superusuarlo en vuesLras apllcaclones. www.FreeLibros.me
31
Ll CUkSC DL kCGkAMACICN LN ANDkCID AkA kINCIIAN1LS ha sldo desarrollado por 8oberL . para IaqsAndro|d.com del Grupo bemoob.
LsLe obra esL ba[o una L|cenc|a Creat|ve Commons Atr|buc|n-NoComerc|a|- S|nDer|vadas 3.0 Unported.