Atividade (ciclo de vida, início...) do tutorial de primeiros passos do Android

Uma atividade é um componente do aplicativo que fornece uma tela com a qual o usuário interage para realizar ações como fazer uma ligação, tirar uma foto, enviar um e-mail ou visualizar um mapa. Cada atividade recebe uma janela para desenhar sua interface de usuário. Uma janela geralmente preenche a tela, mas pode ser menor que a tela e flutuar sobre outras janelas.

Atividade

1. O uso da atividade

Nosso novo projeto tem uma atividade básica.

No novo projeto, você precisa prestar atenção em 3 arquivos.

• MainActivity.java está em src/main/java, no diretório de nome do pacote correspondente.
• Activity_main.xml está em res/layout.
• AndroidManifest.xml está em src/main. Isso é chamado de "arquivo de manifesto".

Esses 3 arquivos são distribuídos em locais diferentes. Simplificando, os arquivos java podem controlar a lógica da interface. O arquivo de layout (referindo-se a Activity_main.xml aqui ) predefiniu como a IU é posicionada. O arquivo de manifesto informa ao sistema quais componentes meu aplicativo possui e quais permissões solicitei.

2. layout - layout da interface

No layout recém-criado, geralmente dará um por padrão ConstraintLayout. Por exemplo atividade_main.xml .

atividade_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <!-- 省略默认的TextView -->

</androidx.constraintlayout.widget.ConstraintLayout>

Para maior comodidade de uso aqui, substituímos por LinearLayout.Alguns amigos vão perguntar, estamos em 2021, por que não usar ConstraintLayout diretamente?

Não execute nenhuma função agora, use LinearLayout primeiro, apenas por conveniência. Depois de mudar para LinearLayout, o arquivo de layout fica assim.

Activity_main.xml após mudar para LinearLayout

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <!-- 省略默认的TextView -->

</LinearLayout>

Como você pode ver, o início e o fim do rótulo são substituídos LinearLayout. Outros locais não serão modificados por enquanto.

como é poderoso e muito conveniente. Podemos usar o mouse para selecionar o início do rótulo androidx...Layoute, em seguida, inserir diretamente LinearLayoutas primeiras letras do teclado.

como uma caixa de seleção aparecerá automaticamente, clique duas vezes para selecionar LinearLayoutou pressione Enter para selecionar e o rótulo será substituído.

3. Java – Interface de Controle

O design do arquivo de layout é o layout inicial da interface. Ele determina quais componentes da UI são colocados na interface inicial e como os componentes são organizados.

Aqui estamos falando de “interface inicial” ou “layout inicial”. Ou seja, podemos controlar os elementos da UI na interface.

Observe primeiro o MainActivity.java padrão . No onCreatemétodo, R.layout.activity_mainrefere-se a Activity_main.xml .

Agora há um TextView no layout, que pode ser usado para exibir texto. Queremos MainActivitycontrolar isso, como fazer?

Agora altere este TextView. Exclua os atributos usados ​​pelo ConstraintLayout original.

Dê uma identificação. Este ID deve ser exclusivo neste arquivo de layout. Atribua a ele um id chamado tv1, como abaixo.

<TextView
    android:id="@+id/tv1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello World!" />

Agora que o TextView possui um ID, podemos encontrá-lo na atividade. O método é usado findViewById.

TextView tv1 = findViewById(R.id.tv1);

Agora temos o objeto TextView na interface. Está pronto para ser manipulado. Como alterar o texto exibido.

TextView tv1 = findViewById(R.id.tv1); // 拿到textView的对象
tv1.setText("Today is a good day.");   // 改变文字

4. AndroidManifest.xml – arquivo de manifesto

Também pode ser chamado de "arquivo de manifesto", abreviadamente. O arquivo de manifesto é muito importante, pois informa ao sistema quais atividades nosso aplicativo possui, quais permissões são utilizadas e assim por diante.

Caso queira criar uma nova atividade, é necessário cadastrá-la no manifesto.

AndroidManifest.xml

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

A partir deste arquivo de manifesto padrão, podemos saber que a atividade pertence ao aplicativo. aplicação é a nossa aplicação.

