Estou procurando um exemplo de algo que pode ser feito com um IntentServiceque não pode ser feito com um Service(e vice-versa)?

Eu também acredito que um IntentServiceé executado em um segmento diferente e um Servicenão. Então, tanto quanto eu posso ver, iniciar um serviço dentro de seu próprio encadeamento é como iniciar um IntentService. Isso está correto?

Tejas Lagvankar escreveu um bom post sobre este assunto. Abaixo estão algumas diferenças importantes entre Service e IntentService.

Quando usar?

• O Serviço pode ser usado em tarefas sem interface do usuário, mas não deve ser muito longo. Se você precisar executar tarefas longas, deverá usar threads no Serviço.

• O IntentService pode ser usado em tarefas longas, geralmente sem comunicação com o Thread Principal. Se a comunicação for necessária, é possível usar o manipulador de thread principal ou intenções de transmissão. Outro caso de uso é quando são necessários retornos de chamada (tarefas acionadas por intenção).

Como desencadear?

• O serviço é acionado pelo método de chamada startService().

• O IntentService é acionado usando um Intent, gera um novo thread de trabalho e o método onHandleIntent()é chamado nesse segmento.

Disparado de

• O Serviço e o IntentService podem ser acionados a partir de qualquer encadeamento, atividade ou outro componente do aplicativo.

Corre em

• O Serviço é executado em segundo plano, mas é executado no Thread Principal do aplicativo.

• O IntentService é executado em um thread de trabalho separado.

Limitações / Desvantagens

• O Serviço pode bloquear o Tópico Principal do aplicativo.

• O IntentService não pode executar tarefas em paralelo. Portanto, todas as intenções consecutivas irão para a fila de mensagens do segmento de trabalho e serão executadas sequencialmente.

Quando parar?

• Se você implementar um Serviço , é de sua responsabilidade interromper o serviço quando seu trabalho estiver concluído, ligando stopSelf()ou stopService(). (Se você deseja apenas fornecer ligação, não precisa implementar esse método).

• O IntentService interrompe o serviço após o processamento de todas as solicitações de início, para que você nunca precise ligar stopSelf().

Se alguém pode me mostrar um exemplo de algo que pode ser feito com um IntentServicee não pode ser feito com um Servicee o contrário.

Por definição, isso é impossível. IntentServiceé uma subclasse de Service, escrita em Java. Portanto, qualquer coisa que um IntentServicefaz, um Servicepoderia fazer, incluindo os bits relevantes de código que são IntentServiceusados.

Iniciar um serviço com seu próprio encadeamento é como iniciar um IntentService. Não é?

Os três principais recursos de um IntentServicesão:

• o encadeamento em segundo plano

• o enfileiramento automático de Intents entregues para onStartCommand(), portanto, se um Intentestiver sendo processado onHandleIntent()no encadeamento em segundo plano, outros comandos ficam na fila aguardando sua vez

• o desligamento automático do IntentService, através de uma chamada para stopSelf(), assim que a fila estiver vazia

Tudo isso pode ser implementado por um Servicesem extensão IntentService.

Serviço

• Invocar por startService()
• Disparado de qualquer Thread
• Corre em Main Thread
• Pode bloquear o thread principal (UI). Sempre use encadeamento em serviço para tarefas longas
• Após a conclusão da tarefa, é nossa responsabilidade interromper o serviço ligando stopSelf()oustopService()

IntentService

• Ele executa tarefas longas, geralmente sem comunicação com o encadeamento principal, se a comunicação for necessária, então é feita por HandlerouBroadcastReceiver
• Invocar por Intent
• Disparado de Main Thread
• Executa no thread separado
• Não é possível executar a tarefa em paralelo e várias intenções estão na fila no mesmo segmento de trabalho.

Não reinvente a roda

IntentService estende a classe Service, o que significa claramente que IntentServiceé feito intencionalmente para o mesmo propósito.

Então, qual é o propósito?

