Android
Aktivität

Einführung

Syntax

• void onCreate (Bundle savedInstanceState) // Wird aufgerufen, wenn die Aktivität beginnt.

• void onPostCreate (Bundle savedInstanceState) // Wird aufgerufen, wenn der Aktivitätsstart abgeschlossen ist (nachdem onStart () und onRestoreInstanceState (Bundle) aufgerufen wurden).

• void onStart () // Wird nach onCreate (Bundle) aufgerufen - oder nach onRestart (), wenn die Aktivität angehalten wurde, dem Benutzer jedoch jetzt wieder angezeigt wird.

• void onResume () // Wird nach onRestoreInstanceState (Bundle), onRestart () oder onPause () aufgerufen, damit Ihre Aktivität mit dem Benutzer interagieren kann.

• void onPostResume () // Wird aufgerufen, wenn die Wiederaufnahme der Aktivität abgeschlossen ist (nachdem onResume () aufgerufen wurde).

• void onRestart () // Wird nach onStop () aufgerufen, wenn die aktuelle Aktivität dem Benutzer erneut angezeigt wird (der Benutzer hat wieder zu ihm navigiert).

• void onPause () // Wird als Teil des Aktivitätslebenszyklus aufgerufen, wenn eine Aktivität in den Hintergrund geht, aber (noch) nicht beendet wurde.

• void onStop () // Wird aufgerufen, wenn Sie für den Benutzer nicht mehr sichtbar sind.

• void onDestroy () // Führen Sie eine letzte Bereinigung durch, bevor eine Aktivität zerstört wird.

• void onNewIntent (Intent Intent) // Dies wird für Aktivitäten aufgerufen, bei denen launchMode in ihrem Paket auf "singleTop" gesetzt ist oder wenn ein Client beim Aufruf von startActivity (Intent) das Flag FLAG_ACTIVITY_SINGLE_TOP verwendet hat.

• void onSaveInstanceState (Bundle outState) // Wird aufgerufen, um den Instanzstatus von einer Aktivität abzurufen, bevor er beendet wird, damit der Status in onCreate (Bundle) oder onRestoreInstanceState (Bundle) wiederhergestellt werden kann (das von dieser Methode aufgefüllte Bundle wird an beide übergeben ).

• void onRestoreInstanceState (Bundle savedInstanceState) // Diese Methode wird nach onStart () aufgerufen, wenn die Aktivität aus einem zuvor gespeicherten Status neu initialisiert wird, der hier in SavedInstanceState angegeben ist.

Parameter

Bemerkungen

Schließen Sie eine Aktivität aus dem Back-Stack-Verlauf aus

Es sei die Aktivität B , die geöffnet werden kann und weitere Aktivitäten starten kann. Der Benutzer sollte jedoch nicht darauf stoßen, wenn er in Aufgabenaktivitäten zurück navigiert.

Die einfachste Lösung besteht darin, das Attribut noHistory für dieses <activity> -Tag in AndroidManifest.xml auf true zu AndroidManifest.xml :

<activity
     android:name=".B"
     android:noHistory="true">

Dasselbe Verhalten ist auch vom Code aus möglich, wenn B vor dem Start der nächsten Aktivität finish() aufruft:

finish();
startActivity(new Intent(context, C.class));

Das noHistory Flag wird noHistory mit "Splash Screen" oder Login-Aktivitäten verwendet.

Android Activity LifeCycle erklärt

Angenommen, eine Anwendung mit einer MainActivity, die die nächste Aktivität mit einem Klick auf die Schaltfläche aufrufen kann.

public class MainActivity extends AppCompatActivity {

    private final String LOG_TAG = MainActivity.class.getSimpleName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(LOG_TAG, "calling onCreate from MainActivity");
    }
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "calling onStart from MainActivity");
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "calling onResume  from MainActivity");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "calling onPause  from MainActivity");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "calling onStop  from MainActivity");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "calling onDestroy  from MainActivity");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "calling onRestart  from MainActivity");
    }
    public void toNextActivity(){
        Log.d(LOG_TAG, "calling Next Activity");
        Intent intent = new Intent(this, NextActivity.class);
        startActivity(intent);
    } }