Vários elementos também são especificados na tag do aplicativo, como ícone, nome, tema do aplicativo e assim por diante.

MainActivity é a primeira atividade iniciada pelo aplicativo. Você pode observar que ele define as propriedades da ação e da categoria.

• android.intent.action.MAINDetermina qual atividade o aplicativo inicia primeiro.
• android.intent.category.LAUNCHERIndica que o ícone do aplicativo pode ser visto na “área de trabalho” do telefone.

Essas duas tags são definidas, o que determina que esta atividade seja a primeira interface a ser iniciada quando o usuário clicar no ícone da aplicação.

A atividade de resumo é um dos componentes importantes do aplicativo. Conteúdo complexo precisa ser transportado por atividade.

Depois disso, controlaremos vários componentes da UI na atividade, lidaremos com as operações do usuário, solicitaremos permissões e assim por diante. Entenda também o ciclo de vida da atividade, método de início e método de salto.

---

Ciclo de vida da atividade

Diagrama do ciclo de vida

1. Mudanças no ciclo de vida

Execute algumas operações comuns e registre para ver as mudanças no ciclo de vida. Modelo de teste: RedMi.

iniciar e sair

onCreate
onStart
onResume
onWindowFocusChanged: hasFocus: true

onWindowFocusChanged: hasFocus: false
onPause
onStop
onDestroy

Pressione o botão home após a inicialização

Act1: onCreate
Act1: onStart
Act1: onResume
Act1: onWindowFocusChanged: hasFocus: true

// 按home键
Act1: onWindowFocusChanged: hasFocus: false
Act1: onPause
Act1: onStop

// 再回来
Act1: onRestart
Act1: onStart
Act1: onResume
Act1: onWindowFocusChanged: hasFocus: true

// 按返回键退出act
Act1: onWindowFocusChanged: hasFocus: false
Act1: onPause
Act1: onStop
Act1: onDestroy

Gire o ciclo de vida da atividade do telefone móvel ao alternar entre telas horizontais e verticais.

[Life]: onCreate
[Life]: onStart
[Life]: onResume
[Life]: onWindowFocusChanged: hasFocus: true

// 横屏
[Life]: onPause
[Life]: onStop
[Life]: onDestroy
[Life]: onCreate
[Life]: onStart
[Life]: onResume
[Life]: onWindowFocusChanged: hasFocus: true

// 竖屏
[Life]: onPause
[Life]: onStop
[Life]: onDestroy
[Life]: onCreate
[Life]: onStart
[Life]: onResume
[Life]: onWindowFocusChanged: hasFocus: true

// 返回
[Life]: onWindowFocusChanged: hasFocus: false
[Life]: onPause
[Life]: onStop
[Life]: onDestroy

Mudanças no ciclo de vida de alternância Tomemos como exemplo o início de duas atividades.

Act1: onCreate
Act1: onStart
Act1: onResume
Act1: onWindowFocusChanged: hasFocus: true
Act1: onPause
Act1: onWindowFocusChanged: hasFocus: false
Act2: onCreate
Act2: onStart
Act2: onResume
Act2: onWindowFocusChanged: hasFocus: true
Act1: onStop
Act2: onWindowFocusChanged: hasFocus: false
Act2: onPause
Act1: onRestart
Act1: onStart
Act1: onResume
Act1: onWindowFocusChanged: hasFocus: true
Act2: onStop
Act2: onDestroy
Act1: onWindowFocusChanged: hasFocus: false
Act1: onPause
Act1: onStop
Act1: onDestroy

Pop up AlertDialog Clique no botão para abrir um AlertDialog. Observe a chamada de descoberta onWindowFocusChanged.

onWindowFocusChanged: hasFocus: false
onWindowFocusChanged: hasFocus: true

DialogFragment também pode ser usado para teste aqui.

recrear chama o método recreate()

[Life]: onCreate
[Life]: onStart
[Life]: onResume
[Life]: onWindowFocusChanged: hasFocus: true
[Life]: click [recreate]
[Life]: onPause
[Life]: onStop
[Life]: onDestroy
[Life]: onCreate
[Life]: onStart
[Life]: onResume

Como você pode ver, recreate()não há retorno de chamada após chamar o método onWindowFocusChanged.

