As atividades são fundamentais e componentes do desenvolvimento dos andróides. Uma atividade encapsula uma tela com a qual o usuário interage. As atividades normalmente conterão componentes com os quais o usuário deverá interagir. Estes podem ser botões, listas, textos de edição, etc. A atividade, entretanto, tem seu próprio ciclo de vida e você pode ouvir os eventos emitidos pela atividade através dos métodos do ciclo de vida.

Neste tutorial aprendemos estes métodos de ciclo de vida praticamente escrevendo código que faz algo quando um evento deste tipo é levantado.

(a). Criar um aplicativo que lista os métodos do ciclo de vida da atividade em Kotlin

Neste exemplo, você aprenderá a interação básica com estes métodos. Mostramos uma simples mensagem de brinde quando um evento deste tipo é levantado.

Usamos androide studio e kotlin

Etapa 1: Dependências

Não são necessárias dependências para este projeto.

Passo 2: Código Kotlin

Comece criando um arquivo chamado MaiActivity.kt.

MainActivity.kt**.

Em seguida, adicionar as importações:

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.StringBuilder

Em seguida, estender a AppCompatActivity:

class MainActivity : AppCompatActivity() {
    //

O primeiro método de ciclo de vida que anulamos é o onCreate(). Isto é levantado quando a atividade é criada pela primeira vez. Insuflaremos nosso layout xml aqui. Anexe algum texto ao nosso textbuilder. Em seguida, mostrar o texto em uma visualização de texto.

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        sb.append("\n onCreate Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onCreate Called")
    }

Em seguida, anulamos nosso onStart(). Isto é levantado quando a atividade é iniciada e se torna visível para uso:


    override fun onStart() {
        super.onStart()
        sb.append("\n onStart Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onStart Called")
    }

E assim por diante.

Aqui está o código completo:

package info.camposha.activitylifecycle

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.StringBuilder

class MainActivity : AppCompatActivity() {
    val sb: StringBuilder = StringBuilder()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        sb.append("\n onCreate Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onCreate Called")
    }

    override fun onStart() {
        super.onStart()
        sb.append("\n onStart Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onStart Called")
    }

    override fun onResume() {
        super.onResume()
        sb.append("\n onResume Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onResume Called")
    }

    override fun onPause() {
        super.onPause()
        sb.append("\n onPause Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onPause Called")
    }

    override fun onStop() {
        super.onStop()
        sb.append("\n onStop Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onStop Called")
    }

    override fun onDestroy() {
        super.onDestroy()
        sb.append("\n onDestroy Called")
        tv.text = sb.toString()
        Log.d("ACTIVITY_LIFECYCLE", "onDestroy Called")
    }
}

Passo 3: Layouts

**activity_main.xml***

O principal sobre nosso layout de atividade principal é que teremos uma visão de texto que mostrará os métodos do ciclo de vida à medida que eles forem sendo levantados:

<?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
        android:id="@+id/tv"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text=""
        android:textAppearance="@style/TextAppearance.AppCompat.Medium"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Passo 4: Correr

Executar o projeto.

Mudança de configuração da tela

Nesta peça, analisamos soluções andróides relacionadas a mudanças de configuração no dispositivo andróide.

Aqui está uma nota simples sobre como lidar com as mudanças de configuração de acordo com a documentação oficial do androide:

