Services

Olá à todos.

Neste tópico falaremos de Services em Android.

Um Service é um componente de aplicação que pode realizar operações de longa duração em modo background, e não necessita de uma interface de usuário. Um outro componente de aplicação pode chamar um Service, e este poderá continuar a rodar em segundo plano mesmo se o usuário mudar o contexto do dispositivo para outra aplicação.

Um Service pode lidar com transações de rede, tocar música, realizar operações I/O, ou interagir com um ContentProvider, tudo em segundo plano.

Um Service pode ser chamado essencialmente possuir duas formas:

• Iniciado → Um Service é "iniciado" quando um componente de aplicação (por exemplo, uma Activity) iniciá-lo chamando startService(). Uma vez iniciado, um serviço pode ser executado em segundo plano por tempo indeterminado, mesmo que o componente que o começou seja destruído. Normalmente, um Service iniciado executa uma única operação e não retorna um resultado para seu chamador. Por exemplo, podemos fazer um download ou upload de um arquivo pela rede. Quando a operação é feita, o Service deve parar a si mesmo.
• Vinculado → Um Service é "vinculado" quando um componente de aplicação liga-se a ele chamando bindService(). Um serviço vinculado oferece uma interface cliente-servidor que permite que componentes consigam interagir com o serviço, enviar requisições e obter resultados. Um Service vinculado executa apenas enquanto outro componente de aplicação é obrigado a isso. Vários componentes podem se ligar a um serviço de uma só vez, mas quando todos se desvincularem, o Service será destruído.

Abaixo temos uma imagem que demonstra estas duas formas.

Para criar um Service, precisamos criar uma sub-classe de Service. Em nossa implementação, precisamos sobrescrever alguns métodos que lidam com aspectos do ciclo de vida de um Service. Os métodos de Service mais importantes são:

• onStartCommand() → O sistema chama este método quando um outro componente, como uma Activity, pede que o serviço seja iniciado, chamando startService(). Uma vez que este método é executado, o Service é iniciado e pode ser executado em segundo plano por tempo indeterminado. Se você implementar isto, é sua a responsabilidade de parar o Service quando o seu trabalho é feito, chamando stopSelf() ou stopService().
• onBind() → O sistema chama este método quando um outro componente quer se ligar ao Service, chamando bindService(). Você sempre deve implementar esse método, mas se você não quer permitir a vinculação, então você deve retornar nulo.
• onCreate() → O sistema chama este método quando o serviço é criado pela primeira vez (antes de chamar ou onStartCommand() ou onBind()). Se o serviço já está em execução, este método não é chamado.
• onDestroy() → O sistema chama este método quando o serviço não é mais utilizado e está sendo destruído. Seu serviço deve implementar isto para limpar todos os recursos como threads, listeners registrados, Broadcast Receivers, etc Esta é a última chamada que o serviço recebe.

Se um componente inicia o Service chamando startService() (o que resulta em uma chamada para onStartCommand()), o Service permanece em execução até que ele se páre com stopSelf() ou outro componente pára-lo chamando stopService().

Se um componente chama bindService() para criar o Service (e onStartCommand() não é chamado), então o Service é executado apenas enquanto o componente é ligado a ele. Uma vez que o Service é desvinculado de todos os componentes, o sistema o destrói.

Exemplo de Service

Utilizaremos como exemplo de Service um tocador de música.

Este exemplo possuirá uma Activity e um Service. Mas antes de mais nada, precisamos declarar o Service em nosso AndroidManifest.xml.

Como podemos ver acima, um Service é declarado de maneira bem simplificada. E ele é chamado pela MainActivity.java da seguinte forma:

Ou seja, estamos chamando um Service através do método startService(). De acordo com o que foi explicado no início deste capítulo, o ciclo de vida que sobrescreveremos contará com os métodos onCreate(), onStart() e onDestroy().

Vamos então à implementação de nosso Service.

Antes de mais nada, podemos notar que neste exemplo, uma música está sendo chamada, através do método MediaPlayer mediaPlayer = MediaPlayer.create(this, R.raw.music). Logo, esta música está localizada na pasta res/raw, como é mostrado abaixo:

Esta pasta se caracteriza por ser a ÚNICA pasta em um projeto de Android que não é compactada quando o aplicativo que estamos implementando for compactado e gerado pelo Eclipse (para futuro upload deste no Google Play).

Ou seja, estamos garantindo que a música não perderá qualidade. Por exemplo, se sua taxa de execução for 256 kbps, estamos garantindo que quando o aplicativo for gerado, ela permanecerá a mesma. Se esta música fosse convertida para uma taxa de execução de 128 kbps, sua qualidade seria perdida, o que poderia gerar uma música de pior qualidade e com timbres menos definidos.

Voltando ao nosso Service, podemos ver que os três métodos descritos anteriormente (onCreate(), onStart() e onDestroy()) foram sobrescritos.

Este Service é chamado quando o botão ”Start” é chamado em nossa MainActivity. O layout da MainActivity é mostrado abaixo:

O primeiro método executado é o onCreate(). Nele criamos nossa instância da classe MusicPlayer. Em seguida, o método executado é o onStart(). Nele, iniciamos nossa música, que ficará tocando em segundo plano, mesmo que nosso dispositivo Android abra outra aplicação.

Tal qual é descrito no início deste capítulo: “o Service permanece em execução até que ele se páre com stopSelf() ou outro componente pára-lo chamando stopService()”. Isto é feito através do botão “Stop”, que finaliza nosso Service mesmo que ele esteja em segundo plano.

Quando isto é feito, o método onDestroy() é chamado no Service. Nele, paramos a música.

Além deste botão “Stop” da MainActivity, que finaliza nosso Service, não podemos esquecer que este Service está ligado à MainActivity. Logo, se a finalizarmos, o Service será finalizado também.

-----

Caso alguém tenha uma dúvida, crítica ou sugestão, sinta-se à vontade.