2. A diferença entre onCreate e onStart

A diferença de estado de atividade

• onCreateDisparado quando o sistema cria uma atividade pela primeira vez. A atividade entrará no estado criado após a criação .
• O sistema chama esse retorno de chamada quando a atividade entra no estado "iniciado". onStart()Chame para tornar a Atividade visível para o usuário enquanto o aplicativo prepara a Atividade para chegar ao primeiro plano e dar suporte à interação.

onStart()O método é concluído muito rapidamente e, assim como acontece com o estado “Criado”, a Atividade não permanece no estado “Iniciado” para sempre. Assim que esse retorno de chamada terminar, a atividade entrará no estado retomado e o sistema chamará onResume()o método.

3. A diferença entre onPause e onStop

onPause()A execução é muito simples e não leva necessariamente tempo suficiente para realizar a operação de salvamento. Portanto, você não deve usar onPause()para salvar dados de aplicativos ou usuários, fazer chamadas de rede ou realizar transações de banco de dados . Porque esse trabalho pode não ser concluído até que o método seja concluído.

entrou no estado parado, então o retorno de chamada será chamado onStop(). Isto pode acontecer, por exemplo, se uma atividade recém-iniciada cobrir toda a tela.

No onStop()método, a aplicação deve liberar ou ajustar recursos que não são utilizados quando a aplicação não está visível para o usuário. Por exemplo, um aplicativo pode pausar uma animação ou mudar de atualizações de localização refinadas para atualizações de localização refinadas. Usar onStop()em vez de onPause()garante que o trabalho relacionado à UI continue mesmo quando o usuário estiver visualizando sua atividade no modo de múltiplas janelas. Você também deve usar onStop()para executar operações de desligamento com uso relativamente intensivo de CPU.

---

A atividade começa, começa com parâmetros

Compreendemos aproximadamente que Activity é um componente de aplicativo que pode fornecer uma interface aos usuários. E como adicionar atividade. Em um aplicativo, geralmente existem várias interfaces. Supondo que cada interface corresponda a uma atividade, como saltar entre diferentes interfaces?

1. Intenção

Normalmente o salto entre as atividades é inseparável da classe Intent. Intenção, traduzida literalmente como "intenção". Envolvemos as informações em um objeto de intenção e o executamos. Por exemplo, inicie RelativeLayoutGuideActesta atividade.

startActivity(new Intent(getApplicationContext(), RelativeLayoutGuideAct.class));

Um método muito comum é usado aqui startActivity (Intent intent). startActivityPertence à classe Context e Activity é uma subclasse de Context.

java.lang.Object
android.content.Context
android.content.ContextWrapper
android.view.ContextThemeWrapper
android.app.Activity

Agora sabemos que iniciar uma atividade requer um Intent para chamar startActivityum método.

2. Salte com parâmetros

Ao pular para a próxima página, podemos querer levar algumas informações para a próxima interface. Como carregar algum texto, números e assim por diante. ou um objeto. Podemos fornecer essas informações ao Intent e passá-las para a próxima atividade. Obtenha a Intenção que passamos na próxima atividade.

Carregar tipos primitivos e String

Vejamos diretamente o método de intenção.

Intent intent = new Intent(getApplicationContext(), SendParamsDemo.class);
intent.putExtra(SendParamsDemo.K_INT, 100);
intent.putExtra(SendParamsDemo.K_BOOL, true);
intent.putExtra(SendParamsDemo.K_STR, "Input string");
startActivity(intent);

O método intent putExtrapode passar parâmetros. Ele aceita uma String como chave e, em seguida, parâmetros específicos. No exemplo, saltamos para SendParamsDemo.

public class SendParamsDemo extends AbsActivity {
    
    

    public static final String K_INT = "k_int";
    public static final String K_BOOL = "k_bool";
    public static final String K_STR = "k_str";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        gotInput();
    }

    private void gotInput() {
    
    
        Intent intent = getIntent();
        if (intent != null) {
    
    
            int i = intent.getIntExtra(K_INT, -1);
            boolean b = intent.getBooleanExtra(K_BOOL, false);
            String str = intent.getStringExtra(K_STR);
            Log.d(TAG, "gotInput: i:" + i + ", b: " + b + ", str: " + str);
        } else {
    
    
            Log.d(TAG, "gotInput: input null.");
        }
    }
}
// log:
// com.rustfisher.tutorial2020 D/rustAppSendParamsDemo: gotInput: i:100, b: true, str: Input string

