Android
Werkzaamheid

Invoering

Syntaxis

• void onCreate (bundle saveInstanceState) // Opgeroepen wanneer de activiteit begint.

• void onPostCreate (bundle saveInstanceState) // Opgeroepen wanneer het opstarten van de activiteit is voltooid (nadat onStart () en onRestoreInstanceState (bundel) zijn opgeroepen).

• void onStart () // Genoemd na onCreate (bundel) - of na onRestart () wanneer de activiteit was gestopt, maar nu weer wordt weergegeven aan de gebruiker.

• void onResume () // Genoemd naar onRestoreInstanceState (bundel), onRestart () of onPause (), zodat uw activiteit interactie kan aangaan met de gebruiker.

• void onPostResume () // Opgeroepen wanneer het hervatten van de activiteit is voltooid (nadat onResume () is opgeroepen).

• void onRestart () // Genoemd na onStop () wanneer de huidige activiteit opnieuw wordt weergegeven aan de gebruiker (de gebruiker is ernaartoe teruggekeerd).

• void onPause () // Genoemd als onderdeel van de activiteitenlevenscyclus wanneer een activiteit naar de achtergrond gaat, maar (nog) niet is gedood.

• void onStop () // Genoemd wanneer u niet langer zichtbaar bent voor de gebruiker.

• void onDestroy () // Voer een laatste opschoning uit voordat een activiteit wordt vernietigd.

• void onNewIntent (Intent intent) // Dit wordt aangeroepen voor activiteiten die launchMode instellen op "singleTop" in hun pakket, of als een client de vlag FLAG_ACTIVITY_SINGLE_TOP heeft gebruikt bij het aanroepen van startActivity (Intent).

• void onSaveInstanceState (Bundle outState) // Opgeroepen om de status per instantie van een activiteit op te halen voordat deze wordt gedood, zodat de status kan worden hersteld in onCreate (Bundle) of onRestoreInstanceState (Bundle) (de bundel die met deze methode is ingevuld, wordt aan beide doorgegeven) ).

• void onRestoreInstanceState (Bundle saveInstanceState) // Deze methode wordt genoemd onStart () wanneer de activiteit opnieuw wordt geïnitialiseerd vanuit een eerder opgeslagen status, hier gegeven in saveInstanceState.

parameters

Opmerkingen

Een activiteit uitsluiten van back-stack geschiedenis

Laat er activiteit B die kan worden geopend en die verder meer activiteiten kan starten. Maar de gebruiker zou het niet moeten tegenkomen bij het terug navigeren in taakactiviteiten.

De eenvoudigste oplossing is om het kenmerk noHistory te stellen op true voor die <activity> -tag in AndroidManifest.xml :

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

Hetzelfde gedrag is ook mogelijk vanuit code als B finish() aanroept voordat de volgende activiteit wordt gestart:

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

Typisch gebruik van de noHistory vlag is met "Splash Screen" of Login-activiteiten.

Android Activity LifeCycle verklaard

Stel een toepassing met een MainActivity die de volgende activiteit kan oproepen met een klik op de knop.

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

en

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

Wanneer de app voor het eerst wordt gemaakt
D / MainActivity: calling onCreate from MainActivity
D / MainActivity: aanroepen van Start vanuit MainActivity
D / MainActivity: roept Resume op vanuit MainActivity
worden genoemd

Wanneer het scherm slaapt
08: 11: 03.142 D / MainActivity: aanroepen van Pauzeren vanuit MainActivity
08: 11: 03.192 D / MainActivity: bellen op Stop vanuit MainActivity
worden genoemd. En opnieuw wanneer het wakker wordt
08: 11: 55.922 D / MainActivity: een beroep doen op Restart vanuit MainActivity
08: 11: 55.962 D / MainActivity: oproepen van Start vanuit MainActivity
08: 11: 55.962 D / MainActivity: roept Resume from MainActivity op
worden genoemd

Geval 1: Wanneer de volgende activiteit wordt opgeroepen vanuit Hoofdactiviteit
D / MainActivity: aanroepen van volgende activiteit
D / MainActivity: aanroepen van Pauzeren vanuit MainActivity
D / NextActivity: aanroepenCreate from Next Activity
D / NextActivity: startStart inschakelen vanaf volgende activiteit
D / NextActivity: hervatten vanuit Volgende activiteit
D / MainActivity: onStop aanroepen vanuit MainActivity

Wanneer u terugkeert naar de hoofdactiviteit vanuit de volgende activiteit met de knop Terug
D / NextActivity: aanroepen van Pauzeren van volgende activiteit
D / MainActivity: roept onRestart aan vanuit MainActivity
D / MainActivity: aanroepen van Start vanuit MainActivity
D / MainActivity: roept Resume op vanuit MainActivity
D / NextActivity: onStop aanroepen vanuit Next Activity
D / NextActivity: roep op Vernietigen vanaf volgende activiteit

Geval 2: Wanneer activiteit gedeeltelijk wordt verduisterd (wanneer op de knop Overzicht wordt gedrukt) of wanneer de app naar de achtergrond gaat en een andere app deze volledig verduistert
D / MainActivity: aanroepen van Pauzeren vanuit MainActivity
D / MainActivity: onStop aanroepen vanuit MainActivity
en wanneer de app weer op de voorgrond staat, klaar om gebruikersinvoer te accepteren,
D / MainActivity: roept onRestart aan vanuit MainActivity
D / MainActivity: aanroepen van Start vanuit MainActivity
D / MainActivity: roept Resume op vanuit MainActivity
worden genoemd

