Aktivitäten sind eine grundlegende Komponente der Android-Entwicklung. Eine Activity kapselt einen Bildschirm, mit dem der Benutzer interagiert. Aktivitäten enthalten typischerweise Komponenten, mit denen der Benutzer interagieren soll. Dies können Schaltflächen, Listen, Texte usw. sein. Die Aktivität hat jedoch ihren eigenen Lebenszyklus, und Sie können die Ereignisse, die von der Aktivität ausgesendet werden, durch Lebenszyklusmethoden abhören.

In diesem Tutorial lernen wir diese Lifecycle-Methoden praktisch kennen, indem wir Code schreiben, der etwas tut, wenn ein solches Ereignis ausgelöst wird.

(a). Eine App erstellen, die die Lebenszyklusmethoden einer Aktivität in Kotlin auflistet

In diesem Beispiel lernen Sie die grundlegende Interaktion mit diesen Methoden. Wir zeigen eine einfache Toastnachricht, wenn ein solches Ereignis ausgelöst wird.

Wir verwenden android studio und kotlin.

Schritt 1: Abhängigkeiten

Für dieses Projekt werden keine Abhängigkeiten benötigt.

Schritt 2: Kotlin-Code

Beginnen Sie mit der Erstellung einer Datei namens "MaiActivity.kt".

MainActivity.kt

Dann fügen Sie Importe hinzu:

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

Erweitern Sie dann die AppCompatActivity:

class MainActivity : AppCompatActivity() {
    //

Die erste Lebenszyklus-Methode, die wir überschreiben, ist die onCreate(). Diese wird ausgelöst, wenn die Aktivität zum ersten Mal erstellt wird. Wir werden hier unser Xml-Layout aufblasen. Der Text wird an unseren Textbuilder angehängt. Dann zeigen wir den Text in einer Textansicht.

    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")
    }

Wir überschreiben dann unser onStart(). Dies wird ausgelöst, wenn die Aktivität gestartet wird und für die Verwendung sichtbar wird:


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

Und so weiter und so fort.

Hier ist der vollständige Code:

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")
    }
}

Schritt 3: Layouts

activity_main.xml

Das Wichtigste an unserem Hauptaktivitätslayout ist, dass wir eine Textansicht haben werden, die die Lebenszyklusmethoden anzeigt, wenn sie ausgelöst werden:

<?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>

Schritt 4: Ausführen

Führen Sie das Projekt aus und Sie erhalten das folgende Ergebnis:

Schritt 5: Herunterladen

Laden Sie den Quellcode [hier]() herunter.

Änderung der Bildschirmkonfiguration

In diesem Teil befassen wir uns mit Android-Lösungen für Konfigurationsänderungen auf dem Android-Gerät.

Hier ein einfacher Hinweis zum Umgang mit Konfigurationsänderungen gemäß der offiziellen android-Dokumentation:

Einige Gerätekonfigurationen können sich während der Laufzeit ändern (z. B. die Bildschirmausrichtung, die Verfügbarkeit der Tastatur und wenn der Benutzer den [Multi-Window-Modus] (https://developer.android.com/guide/topics/ui/multi-window) aktiviert). Wenn eine solche Änderung auftritt, startet Android die laufende Activity neu ( onDestroy() wird aufgerufen, gefolgt von onCreate()). Das Neustartverhalten wurde entwickelt, um Ihre Anwendung bei der Anpassung an neue Konfigurationen zu unterstützen, indem die Anwendung automatisch mit alternativen Ressourcen neu geladen wird, die der neuen Gerätekonfiguration entsprechen.

Um einen Neustart richtig zu behandeln, ist es wichtig, dass Ihre Aktivität ihren vorherigen Zustand wiederherstellt. Sie können eine Kombination aus onSaveInstanceState(), ViewModel Objekten und persistentem Speicher verwenden, um den UI-Status Ihrer Aktivität über Konfigurationsänderungen hinweg zu speichern und wiederherzustellen. Lesen Sie mehr darüber hier.

Wie hört man auf Konfigurationsänderungen in android?

Schritt 1 – Angeben der configChanges-Eigenschaft im android-Manifest

Etwa so:

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

Der Code deklariert eine Aktivität, die sowohl Änderungen der Bildschirmausrichtung als auch Änderungen der Tastaturverfügbarkeit verarbeitet.

  • Der Wert "orientation" verhindert Neustarts, wenn sich die Ausrichtung des Bildschirms ändert.
  • Der Wert "screenSize" verhindert ebenfalls Neustarts, wenn sich die Ausrichtung ändert, allerdings nur für Android 3.2 (API-Level 13) und höher.
  • Der Wert "screenLayout" ist notwendig, um Änderungen zu erkennen, die durch Geräte wie faltbare Telefone und konvertierbare Chromebooks ausgelöst werden können.
  • Der "keyboardHidden"-Wert verhindert Neustarts, wenn sich die Verfügbarkeit der Tastatur ändert.

Schritt 2: Überschreiben Sie die Methode onConfigurationChanged.

Etwa so:

@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");
    }
}

Oder Sie können eine Switch-Anweisung verwenden:

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

In 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()
    }
}

Beachten Sie, dass Sie, bevor Sie Ihren Implementierungscode schreiben, super.onConfigurationChanged(newConfig); hinzufügen müssen, da sonst eine Ausnahme ausgelöst werden kann.

Beobachtungen

Die Funktion onConfigurationCalled() kann nicht aufgerufen werden, wenn Sie

1.Layout in XML auf Querformat setzen

    android:screenOrientation="landscape"

2. SetRequestedOrientation manuell aufruft

    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

**3. Sie haben sowohl android:screenOrientation als auch android:configChanges angegeben.

Beispiel – Wie man Änderungen der Bildschirmausrichtung handhabt

Lassen Sie uns ein einfaches Beispiel erstellen, das Konfigurationsänderungen in einer Android-Aktivität beobachtet und eine Toast-Meldung anzeigt, je nachdem, ob der Bildschirm im Hoch- oder Querformat gedreht ist.

Schritt 1- Layout erstellen

Fügen Sie den folgenden Code in Ihr xml-Layout ein:

<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>

Schritt 2: MainActivity.java

Fügen Sie dann den folgenden Code in Ihre Hauptaktivität ein:

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;
    }

}

That’s it.