Android
Aktivitet

Introduktion

Syntax

• void onCreate (Bundle sparadInstanceState) // Ringas när aktiviteten startar.

• void onPostCreate (Bundle sparadInstanceState) // Anropas när aktivitetsstart är slutfört (efter onStart () och onRestoreInstanceState (Bundle) har kallats)).

• void onStart () // Called after onCreate (Bundle) - eller efter onRestart () när aktiviteten hade stoppats, men visas nu igen för användaren.

• void onResume () // Kallas efter onRestoreInstanceState (Bundle), onRestart () eller onPause () för att din aktivitet ska börja interagera med användaren.

• void onPostResume () // Anropas när aktivitetsuppdateringen är klar (efter att onResume () har kallats).

• void onRestart () // Kallas efter onStop () när den aktuella aktiviteten visas igen för användaren (användaren har navigerat tillbaka till den).

• void onPause () // Kallas som en del av aktivitetslivscykeln när en aktivitet går i bakgrunden, men inte (ännu) har dödats.

• void onStop () // Ringas när du inte längre är synlig för användaren.

• void onDestroy () // Utför någon slutlig sanering innan en aktivitet förstörs.

• void onNewIntent (Intent intention) // Detta krävs för aktiviteter som ställer startMode till "singleTop" i deras paket, eller om en klient använde flaggan FLAG_ACTIVITY_SINGLE_TOP när man ringer startActivity (Intent).

• void onSaveInstanceState (Bundle outState) // Kallas för att hämta per-instansstillstånd från en aktivitet innan den dödas så att staten kan återställas i onCreate (Bundle) eller onRestoreInstanceState (Bundle) (den bunt som fylls med denna metod kommer att skickas till båda ).

• void onRestoreInstanceState (Bundle sparadInstanceState) // Den här metoden kallas efter onStart () när aktiviteten återinitieras från ett tidigare sparat tillstånd, som ges här i SaveInstanceState.

parametrar

Anmärkningar

Uteslut en aktivitet från back-stack-historiken

Låt det finnas aktivitet B som kan öppnas, och kan ytterligare starta fler aktiviteter. Men användaren ska inte stöta på det när han navigerar tillbaka i uppgifter.

Den enklaste lösningen är att ställa attributet noHistory till att vara true för den <activity> -taggen i AndroidManifest.xml :

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

Samma beteende är också möjligt från kod om B samtal är finish() innan nästa aktivitet startar:

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

Typisk användning av noHistory flaggan är med "Splash Screen" eller inloggningsaktiviteter.

Android Activity LifeCycle Explained

Anta en applikation med en MainActivity som kan ringa Nästa aktivitet med ett knappklick.

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

och

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

När appen skapas först
D / MainActivity: call onCreate från MainActivity
D / MainActivity: anropar Starta från MainActivity
D / MainActivity: call onResume from MainActivity
kallas

När skärmen sover
08: 11: 03.142 D / MainActivity: call onPause from MainActivity
08: 11: 03.192 D / MainActivity: ringer på Stop från MainActivity
kallas. Och igen när det vaknar
08: 11: 55.922 D / MainActivity: call on Starta om från MainActivity
08: 11: 55.962 D / MainActivity: ringer på Starta från MainActivity
08: 11: 55.962 D / MainActivity: call onResume from MainActivity
kallas

Fall 1: När nästa aktivitet kallas från huvudaktivitet
D / MainActivity: anropar Next Activity
D / MainActivity: call onPause from MainActivity
D / NextActivity: call onCreate från Next Activity
D / NextActivity: ringa på Starta från Next Activity
D / NextActivity: call onResume from Next Activity
D / MainActivity: ringer på Stop från MainActivity

När du återvänder till huvudaktiviteten från nästa aktivitet med hjälp av tillbaka-knappen
D / NextActivity: call onPause from Next Activity
D / MainActivity: anropar omstart från MainActivity
D / MainActivity: anropar Starta från MainActivity
D / MainActivity: call onResume from MainActivity
D / NextActivity: ringer på Stop från Next Activity
D / NextActivity: anropar Destroy från Next Activity

Fall2: När aktivitet delvis är dold (När översiktsknappen trycks ned) eller När appen går till bakgrunden och en annan app döljer den helt
D / MainActivity: call onPause from MainActivity
D / MainActivity: ringer på Stop från MainActivity
och när appen är tillbaka i förgrunden redo att acceptera användaringångar,
D / MainActivity: anropar omstart från MainActivity
D / MainActivity: anropar Starta från MainActivity
D / MainActivity: call onResume from MainActivity
kallas