und

public class NextActivity extends AppCompatActivity {
    private final String LOG_TAG = NextActivity.class.getSimpleName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_next);
        Log.d(LOG_TAG, "calling onCreate from Next Activity");
    }
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "calling onStart from Next Activity");
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "calling onResume  from Next Activity");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "calling onPause  from Next Activity");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "calling onStop  from Next Activity");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "calling onDestroy  from Next Activity");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "calling onRestart  from Next Activity");
    } }

Wenn die App zum ersten Mal erstellt wird
D / MainActivity: Aufruf vonCreate from MainActivity
D / MainActivity: Aufruf von MainActivity auf Start
D / MainActivity: Aufruf anAusgabe von MainActivity
werden genannt

Wenn der Bildschirm schläft
08: 11: 03.142 D / MainActivity: Aufruf onPause von MainActivity
08: 11: 03.192 D / MainActivity: Aufruf vonStopp von MainActivity
werden genannt. Und wieder, wenn es aufwacht
08: 11: 55.922 D / MainActivity: Aufruf vonRestart von MainActivity
08: 11: 55.962 D / MainActivity: Aufruf anStarten von MainActivity
08: 11: 55.962 D / MainActivity: Aufruf anAusgabe von MainActivity
werden genannt

Fall 1: Wenn die nächste Aktivität aus der Hauptaktivität aufgerufen wird
D / MainActivity: Nächste Aktivität aufrufen
D / MainActivity: Aufruf anPause von MainActivity
D / NextActivity: Aufruf vonAus der nächsten Aktivität erstellen
D / NextActivity: Aufruf vonStart from Next Activity
D / NextActivity: Aufrufen vonArbeit von nächster Aktivität
D / MainActivity: Aufruf von MainActivity auf onStop

Wenn Sie mit der Zurück-Taste zur nächsten Hauptaktivität zurückkehren
D / NextActivity: Aufruf onPause from Next Activity
D / MainActivity: Aufruf von Neustart von MainActivity
D / MainActivity: Aufruf von MainActivity auf Start
D / MainActivity: Aufruf anAusgabe von MainActivity
D / NextActivity: Aufruf von onStop from Next Activity
D / NextActivity: Aufruf von onDestroy aus Next Activity

Fall2: Wenn die Aktivität teilweise verdeckt ist (Wenn die Übersichtstaste gedrückt wird) oder Wenn die App in den Hintergrund wechselt und eine andere App dies völlig verdeckt
D / MainActivity: Aufruf anPause von MainActivity
D / MainActivity: Aufruf von MainActivity auf onStop
und wenn die App wieder im Vordergrund ist, um Benutzereingaben zu akzeptieren,
D / MainActivity: Aufruf von Neustart von MainActivity
D / MainActivity: Aufruf von MainActivity auf Start
D / MainActivity: Aufruf anAusgabe von MainActivity
werden genannt

Fall3: Wenn eine Aktivität aufgerufen wird, um eine implizite Absicht zu erfüllen, und der Benutzer eine Auswahl getroffen hat. Zum Beispiel, wenn die Share-Taste gedrückt wird und der Benutzer eine App aus der Liste der angezeigten Anwendungen auswählen muss
D / MainActivity: Aufruf anPause von MainActivity

Die Aktivität ist sichtbar, aber jetzt nicht aktiv. Wenn die Auswahl abgeschlossen ist und die App aktiv ist
D / MainActivity: Aufruf anAusgabe von MainActivity
wird genannt

Fall4:
Wenn die App im Hintergrund beendet wird (um Ressourcen für eine andere Vordergrund-App freizugeben ), werden onPause (für Pre-Honeycomb-Gerät) oder onStop (für da Honeycomb-Gerät) das letzte Mal aufgerufen, bevor die App beendet wird.

