Índice
Quatro componentes principais do Android:
1. Classificação: Atividade, Serviço, Broadcast Receiver, Content Provider.
1、Atividade
(1) Uma atividade geralmente é uma tela (janela) separada.
(2) As atividades se comunicam por meio da Intenção.
(3) Cada atividade em um aplicativo Android deve ser declarada no arquivo de configuração AndroidManifest.xml, caso contrário o sistema não reconhecerá ou executará a atividade.
2、Serviço
(1) O serviço é usado para concluir operações especificadas pelo usuário em segundo plano. Existem dois tipos de serviços:
(a) iniciado: quando um componente do aplicativo (como atividade) chama o método startService() para iniciar o serviço, o serviço está no estado iniciado.
(b) vinculado: quando o componente do aplicativo chama o método bindService() para vincular ao serviço, o serviço está no estado vinculado.
(2) A diferença entre startService() e bindService():
(a) O serviço iniciado (serviço iniciado) é iniciado por outros componentes que chamam o método startService(), o que faz com que o método onStartCommand() do serviço seja chamado. Quando um serviço está no estado iniciado, seu ciclo de vida é independente do componente que o iniciou e pode ser executado em segundo plano indefinidamente, mesmo que o componente que iniciou o serviço tenha sido destruído. Portanto, o serviço precisa ser interrompido chamando o método stopSelf() após concluir a tarefa ou por outros componentes que chamam o método stopService().
(b) Use o método bindService() para habilitar o serviço. O chamador e o serviço estão vinculados. Assim que o chamador sair, o serviço será encerrado. Isso tem a característica de "se você não quiser morar no mesmo tempo, você deve morrer ao mesmo tempo".
(3) Os desenvolvedores precisam declarar todos os serviços no arquivo de configuração da aplicação, usando tags.
(4) O serviço geralmente é executado em segundo plano e geralmente não precisa interagir com os usuários, portanto o componente Serviço não possui uma interface gráfica de usuário. Os componentes de serviço precisam herdar a classe base Service. Os componentes de serviço geralmente são usados para fornecer serviços em segundo plano para outros componentes ou monitorar o status de execução de outros componentes.
3、Provedor de conteúdo
(1) A plataforma Android fornece ao Provedor de Conteúdo o conjunto de dados especificado de um aplicativo para outros aplicativos. Outros aplicativos podem obter ou armazenar dados deste provedor de conteúdo por meio da classe ContentResolver.
(2) Os provedores de conteúdo só são necessários se os dados precisarem ser compartilhados entre vários aplicativos. Por exemplo, os dados do catálogo de endereços são usados por vários aplicativos e devem ser armazenados em um provedor de conteúdo. Seu benefício é unificar a forma como os dados são acessados.
(3) ContentProvider realiza compartilhamento de dados. ContentProvider é usado para salvar e obter dados e torná-los visíveis para todos os aplicativos. Esta é a única maneira de compartilhar dados entre diferentes aplicativos porque o Android não fornece uma área de armazenamento comum que todos os aplicativos possam acessar.
(4) Os desenvolvedores não usarão objetos da classe ContentProvider diretamente, a maioria deles implementa operações em ContentProvider por meio de objetos ContentResolver.
(5) ContentProvider usa URI para identificar exclusivamente seu conjunto de dados. O URI aqui é prefixado com content://, indicando que os dados são gerenciados por ContentProvider.
4、Receptor de transmissão
(1) Seu aplicativo pode usá-lo para filtrar eventos externos e apenas receber e responder a eventos externos de interesse (como quando uma chamada telefônica é recebida ou quando a rede de dados está disponível). Os receptores de transmissão não possuem interface de usuário. No entanto, eles podem iniciar uma atividade ou serviço em resposta às informações que recebem ou usar um NotificationManager para notificar o usuário. As notificações podem ser usadas de várias maneiras para atrair a atenção do usuário, como piscar a luz de fundo, vibrar, reproduzir sons, etc. De modo geral, você coloca um ícone persistente na barra de status que o usuário pode abrir e receber a mensagem.
(2) Existem dois métodos para registrar receptores de transmissão, ou seja, registro dinâmico no programa e registro estático no arquivo AndroidManifest.
(3) A característica dos receptores de transmissão registrados dinamicamente é que quando a atividade usada para registro for desligada, a transmissão se tornará inválida. O registro estático não precisa se preocupar se o receptor de transmissão está desligado. Enquanto o dispositivo estiver ligado, o receptor de transmissão também estará ligado. Ou seja, mesmo que o aplicativo em si não seja iniciado, a transmissão inscrita pelo aplicativo irá afetá-lo quando acionado.
2. Resumo dos quatro componentes principais do Android:
1. Registro de 4 componentes principais
Os quatro componentes básicos precisam ser registrados antes de serem usados. Cada atividade, serviço e provedor de conteúdo precisam ser configurados no arquivo AndroidManifest. Atividades, serviços e provedores de conteúdo que não estiverem declarados no arquivo AndroidManifest não ficarão visíveis para o sistema e, portanto, não estarão disponíveis. O cadastro dos broadcast receivers é dividido em cadastro estático (configurado no arquivo AndroidManifest) e criação dinâmica através de código e cadastro no sistema por meio da chamada Context.registerReceiver(). Ressalta-se que o receptor de transmissão configurado no arquivo AndroidManifest permanecerá ativo durante a inicialização do sistema, e será acionado enquanto uma transmissão de interesse for recebida (mesmo que o programa não esteja em execução).
2. Ativação de 4 componentes principais
Ativação do provedor de conteúdo: Após receber uma solicitação do ContentResolver, o provedor de conteúdo é ativado. Os outros três componentes atividades, serviços e receptores de transmissão são ativados por uma mensagem assíncrona chamada intenção.
3. Fechamento de 4 componentes principais
Os provedores de conteúdo só são ativados em resposta a solicitações do ContentResolver. Um receptor de transmissão só é ativado em resposta a mensagens de transmissão. Portanto, não há necessidade de fechar explicitamente esses componentes. Fechamento de atividade: você pode fechar uma atividade chamando seu método finish(). Encerramento do serviço: Para serviços iniciados através do método startService(), o método Context.stopService() deve ser chamado para encerrar o serviço. Para serviços iniciados usando o método bindService(), o método Contex.unbindService() deve ser chamado para encerrar o serviço.
4. Tarefas no Android (pilha de atividades)
(a) Uma tarefa é na verdade uma pilha de atividades, que consiste em uma ou mais atividades que juntas completam uma experiência completa do usuário. A parte inferior da pilha é a atividade que inicia toda a tarefa, e o topo da pilha é a atividade atualmente em execução com a qual o usuário pode interagir. Quando uma atividade inicia outra, a nova atividade é colocada na pilha e se torna a atividade atual. atividade de corrida. A atividade anterior permanece na pilha. Quando o usuário pressiona a tecla VOLTAR, a atividade atual sai da pilha e a anterior retorna para a atividade em execução no momento. O que é salvo na pilha é na verdade um objeto. As atividades na pilha nunca serão reorganizadas, mas apenas empurradas ou removidas.
(b) Todas as atividades na tarefa se movem como um todo. A tarefa inteira (ou seja, pilha de atividades) pode ser movida para o primeiro plano ou recuada para segundo plano.
(c) O sistema Android é um sistema operacional multitarefa que pode executar vários outros programas enquanto ouve música no seu celular. Cada vez que um aplicativo adicional é executado, mais memória do sistema será consumida. Quando muitos programas são executados ao mesmo tempo, ou o programa fechado não libera memória corretamente, o sistema ficará cada vez mais lento, ou mesmo instável. Para resolver este problema, o Android introduziu um novo mecanismo, nomeadamente Ciclo de Vida.
3. Duas maneiras de iniciar serviços Android
Prefácio: O serviço é um dos quatro principais componentes do Android e também é um programa executável. Os serviços são uma solução para executar programas em segundo plano no Android, são muito adequados para realizar tarefas que não requerem interação com os usuários e exigem execução de longo prazo. Existem duas maneiras de iniciar o serviço. Vamos resumir as diferenças entre as duas formas.
1. A primeira maneira de iniciar o serviço
Use o método start para iniciar o serviço
Uso básico de serviços: 1. Crie uma classe que herde Service, indicando que se trata de um serviço.
2. Registre-se em AndriodMainfest.xml. Cada serviço precisa ser registrado para entrar em vigor. Ele será registrado por padrão no Android Studio.
3. Use o método startService(Intent) de Contexto para iniciar o Serviço.
4. Use stopService(Intent) para interromper o serviço.
Nota: O ciclo de vida do Serviço iniciado usando este método de início é o seguinte: onCreate()—>onStartCommand()—>onDestory(). onCreate() será executado uma vez quando o serviço for criado, e onStartCommand() será executado toda vez que o serviço for iniciado.Quando o serviço parar, onDestroy() será chamado.
Características: Embora o serviço seja iniciado na atividade, após o início do serviço basicamente não há relação entre a atividade e o serviço. Depois que o serviço for executado onStartCommand() após ser iniciado, ele estará sempre em execução e a atividade não poderá ser controlada. O método onBind() pode aproximar a relação entre atividades e serviços.
2. A segunda forma de criar Serviço
Use bind para iniciar o serviço
Passos para utilizar Service: 1. Crie uma classe que herde Service, indicando que se trata de um serviço.
2. Registre-se em AndriodMainfest.xml. Cada serviço precisa ser registrado para entrar em vigor. Ele será registrado por padrão no Android Studio.
3. Use o método bindService(Intent, ServiceConnection, int) de Contexto para iniciar o Serviço
4. Quando não estiver mais em uso, chame o método unbindService(ServiceConnection) para interromper o serviço.
O ciclo de vida de um serviço iniciado usando este método inicial é o seguinte:
onCreate()—>onBind()—>onunbind()—>onDestory()
Nota: O serviço vinculado não chamará o método onstart() ou onstartcommand()
Recursos: Use o método bind para iniciar o serviço e vincular o serviço. Se o chamador desligar, o serviço também desligará.
O fichário pode chamar métodos no serviço.
4. Ciclo de vida do aplicativo
Recentemente, tenho estudado o desenvolvimento de plug-ins Replugin e descobri que a inicialização é chamada em Application, então quero aprender um pouco sobre Application.
1. Métodos relacionados
onCreate(): chamado ao criar
attachmentBaseContext (Context base): Herdado de ContextWrapper, define o contexto de contexto mais básico
onTerminate(): será chamado quando a aplicação for completamente fechada.Quando testado com o simulador, nenhum retorno de chamada foi encontrado.
onConfigurationChanged(@NonNull Configuration newConfig): Chame onLowMemory() quando a configuração mudar : Quando a memória do sistema estiver baixa, ele irá notificá-lo para liberar recursos.
onTrimMemory(nível int): Notifica para liberar memória. Durante o teste real, este método será chamado quando o aplicativo for fechado, para que os recursos possam ser liberados aqui.
2. Ciclo de vida
Quando o aplicativo é aberto pela primeira vez:
Operação: Clique para abrir o aplicativo, pressione a tecla Enter para sair do aplicativo
Abra o aplicativo uma segunda vez (sem fechá-lo completamente)
O método onTrimMemory() só será chamado no fechamento. Os métodos onCreate() e attachmentBaseContext() anteriores não serão chamados.
Abra o aplicativo várias vezes (sem fechá-lo completamente)
Todos chamarão apenas o método onTrimMemory()
Feche o aplicativo completamente e abra-o novamente
Terá o mesmo ciclo de vida de quando foi aberto pela primeira vez.
Resumo: Bibliotecas de terceiros são inicializadas basicamente no método onCreate(); se quiser liberar recursos, é melhor fazê-lo no método onTrimMemory(), pois onTerminal() não foi chamado; mas bibliotecas de terceiros precisa ficar atento à liberação de recursos, pois onCreate () A segunda abertura não continuará a execução. Neste momento, é necessário verificar se ele foi inicializado, caso contrário ocorrerá um travamento não inicializado.