[Resumo abrangente dos quatro principais componentes - Serviço]

Um resumo abrangente do serviço no Android

1. Tipos de serviço

• [Classificação por local de operação: dividido em serviço local e serviço remoto]

  • Serviço local (Local): Este serviço é anexado ao processo principal,

    • Vantagens:
      O serviço é anexado ao processo principal em vez de um processo independente, o que economiza recursos em certa medida.Além disso, o serviço Local não requer IPC ou AIDL porque está no mesmo processo. O bindService correspondente será muito mais conveniente.

    • Desvantagem: Depois que o processo principal for encerrado, o serviço será encerrado.

    • Cenários de aplicativos: Aplicativos muito comuns, como: serviço de reprodução de música da HTC, serviço de reprodução de música Tiantiandongting.

  • Serviço remoto (Remote): Este serviço é um processo independente,

    • Vantagens:
      O serviço é um processo independente e o formato do nome do processo correspondente é: o nome do pacote mais a string android:process que você especificou. Por se tratar de um processo independente,
      quando o processo onde se encontra a Activity é eliminado, o serviço continua em execução e não será afetado por outros processos, o que favorece a prestação de serviços para múltiplos processos com alta flexibilidade.

    • Desvantagens:　
      Este serviço é um processo independente, que vai ocupar certos recursos, e usar AIDL para IPC é um pouco problemático.

      • Aplicação: Alguns serviços que fornecem serviços de sistema, tais serviços são residentes.

• [Categorizado por tipo de operação: dividido em serviços de primeiro e segundo plano]

  • Recepção:

    • A Notificação de CONTÍNUO será exibida na coluna de notificação. Quando o serviço for encerrado, a Notificação na coluna de notificação também desaparecerá, o que tem um certo efeito de notificação para os usuários.

    • Aplicação: Comum, como serviços de reprodução de música.

  • Serviço em segundo plano:
    O serviço padrão é o serviço em segundo plano, ou seja, a Notificação de EM ANDAMENTO não será exibida na coluna de notificação. Quando o serviço é encerrado, o usuário não pode ver o efeito.

    • Aplicativo:
      Certos serviços que não precisam executar ou encerrar prompts, como atualização do clima, sincronização de datas, sincronização de e-mail, etc.

    • Serviço em segundo plano Podemos criar uma notificação CONTÍNUA (ininterrupta) para que se torne um serviço em primeiro plano?

      • A resposta é não, o serviço de primeiro plano precisa chamar startForeground (android 2.0 e versões posteriores) ou setForeground (android 2.0 e versões posteriores) para tornar o serviço um serviço de primeiro plano depois de fazer o trabalho acima. A vantagem disso é que, quando o serviço for encerrado externamente, a Notificação CONTÍNUA ainda será removida.

• [Classificado por uso]:

  • O serviço iniciado por startService
    é usado principalmente para iniciar um serviço para executar tarefas em segundo plano sem comunicação. Para parar um serviço use stopService

  • O serviço iniciado por bindService
    O serviço iniciado por este método precisa se comunicar. Para interromper um serviço, use unbindService

  • startService também é o serviço iniciado por bindService.
    Para interromper o serviço, você deve usar stepService e unbindService ao mesmo tempo.

  [O ciclo de vida dos serviços iniciados nas três maneiras acima também é diferente].

2. [A diferença entre Service e Thread]

1. Thread: Thread é a menor unidade de execução do programa e é a unidade básica para alocar a CPU. Thread pode ser usado para executar algumas operações assíncronas.

2. Serviço: O serviço é um mecanismo do android. Quando estiver em execução, se for um serviço local, o serviço correspondente estará sendo executado no thread principal do processo principal. Tais como: onCreate, onStart Todas essas funções são executadas no thread principal do processo principal quando são chamadas pelo sistema. Se for um serviço remoto, o serviço correspondente será executado no thread principal de um processo independente. Então, por favor, não entenda Service como um thread, não tem nada a ver com threads!

3. Neste caso, por que usamos Service?

   Na verdade, isso está relacionado ao mecanismo do sistema android, vamos pegar o Thread como exemplo. A operação do Thread é independente da Activity, ou seja, depois que uma Activity é finalizada, se você não parar o Thread ativamente ou o método run no Thread não for executado, o Thread continuará executando. Portanto, haverá um problema aqui: quando a Activity terminar, você não terá mais uma referência ao Thread. Por outro lado, você não tem como controlar o mesmo Thread em diferentes Activities.

   Por exemplo: Se seu Thread precisa se conectar ao servidor para algum tipo de sincronização em intervalos regulares, o Thread precisa estar em execução mesmo quando a Activity não for iniciada. Neste momento, quando você inicia uma Activity, não há como controlar o Thread criado anteriormente na Activity. Portanto, você precisa criar e iniciar um Serviço, criar, executar e controlar o Thread no Serviço, o que resolve o problema (porque qualquer Activity pode controlar o mesmo Serviço, e o sistema criará apenas uma instância do Serviço correspondente).