onCreate und onDestroy werden bei jeder Ausführung der Anwendung einmalig als utmost bezeichnet. OnPause, onStop, onRestart, onStart, onResume werden jedoch oft während des Lebenszyklus aufgerufen.

Aktivitätsstartmodus

Der Startmodus definiert das Verhalten einer neuen oder vorhandenen Aktivität in der Aufgabe.
Es gibt mögliche Startmodi:

• Standard
• singleTop
• singleTask
• Einzelinstanz

Es sollte im Android-Manifest im <activity/> -Element als android:launchMode Attribut definiert werden.

<activity
    android:launchMode=["standard" | "singleTop" | "singleTask" | "singleInstance"] />

Standard:

Standardwert. Wenn dieser Modus festgelegt ist, wird für jede neue Absicht immer eine neue Aktivität erstellt. So ist es möglich, viele Aktivitäten des gleichen Typs zu erhalten. Neue Aktivität wird auf die Aufgabe gesetzt. Es gibt einige Unterschiede bei den verschiedenen Android-Versionen: Wenn die Aktivität von einer anderen Anwendung aus gestartet wird, wird sie bei Androiden <= 4.4 derselben Aufgabe als Starter-Anwendung zugeordnet, aber bei> = 5.0 wird eine neue Aufgabe erstellt.

SingleTop:

Dieser Modus entspricht fast dem standard . Es können viele Instanzen von singleTop-Aktivitäten erstellt werden. Der Unterschied besteht darin, dass onNewIntent() aufgerufen wird, anstatt eine neue Instanz zu erstellen, wenn auf dem aktuellen Stack bereits eine Aktivitätsinstanz vorhanden ist.

SingleTask:

Die Aktivität bei diesem Startmodus kann nur eine Instanz im System haben . Neue Aufgabe für Aktivität wird erstellt, wenn sie nicht existiert. Andernfalls wird die Task mit der Aktivität nach vorne onNewIntent und onNewIntent wird aufgerufen.

Einzelinstanz:

Dieser Modus ähnelt singleTask . Der Unterschied ist die Aufgabe, die eine Aktivität mit singleInstance kann nur diese Aktivität haben und nichts weiter. Wenn die singleInstance Aktivität eine andere Aktivität erstellt, wird eine neue Aufgabe erstellt, um diese Aktivität zu platzieren.

Präsentieren der Benutzeroberfläche mit setContentView

Die Aktivitätsklasse erstellt für Sie ein Fenster, in dem Sie Ihre Benutzeroberfläche mit setContentView .
Es gibt drei setContentView Methoden:

• setContentView(int layoutResID) - setContentView(int layoutResID) den Aktivitätsinhalt einer setContentView(int layoutResID) .
• setContentView(View view) - Setzt den Aktivitätsinhalt auf eine explizite Ansicht.
• setContentView(View view, ViewGroup.LayoutParams params) - setContentView(View view, ViewGroup.LayoutParams params) den Aktivitätsinhalt auf eine explizite Ansicht mit den bereitgestellten Parametern fest.

Wenn setContentView aufgerufen wird, wird diese Ansicht direkt in die Ansichtshierarchie der Aktivität setContentView . Es kann selbst eine komplexe Ansichtshierarchie sein.

Beispiele

Inhalt aus Ressourcendatei setzen:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello" /> 

</FrameLayout>

Legen Sie es als Inhalt in Aktivität fest:

public final class MainActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // The resource will be inflated, 
        // adding all top-level views to the activity.
        setContentView(R.layout.main);
    }
}

Setzen Sie den Inhalt auf eine explizite Ansicht:

public final class MainActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Creating view with container
        final FrameLayout root = new FrameLayout(this);
        final TextView text = new TextView(this);
        text.setText("Hello");
        root.addView(text);

        // Set container as content view
        setContentView(root);
    }
}

