[1] El documento describe los servicios en Android y cómo funcionan. [2] Un servicio es un componente que ejecuta tareas de fondo u ofrece funcionalidad a otras aplicaciones, y puede iniciarse o vincularse a él. [3] Los servicios no tienen su propio proceso o hilo, por lo que deben crear los suyos para trabajos intensivos.

1. DESARROLLO DE APLICACIONES
MOVILES EN ANDROID
Servicios en Android
ING.IVAN PETRLIK AZABACHE
petrlikperu@gmail.com

2. UN SERVICIO EN ANDROID
Un servicio es un componente de aplicación que representa ya sea el deseo de una aplicación
para realizar una operación de más larga duración, mientras que no interactúa con el usuario,
o de proporcionar la funcionalidad para otras aplicaciones a utilizar. Cada clase de servicio
debe
tener
su
correspondiente <service>declaración
en
su
paquete AndroidManifest.xml . Servicios puede iniciar con Context.startService
() y Context.bindService () .
Tenga en cuenta que los servicios, al igual que otros objetos de la aplicación, ejecute en el
hilo principal de su proceso de alojamiento. Esto significa que, si el servicio se va a hacer
ningún uso intensivo de CPU (como reproducción de MP3) o el bloqueo (por ejemplo, redes)
las operaciones, deberá generar su propio hilo en el que para hacer ese trabajo. Más
información
sobre
esto
se
puede
encontrar
en Procesos
y
subprocesos . El IntentService clase está disponible como una aplicación estándar de
servicio que tiene su propio hilo donde se programa su trabajo por hacer.
¿Qué es un servicio?
• Un servicio es no un proceso independiente. El objeto de servicio sí mismo no implica que
se ejecuta en su propio proceso, a menos que se especifique lo contrario, se ejecuta en el
mismo proceso que la aplicación que es parte de.
• Un servicio es no un hilo. No es un medio en sí para hacer el trabajo fuera del hilo principal
(para evitar la aplicación no responde errores).
Así, un mismo servicio es realmente muy simple, que proporciona dos características
principales:
•
Una instalación para la aplicación indique al sistema acerca de algo que quiere hacer en el
fondo (incluso cuando el usuario no está interactuando directamente con la
aplicación). Esto corresponde a las llamadas a Context.startService () , que piden
al sistema para programar el trabajo para el servicio, que se extenderá hasta el servicio o
alguien más explícitamente detenerlo.
•
Una instalación para una aplicación a exponer algunas de sus funciones a otras
aplicaciones. Esto corresponde a las llamadas a Context.bindService () , que
permite una conexión de larga data que deben introducirse en el servicio con el fin de
interactuar con él.
Cuando un componente de servicio se crea realmente, por cualquiera de estas razones,
todo lo que el sistema realmente hace es crear una instancia del componente y llamar a
su onCreate
() y cualesquiera otros callbacks adecuados
en el hilo
principal. Corresponde al Servicio de implementar estos con el comportamiento apropiado,
tal como la creación de un subproceso secundario en el que se realiza su trabajo.

3. Tenga en cuenta que debido a servicio en sí es tan simple, usted puede hacer su interacción
con él tan simple o complicado como quieras: de tratarlo como un objeto local de Java que
permite hacer llamadas a métodos en directo (como lo ilustra Ejemplo de servicio local ), para
proporcionar una interfaz completa con remoteable AIDL.
Servicio del Ciclo de Vida
Hay dos razones por las que un servicio puede ser ejecutado por el sistema. Si alguien llama
a Context.startService () entonces el sistema recuperará el servicio (su creación y
llamando a su onCreate () método si es necesario) y luego llamar a su onStartCommand
(Intent, int, int) método con los argumentos proporcionados por el cliente. El servicio
en este punto continuará funcionando hasta que Context.stopService () o stopSelf
() es llamado.Tenga en cuenta que varias llamadas a Context.startService () no hacen nido
(aunque sí dan lugar a múltiples llamadas correspondientes a onStartCommand ()), así que no
importa cuántas veces se ha iniciado el servicio se detendrá una vez Context.stopService () o
stopSelf () es llamado, sin embargo, los servicios pueden usar su stopSelf (int) método
para garantizar que el servicio no se detiene hasta que comenzaron los intentos han sido
procesados.
Para los servicios iniciados, hay dos modos principales de funcionamiento adicionales pueden
decidir ejecutar en, según el valor que retornan desde onStartCommand (): START_STICKY se
utiliza para los servicios que están explícitamente inicia y se detiene cuando se necesita,
mientras que START_NOT_STICKYo START_REDELIVER_INTENT se utilizan por los servicios
que sólo deben permanecer en funcionamiento mientras el procesamiento de los comandos
enviados a ellos. Consulte la documentación relacionada para obtener más información sobre
la semántica.
Los clientes también pueden utilizar Context.bindService () para obtener una conexión
persistente con un servicio. Esto también crea el servicio si no se está ejecutando
(llamando onCreate () mientras lo hace), pero no llama a onStartCommand (). El cliente
recibirá el IBinder objeto de que el servicio regrese de suonBind (Intención) método,
que permite al cliente hacer llamadas luego de vuelta al servicio. El servicio permanecerá
funcionando mientras se establece la conexión (si o no el cliente mantiene una referencia en
IBinder del servicio). Por lo general, la IBinder devuelto es una interfaz compleja que se
ha escrito en AIDL .
Un servicio puede ser dos partidos y han obligado a las conexiones. En tal caso, el sistema
mantendrá el servicio que se ejecuta siempre que o bien se inicia o hay una o más conexiones
a la misma con el Context.BIND_AUTO_CREATE bandera. Una vez que ninguna de estas
situaciones de espera, el servicio de OnDestroy ()se llama al método y el servicio es
cancelado efectivamente. Todas limpieza (suspensión de hilos, anular el registro de
receptores) deben estar completos al regresar de OnDestroy ().

