Análise de atividade dos quatro principais componentes do Android (on)

I. Visão geral

Simplificando, Activity é uma interface visual, responsável por construir uma janela de tela para evitar componentes de UI para interação do usuário. De um modo geral, existem três etapas para construir a Atividade:

1. Contrato para construir classe de atividade;
2. Registre-se em AndroidManifest.xml;
3. Defina o arquivo de layout (opcional).

2. Como iniciar a atividade

2.1, inicialização da tela

Especifique claramente a classe da Atividade a ser iniciada $CLASS$ ou$Pacotenome.Activityclassenome$ , existem três principais formas de inicialização display:

• Método 1: salto de classe (mais comumente usado)

  Intent intent = new Intent(MainActivity.this, SecondActivity.class);
  startActivity(intent);
  

• Método 2: nome do pacote. Nome da classe salto

  Intent intent = new Intent();
  intent.setClassName(MainActivity.this, "com.zjgsu.activitydemo.SecondActivity");
  startActivity(intent);
  

• Método 3: salto ComponentName

  Intent intent = new Intent();
  intent.setComponent(new ComponentName(MainActivity.this, SecondActivity.class));
  startActivity(intent);
  

2.2, início implícito

Defina o filtro de inicialização, por meio da ação especificada $action$或$As\; propriedades\; ACTIOn-eDATA$ , encontrará a Atividade qualificada e a iniciará, há duas maneiras de iniciar a privacidade:

• Método 1: transmitir actionName

  Intent intent = new Intent("abcd.SecondActivity");
  startActivity(intent);
  

• Método 2: definir ação

  Intent intent = new Intent();
  intent.setAction("abcd.SecondActivity");
  startActivity(intent);
  

Nota: Se uma atividade definida por você deve ser iniciada implicitamente, android.intent.category.DEFAULT deve ser adicionado ao AndroidManifest.xml, caso contrário, não funcionará.

 <activity android:name=".SecondActivity">
     <intent-filter>
         <action android:name="abcd.SecondActivity"/>
         <category android:name="android.intent.category.DEFAULT"/>
     </intent-filter>
 </activity>

2.2.1. O que acontece se o actionName de duas atividades for o mesmo quando iniciado implicitamente?

Conforme mostrado abaixo, eu criei duas atividades, então eu defini o actionName dessas duas atividades como sendo o mesmo, e então eu inicio a atividade implicitamente, o que vai acontecer?

<activity android:name=".SecondActivity"
   android:label="第二个界面">
    <intent-filter>
        <action android:name="abcd.SecondActivity" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

<activity android:name=".ThirdActivity"
    android:label="第三个界面">
    <intent-filter>
        <action android:name="abcd.SecondActivity" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

O efeito de execução é o seguinte:



podemos ver na animação gif acima, neste caso, o Android nos deixará escolher a atividade a ser executada. Ou seja, quando houver várias Ações que correspondem às condições correspondidas implicitamente, uma caixa de seleção aparecerá para o usuário escolher.

Três, o ciclo de vida da atividade

Vamos pegar o seguinte diagrama do ciclo de vida da atividade como exemplo:

Quando uma atividade começa, ela chama onCreate () -> onStart () -> onResume () -> onPause () -> onStop () -> onDestroy () por sua vez. Quando onResume () é executado, a Activity torna-se operacional.

3.1, a sequência de chamada de um único ciclo de vida de atividade

• onCreate () é chamado quando a atividade é criada
• onStart () é chamado quando a interface Activity se torna visível para o usuário
• onResume () é chamado quando a interface Activity obtém o foco (o botão da interface pode ser clicado, a caixa de texto pode ser inserida, etc.)
• onPause () é chamado quando a interface de atividade perde o foco (os botões da interface não podem ser clicados, as caixas de texto não podem ser inseridas, etc.)
• onStop () é chamado quando a interface de atividade se torna invisível para o usuário
• onDestroy () é chamado quando a atividade é destruída
• onRestart () é chamado quando a atividade começa novamente

3.2, sequência de chamadas do ciclo de vida de várias atividades

O ciclo de vida de várias atividades é mostrado na figura a seguir:

O fluxo de operação da figura acima: abra a atividade A, clique no botão para iniciar a atividade B e clique no botão de retorno na atividade B. A captura de tela do código em execução é a seguinte:

Quarto, o modo de inicialização da atividade

O modo de inicialização da Activity determina se a instância recém-produzida da Activity reutiliza a instância existente da Activity e se compartilha uma Task com outras instâncias da Activity. Tarefa é um objeto com uma estrutura de pilha. Uma Tarefa pode gerenciar várias Atividades, iniciar um aplicativo e criar uma Tarefa correspondente.

4.1. Quatro modos de inicialização