Löschen Sie Ihren aktuellen Aktivitätsstapel und starten Sie eine neue Aktivität

Wenn Sie Ihren aktuellen Aktivitätsstapel löschen und eine neue Aktivität starten möchten (z. B. Abmeldung von der App und Starten einer Protokollaktivität), gibt es zwei Ansätze.

1. Ziel (API> = 16)

finishAffinity() von einer Aktivität aus finishAffinity()

2. Ziel (11 <= API <16)

Intent intent = new Intent(this, LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK |Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
finish();

Bewerbung beenden mit Ausnahmen ausschließen

Definieren Sie zunächst eine ExitActivity in der AndroidManifest.xml

<activity
        android:name="com.your_example_app.activities.ExitActivity"
        android:autoRemoveFromRecents="true"
        android:theme="@android:style/Theme.NoDisplay" />

Danach die ExitActivity-Klasse

/**
 * Activity to exit Application without staying in the stack of last opened applications
 */
public class ExitActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (Utils.hasLollipop()) {
            finishAndRemoveTask();
        } else if (Utils.hasJellyBean()) {
            finishAffinity();
        } else {
            finish();
        }
    }

   /**
    * Exit Application and Exclude from Recents
    *
    * @param context Context to use
    */
    public static void exitApplication(ApplicationContext context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
        context.startActivity(intent);
    }
}

Up Navigation für Aktivitäten

Die Navigation in Android erfolgt durch Hinzufügen von android:parentActivityName="" in Manifest.xml zum Activity-Tag. Mit diesem Tag informieren Sie das System grundsätzlich über die übergeordnete Aktivität einer Aktivität.

Wie wird es gemacht?

<uses-permission android:name="android.permission.INTERNET" />

<application
    android:name=".SkillSchoolApplication"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity
        android:name=".ui.activities.SplashActivity"
        android:theme="@style/SplashTheme">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
    <activity android:name=".ui.activities.MainActivity" />
    <activity android:name=".ui.activities.HomeActivity"
     android:parentActivityName=".ui.activities.MainActivity/> // HERE I JUST TOLD THE SYSTEM THAT MainActivity is the parent of HomeActivity
</application>

Wenn ich jetzt auf den Pfeil in der Symbolleiste von HomeActivity klicke, werde ich zur übergeordneten Aktivität zurückkehren.

Java-Code

Hier werde ich den entsprechenden Java-Code schreiben, der für diese Funktionalität erforderlich ist.

public class HomeActivity extends AppCompatActivity {
    @BindView(R.id.toolbar)
    Toolbar toolbar;    

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_home);
        ButterKnife.bind(this);
        //Since i am using custom tool bar i am setting refernce of that toolbar to Actionbar. If you are not using custom then you can simple leave this and move to next line
        setSupportActionBar(toolbar); 
        getSupportActionBar.setDisplayHomeAsUpEnabled(true); // this will show the back arrow in the tool bar.
}
}

Wenn Sie diesen Code ausführen, sehen Sie, wenn Sie die Zurück-Taste drücken, um zur Hauptaktivität zurückzukehren. Für ein besseres Verständnis von Up Navigation würde ich das Lesen von Dokumenten empfehlen

Sie können dieses Verhalten an Ihre Bedürfnisse anpassen, indem Sie es überschreiben

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
    // Respond to the action bar's Up/Home button
    case android.R.id.home:
        NavUtils.navigateUpFromSameTask(this); // Here you will write your logic for handling up navigation
        return true;
    }
    return super.onOptionsItemSelected(item);
}

Einfacher Hack

Dies ist ein einfacher Hack, der meistens verwendet wird, um zur übergeordneten Aktivität zu navigieren, wenn das übergeordnete Element im Hintergrund ist. Durch Aufruf von onBackPressed() wenn id gleich android.R.id.home

@Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        switch (id) {
            case android.R.id.home:
                onBackPressed();
                return true;
        }
        return super.onOptionsItemSelected(item);
    }