4. Permisos
Acceso global a un servicio se puede aplicar cuando se declara en su manifiesto
de <service> etiqueta. De este modo, otras aplicaciones tendrá que declarar un
correspondiente <uses-permission> elemento en su propio manifiesto para ser capaz de
iniciar, detener, o enlazar con el servicio.
A partir de GINGERBREAD , al utilizar Context.startService (Intención) , también
puede
establecer Intent.FLAG_GRANT_READ_URI_PERMISSION y
/
oIntent.FLAG_GRANT_WRITE_URI_PERMISSION en el Intento. Esto permitirá el acceso
temporal al servicio específico URI en el Intento. Acceso permanecerá hasta que el Servicio
ha llamado stopSelf (int) para ese comando de arranque o una posterior, o hasta que el
servicio se haya detenido completamente. Esto funciona para permitir el acceso a las otras
aplicaciones que no han solicitado el permiso de la protección del Servicio, o incluso cuando el
servicio no se exporta en absoluto.
Además, un servicio puede proteger a las distintas llamadas del IPC en ella con permisos,
llamando a la checkCallingPermission (String) método antes de ejecutar la
aplicación de esa llamada.
Ver la Seguridad y permisos documento para obtener más información sobre los permisos y la
seguridad en general.
Procesos del Ciclo de Vida
El sistema Android tratarán de mantener el proceso de alojamiento de un servicio en todo el
tiempo que el servicio se ha iniciado o tiene clientes vinculados a la misma. Cuando se ejecuta
bajo en la memoria y la necesidad de matar a los procesos existentes, la prioridad de un
proceso que aloja el servicio será la más alta de las siguientes posibilidades:
•
Si el servicio se está ejecutando código en su onCreate () , onStartCommand
() , o OnDestroy () métodos, entonces el proceso de hospedaje será un proceso en
primer plano para asegurar que este código se puede ejecutar sin ser asesinados.
•
Si el servicio se ha iniciado, a continuación, su proceso de alojamiento se considera
que es menos importante que todos los procesos que están visibles para el usuario en la
pantalla, pero más importante que cualquier proceso no visible. Debido a que sólo unos
pocos procesos son generalmente visibles para el usuario, esto significa que el servicio no
se debe matar salvo en condiciones extremas de poca memoria.
•
Si hay clientes vinculados al servicio, entonces el proceso que aloja el servicio nunca
es menos importante que el cliente más importante. Es decir, si uno de sus clientes es
visible para el usuario, entonces el servicio en sí se considera que es visible.
•
Un
servicio
iniciado
puede
utilizar
el startForeground
(int,
notificación) API para poner el servicio en un estado plano, donde el sistema
considera que es algo que el usuario es consciente y activamente tanto no es un candidato
para matar cuando poca memoria. (Todavía es teóricamente posible que el servicio que se

5. mató bajo presión de memoria extrema de la aplicación actual en primer plano, pero en la
práctica esto no debería ser una preocupación.)
Tenga en cuenta lo que significa que la mayor parte del tiempo el servicio se está ejecutando,
puede ser eliminada por el sistema si se encuentra bajo presión de memoria pesada. Si esto
sucede, el sistema más tarde intentará reiniciar el servicio. Una consecuencia importante de
esto es que si se implementa onStartCommand () para programar el trabajo a realizar de
forma
asíncrona
o
en
otro
hilo,
entonces
es
posible
que
desee
utilizar START_FLAG_REDELIVERY para que el sistema vuelva a emitir un Intención para
usted de modo que no se pierda si su servicio es asesinado mientras procesando.
Otros componentes de aplicación que se ejecutan en el mismo proceso que el servicio (tal
como una actividad ) puede, por supuesto, aumentar la importancia del proceso global más
allá de la importancia del servicio en sí.
Ejemplo de servicio local
Uno de los usos más comunes de un servicio es como un componente secundario que se
ejecuta junto con otras partes de una aplicación, en el mismo proceso que el resto de los
componentes. Todos los componentes de una carrera. Apk en el mismo proceso a menos que
se especifique lo contrario, así que esta es una situación típica.
Cuando se usa de esta manera, asumiendo los componentes están en el mismo proceso, se
puede simplificar mucho la interacción entre ellos: los clientes del servicio simplemente puede
convertir el IBinder que reciben de ella a una clase concreta publicada por el servicio.