1. O modo de inicialização padrão
   padrão, cada vez que a Activity é ativada (startActivity), uma instância da Activity é criada e colocada na pilha de tarefas;
2. Cada vez que singleTop
   ativa uma Activity, ele determina se a instância Activity está no topo da pilha. Se estiver, não precisa ser criada. Caso contrário, é necessário criar uma instância Activity;
3. SingleTask
   Se a Activity a ser ativada já existe na pilha de tarefas, você não precisa criá-la. Você só precisa retirar as instâncias de Activity acima desta Activity da pilha. Neste momento, a Activity alcançará o topo da pilha. Se ela não existir, crie a Activity Instância
4. Há apenas uma instância de singleInstance
   e esta instância é executada independentemente em uma Tarefa, esta Tarefa tem apenas esta instância e nenhuma outra instância de Activity é permitida.

4.2, demonstração de código de quatro modos iniciais

4.2.1 、 padrão

Vamos dar uma olhada no efeito primeiro:


você pode ver que em SecondActivity, inicie SecondActivity novamente e o método start no modo padrão criará a instância SecondActivity novamente. Faz com que a pilha de tarefas contenha duas instâncias de SecondActivity, então clicamos no botão de retorno para retornar à SecondActivity anterior e pressionamos o botão de retorno novamente para retornar a MainActivity.

O código principal é o seguinte:

// 启动模式是 standard，不填默认就是 standard
<activity android:name=".SecondActivity"
	android:launchMode="standard"/>

// SecondActivity
public class SecondActivity extends AppCompatActivity {
    
    

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        findViewById(R.id.btn_start_self).setOnClickListener(new View.OnClickListener() {
    
    
            @Override
            public void onClick(View v) {
    
    
                startActivity(new Intent(SecondActivity.this, SecondActivity.class));
            }
        });
    }
}

4.2.2 、 singleTop

Ainda usamos o exemplo acima para demonstrar, basta alterar o modo de inicialização do SecondActivity para singleTop, vamos ver o efeito:


você pode ver que se você iniciar-se novamente no SecondActivity neste momento, a instância do SecondActivity não será criada, deveria ser neste momento SecondActivity Já está no topo da pilha, e o modo de inicialização singleTop irá determinar se a instância Activity está no topo da pilha, se estiver, não precisa ser criada, caso contrário, a instância Activity é criada.

O código principal é o seguinte:

<activity android:name=".SecondActivity"
	android:launchMode="singleTop"/>

Pergunta 1 : Se criarmos uma ThirdActivity neste momento, iniciaremos SecondActivity em MainActivity, depois iniciarmos ThirdActivity em SecondActivity e, em seguida, iniciarmos SecondActivity em ThirdActivity, qual é a ordem das instâncias de Activity na pilha de tarefas neste momento?

Resposta : A sequência ascendente da instância da Activity na pilha de tarefas é MainActivity–> SecondActivity–> ThirdActivity–> SecondActivity.

4.2.3 、 singleTask

Usamos o exemplo da pergunta acima para demonstrar, apenas altere o modo de inicialização de SecondActivity para singleTask, vamos ver o efeito:


Neste momento, a ordem das instâncias de Activity bottom-up na pilha de tarefas é MainActivity–> SecondActivity. Por causa do modo de inicialização SingleTask, se houver instâncias de Activity na pilha, todas as instâncias de Activity acima da Activity serão retiradas da pilha.

O código principal é o seguinte:

<activity android:name=".SecondActivity"
	android:launchMode="singleTask"/>

4.2.4 、 singleInstance

O modo de inicialização singleInstance é um pouco semelhante ao modo de inicialização singleTask. Ambos garantem que haja apenas uma instância da mesma Activity na pilha de tarefas, mas singleInstance criará uma nova Task. Para demonstrar singleInstance, precisamos imprimir o ID da pilha onde cada Activity está localizada. O exemplo é igual ao anterior, exceto que o modo de inicialização é alterado para singleInstance.

O log de impressão é o seguinte:

Vemos que o TaskId da pilha de tarefas onde SecondActivity está localizado é 592 e o TaskId da pilha de tarefas onde MainActivity e ThirdActivity estão localizados é 591. Isso significa que SecondActivity é executado em uma pilha de tarefas independente e há apenas uma instância de Activity de SecondActivity nesta pilha de tarefas. O método de impressão de TaskId é o seguinte:

Log.e("activityDemo2TAG", "ThirdActivity所在的task的id为：" + getTaskId());

Quinto, use IntentFlag para definir o método de inicialização de Activity

Antes de explicar esse ponto de conhecimento, vamos dar uma olhada nos dois conceitos de Task e taskAffinity.

5.1, Conceitos básicos de tarefas