Nesta atividade recebemos os parâmetros recebidos.

Observando putExtrao método de intenção, descobrimos que ele suporta a passagem de vários tipos de parâmetros.

int, byte, char, float, double, long, boolean, string, CharSequence ou seu array. Você também pode passar objetos Parcelable, Serializable ou matrizes de objetos.

Passe o objeto Serializable

Além dos tipos primitivos e String, os objetos podem ser transferidos? A resposta é sim. A intenção pode carregar Serializableobjetos. SerializableÉ uma interface em si. Depois que um objeto personalizado implementa essa interface, ele pode ser transportado por Intent. Por exemplo, vamos transformar a classe DataTest para que ela implemente Serializablea interface.

public class DataTest implements Serializable {
    
     // 实现接口

Em seguida, envie o objeto para a intenção e inicie a atividade.

Intent intent = new Intent(getApplicationContext(), RecyclerViewDemo2Act.class);
DataTest out = new DataTest("input time", 233, 666, 999);
Log.d(TAG, "startInputData: sending object: " + out);
intent.putExtra(RecyclerViewDemo2Act.K_INPUT_DATA, out);
startActivity(intent);

A atividade iniciada aceita a intenção recebida e recupera o objeto.

Intent intent = getIntent();
if (intent != null) {
    
    
    DataTest d = (DataTest) intent.getSerializableExtra(K_INPUT_DATA);
    // 取出了对象，拿去显示
}

SerializableUma interface não contém nenhum método. As classes que implementam esta interface serão serializadas automaticamente pelo sistema.

Imprimimos os objetos enviados e recebidos.

startInputData: sending object: com.rustfisher.tutorial2020.recycler.data.DataTest@fb43df5
getInputData: input data object: com.rustfisher.tutorial2020.recycler.data.DataTest@a588b5c

Pode-se descobrir que esses dois objetos não são a mesma referência. Mas o seu “conteúdo” é o mesmo. Os objetos passam pelo processo de serialização e desserialização.

É importante notar que o tamanho do objeto que uma Intent pode carregar não é ilimitado. No desenvolvimento real, os desenvolvedores precisam estimar sozinhos o tamanho dos dados transmitidos.

Transferir um objeto Parcelable é semelhante a transferir um objeto Serializable, usando as mesmas operações de depósito e recuperação.

---

Perguntas da entrevista relacionadas às atividades

1. Fale sobre a pilha de retorno

Primeiro, entenda que o Android usa Task para gerenciar atividades. Uma Task é uma coleção de atividades armazenadas na pilha. Essa pilha é chamada de pilha de retorno. Cada vez que uma nova atividade é iniciada, ela será colocada no topo da pilha. Quando clicamos A atividade que está no topo da pilha ao voltar ou chamar a função final da atividade será retirada da pilha e a atividade anterior que foi colocada na pilha irá para o topo da pilha. O sistema sempre exibe a atividade no topo da pilha.

2. Fale sobre o ciclo de vida da Atividade?

• Método onCreate(): é chamado quando a atividade é criada pela primeira vez e geralmente executa operações de inicialização, como carregamento de layout (setContentView) e eventos de vinculação (findViewById). Indica que a atividade está sendo criada.
• Método onStart(): É chamado quando a atividade está invisível e visível, indicando que a atividade está iniciando. Neste momento, a atividade está visível, mas não em primeiro plano.
• Método onResume(): Chamado quando a atividade está pronta para interagir com o usuário. Indica que a Atividade ganhou foco e neste momento a Atividade está visível e em primeiro plano.
• Método onPause(): Chamado quando o sistema está pronto para iniciar ou retomar outra atividade. Indica que a atividade está parando. Neste momento, operações como armazenamento de dados e interrupção da animação podem ser realizadas.
• Método onStop(): chamado quando a atividade está completamente invisível. Indica que a atividade está prestes a parar.
• Método onDestory(): chamado antes da atividade ser destruída, indicando que a atividade está prestes a ser destruída, geralmente fazendo trabalho de reciclagem e liberando recursos.
• Método onRestart(): chamado antes que a atividade mude do estado parado para o estado de execução. Indica que a atividade está prestes a ser reiniciada.

3. Fale sobre o tempo de vida da atividade

O ciclo de vida de uma atividade é dividido em três partes:

• vida inteira
• vida útil visível
• Vida útil em primeiro plano

Vida útil completa : tanto o método onCreate() quanto onDestory() estão em vida útil completa. Geralmente, a atividade conclui várias operações de inicialização no método onCreate() e conclui a operação de liberação de memória no método onDestory().

**Vida útil visível: **O método onStart() e o método onStop() são a vida útil visível. A atividade é visível para o usuário, mas não pode interagir com o usuário. Os recursos são carregados no método onStart() e os recursos são liberados no método onStop().

**Vida útil em primeiro plano: **O método onResume e o método onPause são a vida útil em primeiro plano. Durante a vida útil em primeiro plano, a atividade está em execução e pode interagir com o usuário.

4. Quais operações podem ser realizadas quando a Activity está em onPasue()?

• O usuário retorna à Activity, chama o método onResume() e executa novamente
• Quando o usuário abrir outras atividades, o método onStop() será chamado
• A memória do sistema é insuficiente e os aplicativos com permissões mais altas precisam de memória, e a atividade será reciclada pelo sistema
• Se o usuário retornar à atividade onStop() e for exibido em primeiro plano novamente, o sistema chamará

onRestart() -> onStart() -> onResume() 然后重新running

Quando a Activity termina (chamando o método finish()), o método onDestory() é chamado para liberar todos os recursos ocupados.

Processo de mudança de ciclo de vida

1. Iniciar uma atividade onCreate->onStart->onResume
2. Quando uma Activity abre outra Activity, quais métodos serão chamados de volta? E se ActivityB for completamente transparente? E se uma caixa de diálogo Activity for iniciada? A:onPause->B:onCreate->B:onStart->B:onResume->A:onStop Se ActivityB for completamente transparente ou caixa de diálogo Activity, onStop não será chamado.
3. Após iniciar a nova Activity, retorne para a antiga Activity B:onPause->A:onRestart->A:onStart->A:onResume->B:onStop->B:onDestory
4. Desligue a tela/pressione o botão Home: onPause->onStop
5. Quando uma atividade pressiona a tecla Home para alternar para a área de trabalho e depois retorna à atividade para retornar quais métodos. onPause->onStop->onRestart->onStart->onResume
6. Quais métodos são chamados de volta quando uma Activity pressiona a tecla Voltar para retornar a onPause->onStop->onDestory

Prioridade da atividade

1. Visível e interativo (Atividade em primeiro plano): interagindo com o usuário, com maior prioridade.
2. Visível, mas não interativo (atividade visível, mas não em primeiro plano): por exemplo, se a atividade atual iniciar uma atividade de diálogo, a atividade atual será visível, mas não interativa.
3. Atividade em segundo plano: Atividade que foi suspensa, como onStop, tem a prioridade mais baixa. Quando a memória do sistema for insuficiente, ele encerrará o processo onde a atividade alvo está localizada em ordem de prioridade de baixa para alta.

5. Como a atividade de baixa prioridade pode ser restaurada ao estado anterior à destruição após ser reciclada devido à memória insuficiente?

A atividade com baixa prioridade será reaberta após ser reciclada por falta de memória (durante o processo de alternância entre telas horizontais e verticais), o que fará com que a atividade seja reconstruída.

Quando a atividade é encerrada devido a condições anormais, o sistema chamará onSaveInstanceStateo método para salvar o estado da atividade atual.Este método é chamado antes de onStop e não tem relação de tempo com o método onPause.

Quando a atividade encerrada anormalmente for reconstruída, onRestoreInstanceStateo método será chamado (este método é após onStart) e o onSaveInstanceStateparâmetro do objeto Bundle salvo quando a atividade for destruída será passado para onCreateo método e onRestoreInstanceStateo método ao mesmo tempo. Este método é chamado onStartantes do .

onRestoreInstanceState(Bundle savedInstanceState)Portanto, e pode ser usado onCreate((Bundle savedInstanceState)para julgar Activityse foi reconstruído e retirar os dados para recuperação. No entanto, deve-se notar que ao onCreatebuscar dados de , deve-se primeiro avaliar savedInstanceStatese estão vazios.

Suplemento: A diferença entre onCreate e onRestoreInstanceStateo método para restaurar o estado da Atividade: onRestoreInstanceStateo retorno de chamada do método indica que o objeto do pacote não está vazio e não há necessidade de adicionar um julgamento não vazio, enquanto onCreate precisa de um julgamento não nulo .

6. Fale onSaveInstanceState()comonRestoreIntanceState()

Os dois métodos onSaveInstanceState() não são métodos de ciclo de vida e não são necessariamente acionados. Quando a aplicação encontra uma situação inesperada (como: memória insuficiente, o usuário pressiona diretamente o botão Home) e o sistema destrói uma Activity, onSaveInstanceState() será chamado. Este método é chamado antes de onStop e não tem relação de tempo com onPause. Mas quando o usuário destrói ativamente uma atividade, como pressionar a tecla Enter no aplicativo, onSaveInstanceState() não será chamado. Pois neste caso o comportamento do usuário determina que não há necessidade de salvar o estado da Activity.

onSaveInstanceState()Tempo: (1) O usuário pressiona o botão Home (2) Alterna entre telas horizontais e verticais (3) Pressione o botão liga / desliga (desliga a exibição da tela) (4) A atividade prioritária é interrompida devido à memória insuficiente

onRestoreInstanceState() Quando a atividade destruída pela exceção do sistema é reconstruída, o método onRestoreInstanceState ou onCreate será chamado para restaurar, e o objeto Bundle passado nos métodos onRestoreInstance e Oncreate é salvo por onSaveInstanceState quando é destruído, e onRestoreInstanceState é após onStart .

7. A diferença entre onSaveInstanceState() e onPause()?

onSaveInstanceState()É adequado apenas para salvar algum estado temporário, mas onPause()é adequado para armazenamento persistente de dados.

8. Fale sobre as funções chamadas no processo de alternância entre telas horizontais e verticais

Lembre-se de que a atividade aqui foi destruída. onPause->onSaveInstanceState->onStop->onDestory()->onCreate->onStart->onRestoreInstanceState->onResume

9. Como evitar que a Activity seja destruída e trocada quando as telas horizontal e vertical são trocadas (mudanças de configuração)

Especificando o atributo (configChanges) na atividade do arquivo AndroidManifest:

android：configChanges = “orientation| screensize”

Para evitar a destruição e reconstrução da Activity quando as telas horizontal e vertical são trocadas, mas chame de volta o método onConfigurationChanged()

@Override
 public void onConfigurationChanged(Configuration newConfig) {
    
    
 super.onConfigurationChanged(newConfig);
 }

Aqui está uma explicação de todos os atributos do Android configChanges

“mcc“ 移动国家号码，由三位数字组成，每个国家都有自己独立的MCC，可以识别手机用户所属国家。
“mnc“ 移动网号，在一个国家或者地区中，用于区分手机用户的服务商。
“locale“ 所在地区发生变化。
“touchscreen“ 触摸屏已经改变。（这不应该常发生。）
“keyboard“ 键盘模式发生变化，例如：用户接入外部键盘输入。
“keyboardHidden“ 用户打开手机硬件键盘
“navigation“ 导航型发生了变化。（这不应该常发生。）
“orientation“ 设备旋转，横向显示和竖向显示模式切换。
“fontScale“ 全局字体大小缩放发生改变

10. Conte-me sobre os quatro modos de inicialização do Activity?

1. Modo padrão (modo padrão): modo de inicialização normal, cada vez que a Activity for iniciada, uma instância será criada.
2. modo singletop (modo stack top): Quando uma Activity é iniciada, ela determinará se o topo da pilha de tarefas é a Activity. Se for a Activity, uma instância não será criada e o método onNewIntent (intent) será chamado de volta, caso contrário uma instância será criada
3. Modo Singletask (modo em pilha): Quando uma Atividade é iniciada, enquanto a Atividade estiver na pilha especificada, uma instância não será criada e o método onNewIntent(intent)** será chamado de volta. Se não existir, ele julgará se a pilha especificada não existe, criará uma pilha e enviará a instância da atividade; se a pilha especificada existir, enviará-a diretamente para a pilha.
4. Modo singleInstance (modo de instância única): Neste modo, ao criar uma instância de Activity, uma pilha é criada diretamente e há apenas a instância de Activity na pilha. Depois disso, não importa qual aplicativo inicie a Activity, ela chamará apenas a instância na pilha.

11. Fale sobre a diferença entre singleTop e singleTask e seus cenários de aplicação

O significado do modo singleTop é (consulte a pergunta acima), o significado do modo singleTask é (consulte a pergunta acima)

Então a diferença entre os dois é:

• Modo singleTop: Neste modo, pode haver várias instâncias da mesma Activity na pilha de tarefas, porque apenas determina se a Activity atualmente iniciada está no topo da pilha. A atividade neste modo entrará e iniciará a pilha de tarefas à qual pertence por padrão e não envolverá a conversão da pilha de tarefas. Normalmente usado para evitar a rápida sucessão de cliques e criar várias instâncias de atividade.
• Modo singleTask: Neste modo, haverá apenas uma instância de Activity na pilha de tarefas, porque determinará se a Activity atualmente iniciada está na pilha especificada atualmente. Nesse modo, a Activity pode especificar a pilha de tarefas necessária por meio de taskAffinity, o que pode envolver a conversão da pilha de tarefas, que é frequentemente usada na página inicial ou na página de login. Porque não importa quantas atividades entremos depois de entrar na página inicial, quando retornarmos à página inicial, ainda queremos sair da página inicial e sair diretamente do aplicativo. Neste modo, todas as atividades acima da atividade a ser iniciada na pilha serão retiradas da pilha.

12. Quando chamar onNewIntent()?

Existem duas oportunidades de chamada, nomeadamente iniciar a atividade no modo singleTop e no modo singleTask. Modo singleTop: quando a atividade iniciada estiver no topo da pilha de tarefas, o método onNewIntent será chamado de volta. Modo singleTask: quando a atividade iniciada existir na pilha de tarefas, o método onNewIntent será chamado de volta.

13. Quais são os bits de sinalização do modo de inicialização da atividade?

• FLAG_ACTIVITY_SINGLE_TOP: correspondente ao modo de inicialização singleTop
• FLAG_ACTIVITY_NEW_TASK: corresponde ao modo singleTask

Informações mais completas, desde a entrada baseada em zero até a proficiência em Android, podem ser obtidas gratuitamente digitalizando o código QR! ! !

[Equipe técnica da Tencent produzida] Entrada para proficiência baseada em zero do Android, tutorial de instalação do Android Studio + um conjunto completo de tutoriais básicos do Android

Tutorial de programação Android

Noções básicas da linguagem Java, desde a entrada até a familiaridade

Noções básicas da linguagem Kotlin, desde a entrada até a familiaridade

Pilha de tecnologia Android desde a entrada até a familiaridade

Aprendizado abrangente da família Android Jetpack

Para iniciantes, pode ser difícil instalar o Android Studio. Você pode assistir ao vídeo a seguir e aprender a instalar e executar passo a passo.

Tutorial de instalação do Android Studio

Com o aprendizado da etapa Java, recomenda-se focar no aprendizado por vídeo nesta fase e complementá-lo com livros para verificar omissões. Se você se concentra em livros, pode digitar códigos com base nas explicações dos livros, complementados por vídeos didáticos para verificar omissões. Se você encontrar problemas, você pode ir para o Baidu. Geralmente, muitas pessoas encontrarão problemas ao começar e darão respostas melhores.

É necessário dominar conhecimentos básicos, como usar os quatro componentes principais, como criar um Serviço, como fazer o layout, visualização personalizada simples, animação, comunicação em rede e outras tecnologias comuns.

Um conjunto completo de tutoriais baseados em zero foi preparado para você. Se precisar, você pode adicionar o código QR abaixo para obtê-lo gratuitamente

Um conjunto completo de tutoriais básicos do Android