Android
Czynność

Wprowadzenie

Składnia

• void onCreate (Bundle saveInstanceState) // Wywoływany podczas rozpoczynania działania.

• void onPostCreate (pakiet saveInstanceState) // Wywoływany, gdy uruchamianie aktywności jest zakończone (po wywołaniu onStart () i onRestoreInstanceState (pakiet)).

• void onStart () // Wywoływany po onCreate (pakiet) - lub po onRestart (), gdy aktywność została zatrzymana, ale teraz jest ponownie wyświetlana użytkownikowi.

• void onResume () // Wywoływany po onRestoreInstanceState (pakiet), onRestart () lub onPause (), aby Twoja aktywność zaczęła wchodzić w interakcje z użytkownikiem.

• void onPostResume () // Wywoływany, gdy wznawianie aktywności jest zakończone (po wywołaniu onResume ()).

• void onRestart () // Wywoływany po onStop (), gdy bieżąca aktywność jest ponownie wyświetlana użytkownikowi (użytkownik powrócił do niego).

• void onPause () // Wywoływany jako część cyklu życia działania, gdy działanie przechodzi w tło, ale nie zostało (jeszcze) zabite.

• void onStop () // Wywoływany, gdy użytkownik nie jest już widoczny dla użytkownika.

• void onDestroy () // Wykonaj końcowe czyszczenie przed zniszczeniem działania.

• void onNewIntent (Intent intent) // Jest to wywoływane dla działań, które ustawiają launchMode na „singleTop” w swoim pakiecie lub jeśli klient użył flagi FLAG_ACTIVITY_SINGLE_TOP podczas wywoływania startActivity (Intent).

• void onSaveInstanceState (pakiet outState) // Wywoływany w celu odzyskania stanu instancji z działania przed zabiciem, aby stan mógł zostać przywrócony w onCreate (pakiet) lub onRestoreInstanceState (pakiet) (pakiet wypełniony tą metodą zostanie przekazany do obu ).

• void onRestoreInstanceState (pakiet saveInstanceState) // Ta metoda jest wywoływana po onStart (), gdy aktywność jest ponownie inicjowana z wcześniej zapisanego stanu, podanego tutaj w saveInstanceState.

Parametry

Uwagi

Wyklucz aktywność z historii stosu

Niech pojawi się działanie B które można otworzyć, i może ono dalej uruchamiać więcej działań. Ale użytkownik nie powinien się z tym spotykać podczas powrotu do czynności.

Najprostszym rozwiązaniem jest ustawienie atrybutu noHistory na true dla tego <activity> w AndroidManifest.xml :

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

To samo zachowanie jest również możliwe z kodu, jeśli wywołania B finish() przed rozpoczęciem następnego działania:

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

Typowe użycie flagi noHistory dotyczy „ekranu powitalnego” lub działań związanych z logowaniem.

Wyjaśnienie cyklu życia systemu Android

Załóżmy aplikację z funkcją MainActivity, która może wywoływać następne działanie za pomocą kliknięcia przycisku.

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

i

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

Kiedy aplikacja jest tworzona po raz pierwszy
D / MainActivity: wywoływanie onCreate z MainActivity
D / MainActivity: wywołanie onStart z MainActivity
D / MainActivity: wywoływanieResume z MainActivity
są nazywane

Kiedy ekran śpi
08: 11: 03.142 D / MainActivity: wywoływaniePauza z MainActivity
08: 11: 03.192 D / MainActivity: wywołanie onStop z MainActivity
są nazywane. I znowu, gdy się budzi
08: 11: 55.922 D / MainActivity: wywoływanie Uruchom ponownie z MainActivity
08: 11: 55.962 D / MainActivity: wywołanie onStart z MainActivity
08: 11: 55.962 D / MainActivity: wywoływanie Resume z MainActivity
są nazywane

Przypadek 1: Po wywołaniu następnego działania z działania głównego
D / MainActivity: wywołanie następnego działania
D / MainActivity: wywołanie onPause z MainActivity
D / NextActivity: wywoływanie onCreate z następnego działania
D / NextActivity: wywołanie onStart z następnego działania
D / NextActivity: wywołanie OnResume z Next Activity
D / MainActivity: wywołanie onStop z MainActivity

Podczas powrotu do głównego działania z następnego działania za pomocą przycisku wstecz
D / NextActivity: wywołanie onPause od następnego działania
D / MainActivity: wywoływanie Uruchom ponownie z MainActivity
D / MainActivity: wywołanie onStart z MainActivity
D / MainActivity: wywoływanieResume z MainActivity
D / NextActivity: wywoływanie onStop z następnego działania
D / NextActivity: wywoływanieDestroy z następnego działania

Przypadek 2: Gdy działanie jest częściowo zasłonięte (po naciśnięciu przycisku przeglądu) lub gdy aplikacja przechodzi w tło, a inna aplikacja całkowicie ją zasłania
D / MainActivity: wywołanie onPause z MainActivity
D / MainActivity: wywołanie onStop z MainActivity
a gdy aplikacja powróci na pierwszy plan i będzie mogła akceptować dane wprowadzane przez użytkownika,
D / MainActivity: wywoływanie Uruchom ponownie z MainActivity
D / MainActivity: wywołanie onStart z MainActivity
D / MainActivity: wywoływanieResume z MainActivity
są nazywane