• Task é um contêiner com uma estrutura de pilha, que pode colocar várias instâncias de Activity;
• Inicie um aplicativo, o sistema criará uma Tarefa para colocar a Atividade raiz;
• Quando uma atividade inicia outra atividade, as duas atividades são colocadas na mesma Tarefa por padrão. A última é colocada na pilha de Tarefas onde a primeira está localizada. Quando o usuário pressiona o botão de retorno, a última é ejetada da Tarefa, a primeira Ele é exibido no topo da pilha novamente.

5.2 Conceitos básicos de taskAffinity

• Define a tarefa que a instância da atividade deseja inserir;
• Se uma Activity não exibe a propriedade taskAffinity da Activity, então essa propriedade é igual a taskAffinity especificada pelo Application.Se o Application não especifica, então o valor de taskAffinity é igual ao nome do pacote.

5.3. Valores comumente usados ​​de IntentFlag

Existem muitos tipos de IntentFlag, selecionaremos apenas alguns dos mais usados ​​para explicar.

5.3.1 、 FLAG_ACTIVITY_NEW_TASK

O sistema encontrará ou criará uma nova tarefa para colocar a atividade de destino. Ao pesquisar, ela corresponderá de acordo com a propriedade taskAffinity da atividade de destino. Se a taskAffinity de uma tarefa for considerada a mesma, o destino será pressionado nesta tarefa. Se a pesquisa falhar, então Crie uma nova Tarefa e defina o valor taskAffinity da Tarefa para taskAffinity da Atividade de destino e coloque a Atividade de destino nesta Tarefa.

5.3.1.1, demonstração de código

Método de configuração de IntentFlag:

Intent intent = new Intent(MainActivity.this, SecondActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

$DiYiZhongsituaçãosituação$ : FLAG_ACTIVITY_NEW_TASK maneira de iniciar SecondActivity, mas SecondActivity não adiciona a propriedade taskAffinity, olhamos os resultados:

você pode ver, emboraFLAG_ACTIVITY_NEW_TASKinicie, mas a Atividade de Tarefa onde dois ou o mesmo, que é o motivo ? Issoocorreporquese uma Activity não exibir a propriedade taskAffinity da Activity, então essa propriedade é igual a taskAffinity especificada pelo Application.Se o Application não especificar nenhuma delas, o valor de taskAffinity é igual ao nome do pacote. Ou seja, neste momento, os valores dos dois valores taskAffinity de SecondActivity e MainActivity são nomes de pacotes, então SecondActivity definitivamente será colocado na pilha onde MainActivity está localizado.

$Situação\; decaso\; daprimeiraespéciedicarboxílica$ : De uma maneira FLAG_ACTIVITY_NEW_TASK inicia SecondActivity, e SecondActivity forneceu as propriedades taskAffinity:

<activity android:name=".SecondActivity" 
	android:taskAffinity="flag.newIntent.test"/>

Vamos dar uma olhada no efeito:

Você pode ver que SecondActivity e MainActivity não estão mais na mesma pilha neste momento.

5.3.2 、 FLAG_ACTIVITY_SINGLE_TOP

O singleTop nos mesmos quatro modos de inicialização não será demonstrado aqui.

5.3.3 、 FLAG_ACTIVITY_CLEAR_TOP

A mesma tarefa única nos quatro modos de inicialização não é demonstrada aqui.

5.3.4 、 FLAG_ACTIVITY_REORDER_TO_FRONT

Este modo de inicialização significa que se uma instância de Activity já existir na pilha, ela será colocada no topo da pilha, uma nova Activity não será iniciada e a instância de Activity acima dela não será excluída.

5.3.4.1, demonstração de código

Vejamos primeiro o efeito:


iniciamos SecondActivity em MainActivity, depois iniciamos ThirdActivity em SecondActivity e, em seguida, iniciamos SecondActivity em ThirdActivity por meio de FLAG_ACTIVITY_REORDER_TO_FRONT. Neste momento, como já existe uma instância de SecondActivity na pilha, usaremos essa instância. No topo da pilha e não destruirá todas as instâncias em SecondActivity, então a ordem das instâncias de Activity da parte inferior da pilha neste momento é MainActivity -> ThirdActivity -> SecondActivity.

Seis, resumo

Este artigo fala principalmente sobre os cinco métodos de inicialização de Activity, incluindo três inicializações de exibição e duas inicializações implícitas. Também fala sobre o ciclo de vida de atividade única e multi-Activity, bem como definir o modo de inicialização de Activity por meio de lunchMode em AndroidManifest e por meio de Intent O método .setFlag () define o modo de inicialização da Activity.

No próximo artigo, explicaremos como usar Intent para passar parâmetros , usar Bundle para passar dados , passar dados complexos e iniciar a atividade do sistema .

Para obter detalhes, consulte a análise de atividade dos quatro componentes principais do Android (abaixo)