`O objetivo do IntentService é facilitar nosso trabalho de executar tarefas em segundo plano sem sequer se preocupar com

• Criação de thread de trabalho

• Enfileirando a solicitação múltipla de processamento, uma por uma ( Threading)

• Destruindo o Service

Portanto , NÃO , Servicepode fazer qualquer tarefa que um IntentServicefaria. Se seus requisitos se enquadram nos critérios mencionados acima, você não precisa escrever essas lógicas na Serviceclasse. Portanto, não reinvente a roda porque IntentServiceé a roda inventada.

A principal diferença

O Serviço é executado no thread da interface do usuário, enquanto um IntentService é executado em um thread separado

Quando você usa o IntentService?

Quando você deseja executar várias tarefas em segundo plano, uma por uma, que exista além do escopo de uma Atividade, isso IntentServiceé perfeito.

Como IntentServiceé feitoService

A normais corridas de serviços no segmento de interface do usuário (qualquer componente Android tipo é executado no segmento interface do usuário por exemplo, padrão Activity, BroadcastReceiver, ContentProvidere Service). Se você precisar fazer algum trabalho que possa demorar um pouco para concluir, precisará criar um encadeamento. No caso de várias solicitações, você terá que lidar synchronization. IntentServicerecebe alguma implementação padrão que executa essas tarefas para você.
De acordo com a página do desenvolvedor

1. IntentService cria um segmento de trabalho

2. IntentServicecria uma fila de trabalho que envia uma solicitação ao onHandleIntent()método, uma a uma

3. Quando não há trabalho, IntentServicechama o stopSelf()método
4. Fornece implementação padrão para o onBind()método que é nulo
5. Implementação padrão para a onStartCommand()qual envia Intentsolicitação para o WorkQueue e, eventualmente, paraonHandleIntent()

Adicionando pontos à resposta aceita:

Veja o uso do IntentService na API do Android. por exemplo:

public class SimpleWakefulService extends IntentService {
    public SimpleWakefulService() {
        super("SimpleWakefulService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {  ...}

Para criar um componente IntentService para o seu aplicativo, defina uma classe que estenda o IntentService e, dentro dele, defina um método que substitua onHandleIntent ().

Além disso, consulte o código-fonte do IntentService, seus métodos de construtor e ciclo de vida, como onStartCommand ...

  @Override
    public int More ...onStartCommand(Intent intent, int flags, int startId) {
       onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

O serviço conjunto de um AsyncTask é uma das melhores abordagens para muitos casos de uso em que a carga útil não é enorme. ou apenas crie uma classe estendendo o IntentSerivce. Na versão 4.0 do Android, todas as operações de rede devem estar em processo em segundo plano, caso contrário, a compilação / construção do aplicativo falhará. thread separado da interface do usuário. A classe AsyncTask fornece uma das maneiras mais simples de disparar uma nova tarefa do thread da interface do usuário. Para mais discussões sobre este tópico, consulte a postagem do blog.

do guia do desenvolvedor do Android :

IntentService é uma classe base de Serviços que manipula solicitações assíncronas (expressas como Intents) sob demanda. Os clientes enviam solicitações por meio de chamadas startService (Intent); o serviço é iniciado conforme necessário, lida com cada Intent, por sua vez, usando um encadeamento de trabalho e para-se quando fica sem trabalho.

Padrão de design usado no IntentService

: Esse padrão de "processador de fila de trabalho" é comumente usado para descarregar tarefas do encadeamento principal de um aplicativo. A classe IntentService existe para simplificar esse padrão e cuidar da mecânica. Para usá-lo, estenda o IntentService e implemente onHandleIntent (Intent). IntentService receberá os Intents, iniciará um thread de trabalho e interromperá o serviço conforme apropriado.

Todas as solicitações são tratadas em um único thread de trabalho - elas podem levar o tempo necessário (e não bloquearão o loop principal do aplicativo), mas apenas uma solicitação será processada por vez.

A classe IntentService fornece uma estrutura direta para executar uma operação em um único encadeamento em segundo plano. Isso permite lidar com operações de longa duração sem afetar a capacidade de resposta da interface do usuário. Além disso, um IntentService não é afetado pela maioria dos eventos do ciclo de vida da interface do usuário, portanto, continua sendo executado em circunstâncias que encerrariam uma AsyncTask.

Um IntentService tem algumas limitações:

Ele não pode interagir diretamente com sua interface de usuário. Para colocar seus resultados na interface do usuário, você deve enviá-los para uma atividade. Solicitações de trabalho são executadas seqüencialmente. Se uma operação estiver em execução em um IntentService e você enviar outra solicitação, a solicitação aguardará até que a primeira operação seja concluída. Uma operação em execução em um IntentService não pode ser interrompida. No entanto, na maioria dos casos

IntentService é a maneira preferida para operações simples em segundo plano

**

Volley Library

Existe a biblioteca chamada volley-library para o desenvolvimento de aplicativos de rede Android. O código fonte está disponível para o público no GitHub.

A documentação oficial do Android sobre Práticas recomendadas para trabalhos em segundo plano : ajuda a entender melhor sobre serviço intencional, encadeamento, manipulador e serviço. e também executando operações de rede

Tenho certeza de que você pode encontrar uma extensa lista de diferenças pesquisando apenas algo como 'Android IntentService vs Service'

Uma das diferenças mais importantes, por exemplo, é que o IntentService termina a si mesmo quando terminar.

Alguns exemplos (criados rapidamente) podem ser;

IntentService: se você deseja baixar um monte de imagens no início da abertura do aplicativo. É um processo único e pode se limpar depois que tudo é baixado.

Serviço: um serviço que será constantemente usado para se comunicar entre seu aplicativo e o back-end com chamadas de API da web. Mesmo que tenha terminado com sua tarefa atual, você ainda deseja que ela seja exibida alguns minutos depois, para obter mais comunicação.

IntentService

IntentServiceexecuta em seu próprio encadeamento. Ele irá parar quando terminar. Mais como fogo e esqueça. As chamadas subseqüentes serão enfileiradas. Bom para enfileirar chamadas. Você também pode girar vários threads dentro IntentServicese precisar - Você pode conseguir isso usando ThreadPoolExecutor. Digo isso porque muitas pessoas me perguntaram "por que usar, IntentServicepois não suporta execução paralela". IntentServiceé apenas uma discussão. Você pode fazer o que precisar dentro dele - mesmo girando vários threads. A única ressalva é que IntentServicetermina assim que você gira os vários segmentos. Não espera que esses threads retornem. Você precisa cuidar disso. Então, eu recomendo usar ThreadPoolExecutornesses cenários.

• Bom para sincronizar, carregar etc ...

Serviço

Por padrão, Serviceé executado no thread principal. Você precisa girar um segmento de trabalho para fazer seu trabalho. Você precisa parar serviceexplicitamente. Usei-o para uma situação em que você precisa executar coisas em segundo plano, mesmo quando se afasta do aplicativo e volta mais para um Headless service.

• Novamente, você pode executar vários threads, se necessário.
• Pode ser usado para aplicativos como players de música.

Você sempre pode se comunicar de volta à sua atividade usando, BroadcastReceiversse necessário.

Um IntentService é uma extensão de um Serviço que é feito para facilitar a execução de uma tarefa que precisa ser executada em segundo plano e em um encadeamento separado.

O IntentService inicia, cria um encadeamento e executa sua tarefa no encadeamento. Uma vez feito, ele limpa tudo. Somente uma instância de um IntentService pode ser executada ao mesmo tempo, várias chamadas são enfileiradas.

É muito simples de usar e muito conveniente para muitos usos, como baixar coisas. Mas tem limitações que podem fazer com que você queira usar o Serviço mais básico (não simples).

Por exemplo, um serviço conectado a um servidor xmpp e vinculado por atividades não pode ser simplesmente executado usando um IntentService. Você acabará ignorando ou substituindo os itens do IntentService.

Se alguém pode me mostrar um exemplo de algo que você pode fazer com um IntentServicee não pode ser feito com um servicee o contrário.

IntentService não pode ser usado para ouvir muito tempo, o Like for XMPP Listeners, um operador único, faz o trabalho e se despede.

Também possui apenas um threadworker, mas com um truque, você pode usá-lo como ilimitado.

A principal diferença entre a Servicee an IntentServiceé descrita a seguir:

Serviço :

1.A, Servicepor padrão, é executado no thread principal do aplicativo. (Aqui nenhum thread de trabalho padrão está disponível). Portanto, o usuário precisa criar um thread separado e executar o trabalho necessário nesse thread.

2. Permite várias solicitações por vez. (Multi Threading)

IntentService:

1.Agora, chegando a IntentService, aqui um thread de trabalho padrão está disponível para executar qualquer operação. Observe que - Você precisa implementar o onHandleIntent()método, que recebe a intenção de cada solicitação de início, onde é possível realizar o trabalho em segundo plano.

2.Mas permite apenas uma solicitação por vez.

Android IntentService vs Serviço

1.Serviço

• Um serviço é chamado usando startService ().
• Um serviço pode ser chamado de qualquer encadeamento.
• Um serviço executa operações em segundo plano no segmento principal do aplicativo por padrão. Portanto, ele pode bloquear a interface do usuário do seu aplicativo.
• Um serviço chamado várias vezes criaria várias instâncias.
• Um serviço precisa ser parado usando stopSelf () ou stopService ().
• O serviço Android pode executar operações paralelas.

2. IntentService

• Um IntentService é chamado usando Intent.
• Um IntentService pode ser chamado apenas do thread Principal.
• Um IntentService cria um thread de trabalho separado para executar operações em segundo plano.
• Um IntentService chamado várias vezes não criará várias instâncias.
• Um IntentService para automaticamente depois que a fila é concluída. Não há necessidade de acionar stopService () ou stopSelf ().
• Em um IntentService, várias chamadas de intenção são enfileiradas automaticamente e seriam executadas seqüencialmente.
• Um IntentService não pode executar uma operação paralela como um Serviço.

Consulte a partir daqui