4. Portanto, Service pode ser imaginado como um serviço de mensagem, e você pode chamar Context.startService, Context.stopService, Context.bindService, Context.unbindService em qualquer lugar com Context para controlá-lo. Você também pode registrar BroadcastReceiver em Service, em Outros lugares controlá-lo enviando broadcast, é claro, essas são coisas que o Thread não pode fazer.

3. [Ciclo de vida do serviço]

onCreate onStart onDestroy onBind

1. O ciclo de vida do serviço iniciado: Se um serviço for iniciado por uma atividade chamando o método Context.startService, o serviço será executado em segundo plano, independentemente de haver uma atividade usando bindService para vincular ou unbindService para desvincular o serviço. Se um Serviço for iniciado várias vezes pelo método startService, o método onCreate será chamado apenas uma vez, onStart será chamado várias vezes (correspondente ao número de chamadas para startService) e o sistema criará apenas uma instância do Serviço ( então você deve saber que apenas uma chamada stopService). O serviço sempre será executado em segundo plano, independentemente de a atividade do programa correspondente estar em execução, até que seja chamado stopService ou seu próprio método stopSelf. Obviamente, se os recursos do sistema forem insuficientes, o sistema Android também poderá encerrar o serviço.

2. O ciclo de vida do serviço vinculado: Se um serviço for vinculado e iniciado por uma Activity chamando o método Context.bindService, não importa quantas vezes o bindService seja chamado, o método onCreate será chamado apenas uma vez e o método onStart nunca ser chamado. Depois que a conexão for estabelecida, o Serviço continuará rodando, a menos que o Context.unbindService seja chamado para desconectar ou o Context que chamou o bindService antes não exista (como quando a Activity é finalizada), o sistema irá parar automaticamente o Serviço, e o onDestroy correspondente será chamado.

3. O ciclo de vida de um serviço iniciado e vinculado: Se um serviço for iniciado e vinculado novamente, ele sempre será executado em segundo plano. E não importa como for chamado, onCreate só será chamado uma vez, e quantas vezes o onStart do Serviço será chamado correspondente a quantas vezes startService for chamado. Chamar unbindService não interromperá o serviço, mas você deve chamar stopService ou stopSelf do serviço para interromper o serviço.

4. Limpe o serviço quando o serviço for interrompido: Quando um serviço for encerrado (1, chame stopService; 2, chame stopSelf; 3, não haja mais uma conexão vinculada (não iniciada)), o método onDestroy será chamado, aqui você deve faça algum trabalho de limpeza, como interromper os threads criados e executados no Serviço.

prestar atenção:

1. Deve-se saber que ao chamar bindService para vincular ao Serviço, você deve garantir que unbindService seja chamado em algum lugar para desvincular (embora a vinculação seja liberada automaticamente quando a Atividade for concluída e o Serviço pare automaticamente);

2. Deve-se observar que, após usar startService para iniciar o serviço, certifique-se de usar stopService para interromper o serviço, independentemente de usar bindService ou não;

3. Ao usar startService e bindService ao mesmo tempo, deve-se observar que o encerramento do Serviço exige que unbindService e stopService sejam chamados ao mesmo tempo para encerrar o Serviço. Independentemente da ordem de chamada de startService e bindService, se unbindService for chamado primeiro, o serviço não será encerrado automaticamente neste momento e, em seguida, o serviço será chamado após stopService Ele será interrompido. Se stopService for chamado primeiro, o serviço não será encerrado neste momento e, em seguida, o serviço será interrompido automaticamente após chamar unbindService ou o Context que chamou bindService antes não existe (como quando a Activity é finalizada);

4. Ao girar a tela do celular, quando a tela do celular está mudando entre "horizontal" e "vertical", se sua Activity girar automaticamente neste momento, a rotação é na verdade uma recriação da Activity, então a conexão estabelecida usando bindService antes da rotação será desconectada (o contexto não existe) e o ciclo de vida do serviço correspondente é o mesmo que o anterior.

5. No sdk 2.0 e versões posteriores, o onStart correspondente foi descontinuado e alterado para onStartCommand, mas o onStart anterior ainda é válido. Isso significa que, se você desenvolver um aplicativo usando SDK 2.0 e posterior, deverá usar onStartCommand em vez de onStart.

4. Opções comuns do elemento Service no AndroidManifest.xml

android:name　　-------------　　服务类名

android:label　　--------------　　服务的名字，如果此项不设置，那么默认显示的服务名则为类名

android:icon　　--------------　　服务的图标

android:permission　　-------　　申明此服务的权限，这意味着只有提供了该权限的应用才能控制或连接此服务

android:process　　----------　　表示该服务是否运行在另外一个进程，如果设置了此项，那么将会在包名后面加上这段字符串表示另一进程的名字

android:enabled　　----------　　如果此项设置为 true，那么 Service 将会默认被系统启动，不设置默认此项为 false

android:exported　　---------　　表示该服务是否能够被其他应用程序所控制或连接，不设置默认此项为 false