Algumas configurações do dispositivo podem mudar durante a execução (como orientação da tela, disponibilidade do teclado e quando o usuário habilita [modo multijanela] (https://developer.android.com/guide/topics/ui/multi-window)). Quando tal mudança ocorre, o Android reinicia a execução Activity ( onDestroy() é chamado, seguido por onCreate()). O comportamento de reinício é projetado para ajudar sua aplicação a se adaptar a novas configurações, recarregando automaticamente sua aplicação com recursos alternativos que combinam com a nova configuração do dispositivo.

Para lidar adequadamente com um reinício, é importante que sua atividade restaure seu estado anterior. Você pode utilizar uma combinação de objetos onSaveInstanceState(), ViewModel, e armazenamento persistente para salvar e restaurar o estado da IU de sua atividade durante as mudanças de configuração. Leia mais sobre isso aqui.

Como você ouve as mudanças de configuração no andróide?

Passo 1 – Especifique a propriedade configChanges no manifesto do andróide

Assim:

<activity android:name=".MyActivity"
          android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
          android:label="@string/app_name">

O código declara uma atividade que trata tanto de mudanças de orientação da tela quanto de disponibilidade do teclado.

  • O valor "orientação" impede que se reinicie quando a orientação da tela muda.
  • O valor "screenSize" também impede que se reinicie quando a orientação muda, mas somente para o Android 3.2 (nível API 13) e acima.
  • O valor "screenLayout" é necessário para detectar mudanças que podem ser acionadas por dispositivos como telefones dobráveis e Chromebooks conversíveis.
  • O valor "keyboardHidden" impede que se reinicie quando a disponibilidade do teclado muda.

Passo 2: Substituir emConfiguraçãoMétodo modificado

Assim:

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

    int newOrientation = newConfig.orientation;

    if (newOrientation == Configuration.ORIENTATION_LANDSCAPE) {
      // show("Landscape");
    } else if (newOrientation == Configuration.ORIENTATION_PORTRAIT){
    // show("Portrait");
    }
}

Ou você pode usar uma declaração de interruptor:

int orientation=newConfig.orientation;
switch(orientation) {
    case Configuration.ORIENTATION_LANDSCAPE:
        //to do something
        break;
    case Configuration.ORIENTATION_PORTRAIT:
        //to do something
        break;
}

Em Kotlin:

override fun onConfigurationChanged(newConfig: Configuration) {
    super.onConfigurationChanged(newConfig)

    // Checks the orientation of the screen
    if (newConfig.orientation === Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show()
    } else if (newConfig.orientation === Configuration.ORIENTATION_PORTRAIT) {
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show()
    }
}

Note que antes de escrever seu código de implementação você precisa adicionar super.onConfigurationChanged(newConfig); ou então uma exceção poderá ser levantada.

Observações

O onConfigurationCalled() não pode ser chamado se você

**1.definir layout para paisagem em XML***

    android:screenOrientation="landscape"

**2. Conjunto de convitesOrientação solicitada manualmente***

    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

3. Você tem tanto android:screenOrientation como android:configChanges especificados.

Exemplo – Como lidar com mudanças na orientação da tela

Vamos criar um exemplo simples que irá observar mudanças de configuração em uma atividade andróide e mostrar uma mensagem de brinde com base no fato de a tela ser girada retrato ou paisagem.

Passo 1- Criar layout

Adicione o seguinte código em seu layout xml:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />

</RelativeLayout>

Passo 2: MainActivity.java

Em seguida, adicione o seguinte código em sua atividade principal:

package com.example.screenorientation;

import android.os.Bundle;
import android.app.Activity;
import android.content.res.Configuration;
import android.view.Menu;
import android.widget.Toast;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        onConfigurationChanged(new Configuration());
    }
@Override
public void onConfigurationChanged(Configuration newConfig) {
    // TODO Auto-generated method stub
    super.onConfigurationChanged(newConfig);

    if(getResources().getConfiguration().orientation==Configuration.ORIENTATION_PORTRAIT)
    {
        Toast.makeText(getApplicationContext(), "portrait", Toast.LENGTH_SHORT).show();
        System.out.println("portrait");
    }
    else if (getResources().getConfiguration().orientation==Configuration.ORIENTATION_LANDSCAPE) {
         Toast.makeText(getApplicationContext(), "landscape", Toast.LENGTH_SHORT).show();
            System.out.println("landscape");
    }
    else
    {
         Toast.makeText(getApplicationContext(), "none", Toast.LENGTH_SHORT).show();
            System.out.println("none");
    }
}
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

}

É isso aí.