Przypadek 3: Gdy działanie jest wywoływane w celu spełnienia ukrytych zamiarów, a użytkownik dokonał wyboru. Na przykład, gdy przycisk udostępniania jest wciśnięty, a użytkownik musi wybrać aplikację z wyświetlonej listy aplikacji
D / MainActivity: wywołanie onPause z MainActivity

Aktywność jest widoczna, ale teraz nieaktywna. Po dokonaniu wyboru i uruchomieniu aplikacji
D / MainActivity: wywoływanieResume z MainActivity
jest nazywany

Przypadek 4:
Gdy aplikacja zostanie zabita w tle (aby zwolnić zasoby dla innej aplikacji na pierwszym planie), onPause (dla urządzenia o strukturze plastra miodu) lub onStop (od urządzenia o strukturze plastra miodu) będą wywoływane jako ostatnie, zanim aplikacja zostanie zakończona.

Programy onCreate i onDestroy będą wywoływane jako najwyższe po każdym uruchomieniu aplikacji. Ale onPause, onStop, onRestart, onStart, onResume może być wywoływany wiele razy podczas cyklu życia.

Uruchomienie trybu

Tryb uruchamiania określa zachowanie nowej lub istniejącej aktywności w zadaniu.
Możliwe są tryby uruchamiania:

• standard
• singleTop
• singleTask
• pojedyncza instancja

Powinien zostać zdefiniowany w manifeście Androida w elemencie <activity/> jako atrybut android:launchMode .

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

Standard:

Domyślna wartość. Jeśli ten tryb zostanie ustawiony, nowe działanie będzie zawsze tworzone dla każdego nowego zamiaru. Możliwe jest uzyskanie wielu działań tego samego typu. Nowa aktywność zostanie umieszczona na górze zadania. Istnieje pewna różnica dla różnych wersji Androida: jeśli aktywność rozpoczyna się od innej aplikacji, na androidach <= 4.4 zostanie ona umieszczona na tym samym zadaniu co aplikacja startowa, ale na> = 5.0 zostanie utworzone nowe zadanie.

SingleTop:

Ten tryb jest prawie taki sam jak standard . Można utworzyć wiele instancji działania singleTop. Różnica polega na tym, że jeśli instancja działania już istnieje na górze bieżącego stosu, onNewIntent() zostanie wywołany zamiast tworzenia nowej instancji.

SingleTask:

Aktywność w tym trybie uruchamiania może mieć tylko jedną instancję w systemie . Nowe zadanie dla działania zostanie utworzone, jeśli nie istnieje. W przeciwnym razie zadanie z działaniem zostanie przeniesione na przód i onNewIntent zostanie polecenie onNewIntent .

Pojedyncza instancja:

Ten tryb jest podobny do singleTask . Różnica polega na tym, że zadanie, które posiada działanie z singleInstance może mieć tylko to działanie i nic więcej. Gdy działanie singleInstance utworzy inne działanie, zostanie utworzone nowe zadanie w celu umieszczenia tego działania.

Prezentowanie interfejsu użytkownika za pomocą setContentView

Klasa aktywności zajmuje się tworzeniem dla ciebie okna, w którym możesz umieścić swój interfejs użytkownika za pomocą setContentView .
Istnieją trzy metody setContentView :

• setContentView(int layoutResID) - Ustaw zawartość aktywności z zasobu układu.
• setContentView(View view) - Ustaw zawartość aktywności na jawny widok.
• setContentView(View view, ViewGroup.LayoutParams params) - Ustaw zawartość aktywności na jawny widok z podanymi parametrami.

Po setContentView ten widok jest umieszczany bezpośrednio w hierarchii widoków działania. Sama może być złożoną hierarchią widoków.

Przykłady

Ustaw zawartość z pliku zasobów:

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

Ustaw jako treść w działaniu:

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

Ustaw treść w jawnym widoku:

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

Wyczyść swój obecny stos działań i uruchom nowe działanie

Jeśli chcesz wyczyścić swój aktualny stos działań i uruchomić nowe działanie (na przykład wylogowanie z aplikacji i uruchomienie działania logowania), wydaje się, że istnieją dwa podejścia.

1. Cel (API> = 16)

Wywołanie finishAffinity() z działania

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

Zakończ aplikację z wyłączeniem z ostatnich

Najpierw zdefiniuj ExitActivity w AndroidManifest.xml

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

Następnie klasa ExitActivity

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

Nawigacja aktywności

Nawigacja w górę odbywa się w android:parentActivityName="" poprzez dodanie android:parentActivityName="" w Manifest.xml do tagu aktywności. Zasadniczo za pomocą tego znacznika informujesz system o aktywności nadrzędnej działania.

Jak to jest zrobione?

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

Teraz, gdy kliknę strzałkę na pasku narzędzi HomeActivity, zabiorę mnie z powrotem do działania nadrzędnego.

Kod Java

Tutaj napiszę odpowiedni kod Java wymagany dla tej funkcjonalności.

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

Jeśli uruchomisz ten kod, zobaczysz, kiedy naciśniesz przycisk Wstecz, przeniesie Cię z powrotem do MainActivity. Aby lepiej zrozumieć nawigację w górę, polecam czytanie dokumentów

Możesz bardziej dostosować to zachowanie do własnych potrzeb, zastępując

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

Prosty hack

Jest to prosty hack, który jest najczęściej używany do nawigacji do aktywności rodzica, jeśli rodzic jest w odwrocie. Przez wywołanie onBackPressed() jeśli id jest równy 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);
    }