Geval 3: wanneer een activiteit wordt aangeroepen om impliciete intentie te vervullen en de gebruiker een selectie moet maken. Bijvoorbeeld wanneer de knop Delen wordt ingedrukt en de gebruiker een app moet selecteren in de lijst met weergegeven applicaties
D / MainActivity: aanroepen van Pauzeren vanuit MainActivity

De activiteit is zichtbaar maar nu niet actief. Wanneer de selectie is voltooid en de app actief is
D / MainActivity: roept Resume op vanuit MainActivity
wordt genoemd

case4:
Wanneer de app op de achtergrond wordt gedood (om bronnen vrij te maken voor een andere voorgrond-app), zullen onPause (voor pre-honeycomb-apparaat) of onStop (want sinds honeycomb-apparaat) de laatste zijn die wordt aangeroepen voordat de app wordt beëindigd.

onCreate en onDestroy worden elke keer dat de toepassing wordt uitgevoerd het meest genoemd. Maar de onPause, onStop, onRestart, onStart, onResume worden vaak tijdens de levenscyclus genoemd.

Activiteit startmodus

De startmodus definieert het gedrag van nieuwe of bestaande activiteit in de taak.
Er zijn mogelijke startmodi:

• standaard-
• singleTop
• singleTask
• enkele instantie

Het moet in het Android-manifest in het element <activity/> worden gedefinieerd als het kenmerk android:launchMode .

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

Standaard:

Standaardwaarde. Als deze modus is ingesteld, wordt altijd nieuwe activiteit gemaakt voor elke nieuwe intentie. Het is dus mogelijk om veel activiteiten van hetzelfde type te krijgen. Nieuwe activiteit wordt bovenop de taak geplaatst. Er is een verschil voor de andere Android-versie: als activiteit begint vanuit een andere applicatie, op androids <= 4.4 wordt deze op dezelfde taak geplaatst als de startapplicatie, maar op> = 5.0 wordt een nieuwe taak gemaakt.

SingleTop:

Deze modus is bijna hetzelfde als standard . Er kunnen veel instanties van singleTop-activiteit worden gemaakt. Het verschil is dat als er al een instantie van activiteit boven aan de huidige stapel bestaat, onNewIntent() wordt aangeroepen in plaats van een nieuwe instantie te maken.

SingleTask:

Activiteit met deze startmodus kan slechts één exemplaar in het systeem hebben . Er wordt een nieuwe taak voor activiteit gemaakt, als deze niet bestaat. Anders wordt taak met activiteit naar voren verplaatst en wordt onNewIntent aangeroepen.

Enkele instantie:

Deze modus is vergelijkbaar met singleTask . Het verschil is dat een taak met een activiteit met singleInstance alleen deze activiteit kan hebben en niets meer. Wanneer singleInstance activiteit een andere activiteit maakt, wordt een nieuwe taak gemaakt om die activiteit te plaatsen.

UI presenteren met setContentView

Activiteitsklasse zorgt voor een venster voor u waarin u uw gebruikersinterface met setContentView .
Er zijn drie setContentView methoden:

• setContentView(int layoutResID) - Stel de activiteitsinhoud van een setContentView(int layoutResID) .
• setContentView(View view) - Stel de activiteitsinhoud in op een expliciete weergave.
• setContentView(View view, ViewGroup.LayoutParams params) - Stel de activiteitsinhoud in op een expliciete weergave met meegeleverde params.

Wanneer setContentView wordt aangeroepen, wordt deze weergave rechtstreeks in de weergavehiërarchie van de activiteit geplaatst. Het kan zelf een complexe weergavehiërarchie zijn.

Voorbeelden

Inhoud instellen vanuit bronbestand:

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

Stel het in als inhoud in activiteit:

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

Stel inhoud in op een expliciete weergave:

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

Wis uw huidige activiteitenstapel en start een nieuwe activiteit

Als u uw huidige activiteitenstapel wilt wissen en een nieuwe activiteit wilt starten (bijvoorbeeld uitloggen bij de app en een inlogactiviteit starten), zijn er twee benaderingen.

1. Doel (API> = 16)

finishAffinity() vanuit een activiteit

2. Doel (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();

Einde toepassing met uitsluiten van Recent

Definieer eerst een ExitActivity in AndroidManifest.xml

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

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

Omhoog Navigatie voor activiteiten

Navigatie wordt gedaan in Android door android:parentActivityName="" in Manifest.xml aan de activiteitentag toe te voegen. Kortom, met deze tag vertel je het systeem over de ouderactiviteit van een activiteit.

Hoe is het gedaan?

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

Als ik nu op de pijl in de werkbalk van HomeActivity klik, ga ik terug naar de bovenliggende activiteit.

Java-code

Hier zal ik de juiste Java-code schrijven die vereist is voor deze functionaliteit.

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

Als u deze code uitvoert, ziet u dat wanneer u op de knop Terug drukt, u teruggaat naar MainActivity. Voor een beter begrip van Up Navigation raad ik aan om documenten te lezen

U kunt dit gedrag meer aanpassen aan uw behoeften door te negeren

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

Eenvoudige hack

Dit is een eenvoudige hack die meestal wordt gebruikt om naar bovenliggende activiteit te navigeren als de ouder achterop zit. Door te bellen onBackPressed() als id gelijk is aan 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);
    }