6. CREANDO UNA APLICACIÓN ANDROID CON UN SERVICIO MUY
BASICO
Primeramente tenemos que crear un proyecto en Android a través del IDE estrella
Eclipse.
Proyecto creado
Ahora vamos a realizar el siguiente diseño.
Diseñando e
implementando un boton
Dar doble clic al archivo
main.xml

7. Ahora vamos a implementar código a la clase Activity de nombre Inicio.
Ir a la clase Inicio
que representa el
Activity principal del
proyecto
Listo para empezar a implementar
código java en este Activity
Implementamos un método de nombre IniciarServicio(View v) que me permita invocar al
Servicio , para eso tenemos que trabajar con un evento de nombre Onclick al momento de
presionar el botón Iniciar Servicio del archivo main.xml .
Implementando el
método
IniciarServicio()

8. Después de haber implementado el método IniciarServicio(View v)
evento del botón de la siguiente manera:
1) Ir al
main.xml
2) seleccionar el botón
ahora vamos a dar el
3) Elegir Other
Properties
Iniciar Servicio y darle clic
derecho
4) Elegir All
By Name
Después de haber elegido All By Name nos muestra otro menú contextual en la cual tenemos
que seleccionar la opción Onclick , se muestra una ventana en la cual tenemos que digitar el
evento Onclick.
5) Elegir el
evento
Onclick
4) Elegir All By
Name
Digitando el nombre del método que se implementó en l clase Activity(Inicio)
6) Digitar el
método
IniciarServicio
7) Presionar
el botón OK

9. Ahora que el evento del botón Iniciar Servicio invoca al método IniciarServicio implementado en
la clase Inicio (Activity), entonces ya estamos en la condiciones necesarias para poder iniciar el
servicio pero para eso tenemos que en el proyecto crear una clase que represente el servicio a
ejecutar.
Dar clic derecho
al paquete
EMPRESA.ANDROI
D.PRINCIPAL y
aparece un menú
contextual
Elegir la opción
New
Seleccionar la
opción Class
Cuando elegimos la opción class aparece una ventana en la cual tenemos que colocar el
nombre de la clase( Servicio) y luego presionar el botón Browse en la cual aparece una ventana
donde tenemos que buscar la clase en la cual tiene que heredar(Service).
Escribir el
nombre
“Servicio”
Presionar el botón
Browse

10. Buscar la clase
Service
Presionar el
botón OK
Así es como debe de quedar en la correspondiente ventana.
Así es como debe
de quedar
Así es como debe
de quedar
Presionar el
botón Finish

11. Esta es la estructura de la clase que hemos creado llamado Servicio
Seleccionar la
clase Servicio
Este es el código que se ha generado por defecto
de la clase Servicio que hereda de Service
Ahora adicionalmente le implementamos otros métodos complementarios que cumplen un rol
específico en un Servicio.
Aquí le estamos adicionando el método onCreate()
que me permite el inicio del servicio, además el
método onDestroy() que me permite el fin del
Servicio.

12. Ahora vamos implementar mensajes para probar que el servicio funciona.
Agregando un
mensaje de Inicio del
Servicio en el método
onCreate()
Agregando un mensaje de
Fin del Servicio en el
método onDestroy()
Ahora
que hemos colocado dos mensajes en el método onCreate() y el onDestroy(), a
continuación vamos a invocar el Servicio desde la clase Inicio (Activity ) dentro del método
IniciarServicio().
Ir a la clase
Inicio
Crear un Intent
para definir al
servicio que se va a
ejecutar
Ejecutar el
servicio
Parar el servicio

13. Ejecutando la aplicación Móvil.

14. Ahora vamos a desarrollar otra aplicación en android que maneje el tema de Servicios.
Primeramente vamos a crear un proyecto.
Aquí se ha creado un proyecto de nombre
PROYECTOSERVICIOANDROID02
Aquí tenemos creado por defecto la clase Inicio que
es un Activity
Aquí tenemos una Interfaz de nombre Protocolo
Aquí tenemos una clase de nombre
Servicio que hereda de Service
A continuación vamos a realizar el diseño respectivo través del archivo main.xml.
Diseñar la respectiva
Interfaz grafica
Ir y dar doble clic
al main.xml

15. A continuación vamos a detallar cada una de las clases mencionadas en la figura anterior.
Protocolo.java
Inicio.java
Mapeando el
EditText
Invocando al método Actualizar y
enviar un objeto de la actividad

16. Método que me permite imprimir el
contador en el campo de texto
Método que me permite
el inicio del Servicio
Método que me permite el fin del
Servicio

17. Servicio.java
Este método me sirve para referenciar un
objeto que llega de la clase Inicio y asi
poder llamar al método contabilizar() en el
Servicio
Este método
me permite el
inicio del
contador
donde cada 1
segundo se
incrementa
en una
unidad
Este método me
permite el
termino del
contador

18. Ejecución de la Aplicación Móvil
Iniciando el servicio
Parando el Servicio