guia de laboratorio de servicios en aplicaciones moviles android - ing.ivan petrlik azabache
DESCRIPTION
GUIA DE LABORATORIO DE SERVICIOS EN APLICACIONES MOVILES ANDROID - ING.IVAN PETRLIK AZABACHETRANSCRIPT
DESARROLLO DE APLICACIONES MOVILES EN ANDROID
Servicios en Android
ING.IVAN PETRLIK AZABACHE
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.
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 VidaHay 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 ().
PermisosAcceso 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 VidaEl 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
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 localUno 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.
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.
Ahora vamos a realizar el siguiente diseño.
Proyecto creado
Dar doble clic al archivo main.xml
Diseñando e implementando un boton
Ahora vamos a implementar código a la clase Activity de nombre Inicio.
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 .
Ir a la clase Inicio que representa el Activity principal del proyecto
Listo para empezar a implementar código java en este Activity
Implementando el método IniciarServicio()
Después de haber implementado el método IniciarServicio(View v) ahora vamos a dar el evento del botón de la siguiente manera:
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.
Digitando el nombre del método que se implementó en l clase Activity(Inicio)
1) Ir al main.xml
2) seleccionar el botón Iniciar Servicio y darle clic derecho
3) Elegir Other Properties
4) Elegir All By Name
4) Elegir All By Name
5) Elegir el evento Onclick
6) Digitar el método IniciarServicio
7) Presionar el botón OK
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.
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).
Dar clic derecho al paquete EMPRESA.ANDROID.PRINCIPAL y aparece un menú contextual
Elegir la opción New
Seleccionar la opción Class
Escribir el nombre “Servicio”
Presionar el botón Browse
Así es como debe de quedar en la correspondiente ventana.
Buscar la clase Service
Presionar el botón OK
Presionar el botón Finish
Así es como debe de quedar
Así es como debe de quedar
Esta es la estructura de la clase que hemos creado llamado Servicio
Ahora adicionalmente le implementamos otros métodos complementarios que cumplen un rol específico en un Servicio.
Seleccionar la clase Servicio
Este es el código que se ha generado por defecto de la clase Servicio que hereda de Service
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.
Ahora vamos implementar mensajes para probar que el servicio funciona.
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
Agregando un mensaje de Inicio del Servicio en el método onCreate()
Agregando un mensaje de Fin del Servicio en el método onDestroy()
Ejecutando la aplicación Móvil.
Ahora vamos a desarrollar otra aplicación en android que maneje el tema de Servicios.
Primeramente vamos a crear un proyecto.
A continuación vamos a realizar el diseño respectivo través del archivo main.xml.
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
Ir y dar doble clic al main.xml
Diseñar la respectiva Interfaz grafica
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
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
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
Ejecución de la Aplicación Móvil
Iniciando el servicio
Parando el Servicio