Fall3: När en aktivitet kallas för att uppfylla implicit avsikt och användaren har gjort ett urval. Till exempel när du trycker på delningsknappen och användaren måste välja en app i listan över visade applikationer
D / MainActivity: call onPause from MainActivity

Aktiviteten är synlig men inte aktiv nu. När valet är gjort och appen är aktiv
D / MainActivity: call onResume from MainActivity
kallas

Case4:
När appen dödas i bakgrunden (för att frigöra resurser för en annan förgrundsapp), kommer OnPause (för pre-honeycomb-enhet) eller onStop (för sedan honeycomb-enhet) att vara den sista som kallas innan appen avslutas.

onCreate och onDestroy kommer att kallas ytterst en gång varje gång applikationen körs. Men onPause, onStop, onRestart, onStart, onResume kanske kallas många gånger under livscykeln.

AktivitetsstartMode

Startläge definierar beteendet för ny eller befintlig aktivitet i uppgiften.
Det finns möjliga startlägen:

• standard
• singleTop
• singleTask
• SingleInstance

Det bör definieras i Android manifest i <activity/> element som android:launchMode attribut.

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

Standard:

Standardvärde. Om detta läge ställs in skapas alltid ny aktivitet för varje ny avsikt. Så det är möjligt att få många aktiviteter av samma typ. Ny aktivitet kommer att placeras på toppen av uppgiften. Det finns en viss skillnad för olika Android-versioner: om aktivitet startar från en annan applikation, på androids <= 4.4 kommer den att placeras på samma uppgift som startprogram, men på> = 5.0 skapas en ny uppgift.

SingleTop:

Detta läge är nästan samma som standard . Många fall av singleTop-aktivitet kan skapas. Skillnaden är att om en förekomst av aktivitet redan finns på toppen av den aktuella stacken kommer onNewIntent() att anropas istället för att skapa en ny instans.

SingleTask:

Aktivitet med detta startläge kan endast ha en instans i systemet . Ny uppgift för aktivitet skapas om den inte finns. Annars flyttas uppgiften med aktivitet till front och onNewIntent kommer att anropas.

SingleInstance:

Det här läget liknar singleTask . Skillnaden är en uppgift som innehar en aktivitet med singleInstance kan bara ha denna aktivitet och inget mer. När singleInstance aktivitet skapar en annan aktivitet skapas en ny uppgift för att placera den aktiviteten.

Presenterar UI med setContentView

Aktivitetsklassen tar hand om att skapa ett fönster för dig där du kan placera ditt UI med setContentView .
Det finns tre setContentView metoder:

• setContentView(int layoutResID) - Ställ in aktivitetsinnehållet från en layoutresurs.
• setContentView(View view) - Ställ in aktivitetsinnehållet till en tydlig vy.
• setContentView(View view, ViewGroup.LayoutParams params) - Ställ in aktivitetsinnehållet till en tydlig vy med tillhandahållna params.

När setContentView anropas placeras denna vy direkt i aktivitetens visningshierarki. Det kan i sig vara en komplex visningshierarki.

exempel

Ställ in innehåll från resursfilen:

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

Ställ in det som innehåll i aktivitet:

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

Ställ in innehåll till en tydlig vy:

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

Rensa din nuvarande aktivitetsstapel och starta en ny aktivitet

Om du vill rensa din nuvarande aktivitetsstapel och starta en ny aktivitet (till exempel att logga ut från appen och starta en inloggningsaktivitet) verkar det finnas två tillvägagångssätt.

1. Mål (API> = 16)

Calling finishAffinity() från en aktivitet

2. Mål (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();

Avsluta ansökan med undantag från Recents

Definiera först en ExitActivity i AndroidManifest.xml

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

Därefter ExitActivity-klassen

/**
 * 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);
    }
}

Upp navigering för aktiviteter

Navigering android:parentActivityName="" görs i Android genom att lägga till android:parentActivityName="" i Manifest.xml till aktivitetstaggen. I grund och botten med denna tagg berättar du systemet om en aktivitets överordnade aktivitet.

Hur görs det?

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

När jag nu klickar på pilen i verktygsfältet i HomeActivity tar det mig tillbaka till överordnad aktivitet.

Java-kod

Här kommer jag att skriva rätt Java-kod som krävs för denna funktion.

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

Om du kör den här koden ser du när du trycker på tillbaka-knappen tar den tillbaka till MainActivity. För ytterligare förståelse av Up Navigation rekommenderar jag att du läser dokument

Du kan mer anpassa detta beteende efter dina behov genom att åsidosätta

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

Enkel hack

Detta är en enkel hack som oftast används för att navigera till överordnad aktivitet om föräldern är i backstack. Genom att ringa onBackPressed() om id är lika med 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);
    }