Android
Paprochy

Wprowadzenie

Składnia

• void onActivityCreated (Bundle saveInstanceState) // Wywoływany, gdy utworzono aktywność fragmentu i utworzono wystąpienie hierarchii widoku tego fragmentu.

• void onActivityResult (int requestCode, int resultCode, Intent data) // Odbierz wynik z poprzedniego wywołania startActivityForResult (Intent, int).

• void onAttach (Activity activity) // Ta metoda została uznana za przestarzałą na poziomie API 23. Zamiast tego należy użyć onAttach (Context).

• void onAttach (kontekst kontekstowy) // Wywoływany, gdy fragment jest najpierw dołączany do swojego kontekstu.

• void onAttachFragment (Fragment childFragment) // Wywoływany, gdy fragment jest dołączony jako element potomny tego fragmentu.

• void onConfigurationChanged (Configuration newConfig) // Wywoływany przez system, gdy zmienia się konfiguracja urządzenia podczas działania komponentu.

• void onCreate (pakiet saveInstanceState) // Wywoływany w celu początkowego utworzenia fragmentu.

• Wyświetl onCreateView (inflator LayoutInflater, kontener ViewGroup, pakiet saveInstanceState) // Wywoływany w celu utworzenia fragmentu instancji widoku interfejsu użytkownika.

• void onDestroy () // Wywoływany, gdy fragment nie jest już używany.

• void onDestroyView () // Wywoływany, gdy widok wcześniej utworzony przez onCreateView (LayoutInflater, ViewGroup, Bundle) został odłączony od fragmentu.

• void onDetach () // Wywoływany, gdy fragment nie jest już dołączony do swojej aktywności.

• void onInflate (aktywność działania, atrybuty AttributeSet, pakiet saveInstanceState) // Ta metoda została uznana za przestarzałą na poziomie API 23. Użyj zamiast tego metody onInflate (Context, AttributeSet, Bundle).

• void onInflate (kontekst kontekstowy, atrybuty AttributeSet, pakiet saveInstanceState) // Wywoływany, gdy fragment jest tworzony w ramach inflacji układu widoku, zwykle po ustawieniu widoku zawartości działania.

• void onPause () // Wywoływany, gdy fragment nie jest już wznawiany.

• void onResume () // Wywoływany, gdy fragment jest widoczny dla użytkownika i aktywnie działa.

• void onSaveInstanceState (Bundle outState) // Wywoływany, aby poprosić fragment o zapisanie jego bieżącego stanu dynamicznego, aby można go było później zrekonstruować w nowej instancji jego procesu.

• void onStart () // Wywoływany, gdy fragment jest widoczny dla użytkownika.

• void onStop () // Wywoływany, gdy fragment nie jest już uruchamiany.

• void onViewStateRestored (pakiet saveInstanceState) // Wywoływany, gdy cały zapisany stan został przywrócony do hierarchii widoku fragmentu.

Uwagi

Wzorzec newInstance ()

Chociaż możliwe jest utworzenie konstruktora fragmentów z parametrami, Android wewnętrznie wywołuje konstruktor zero-argumentowy podczas odtwarzania fragmentów (na przykład, jeśli są one przywracane po zabiciu z własnych powodów). Z tego powodu nie zaleca się polegania na konstruktorze, który ma parametry.

Aby mieć pewność, że oczekiwane argumenty fragmentu są zawsze obecne, możesz użyć statycznej metody newInstance() do utworzenia fragmentu i umieścić dowolne parametry w pakiecie, który będzie dostępny podczas tworzenia nowej instancji.

import android.os.Bundle;
import android.support.v4.app.Fragment;

public class MyFragment extends Fragment
{
  // Our identifier for obtaining the name from arguments
  private static final String NAME_ARG = "name";

  private String mName;

  // Required
  public MyFragment(){}

  // The static constructor.  This is the only way that you should instantiate
  // the fragment yourself
  public static MyFragment newInstance(final String name) {
    final MyFragment myFragment = new MyFragment();
    // The 1 below is an optimization, being the number of arguments that will
    // be added to this bundle.  If you know the number of arguments you will add
    // to the bundle it stops additional allocations of the backing map.  If
    // unsure, you can construct Bundle without any arguments
    final Bundle args = new Bundle(1);

    // This stores the argument as an argument in the bundle.  Note that even if
    // the 'name' parameter is NULL then this will work, so you should consider
    // at this point if the parameter is mandatory and if so check for NULL and
    // throw an appropriate error if so
    args.putString(NAME_ARG, name);

    myFragment.setArguments(args);
    return myFragment;
  }

  @Override
  public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final Bundle arguments = getArguments();
    if (arguments == null || !arguments.containsKey(NAME_ARG)) {
      // Set a default or error as you see fit
    } else {
      mName = arguments.getString(NAME_ARG);
    }
  }
}

Teraz w działaniu:

FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
MyFragment mFragment = MyFragment.newInstance("my name");
ft.replace(R.id.placeholder, mFragment);
//R.id.placeholder is where we want to load our fragment
ft.commit();

Ten wzorzec jest najlepszą praktyką, aby zapewnić, że wszystkie potrzebne argumenty zostaną przekazane do fragmentów podczas tworzenia. Zauważ, że kiedy system zniszczy fragment i ponownie go utworzy później, automatycznie przywróci jego stan - ale musisz zapewnić mu onSaveInstanceState(Bundle) .

Nawigacja między fragmentami za pomocą plecaka i statycznego wzoru tkaniny

Przede wszystkim musimy dodać nasz pierwszy Fragment na początku, powinniśmy to zrobić w onCreate() naszej działalności:

if (null == savedInstanceState) {
    getSupportFragmentManager().beginTransaction()
      .addToBackStack("fragmentA")
      .replace(R.id.container, FragmentA.newInstance(), "fragmentA")
      .commit();
}

Następnie musimy zarządzać naszym backstackiem. Najłatwiejszym sposobem jest użycie funkcji dodanej do naszej aktywności, która jest używana dla wszystkich transakcji fragmentów.

public void replaceFragment(Fragment fragment, String tag) {
    //Get current fragment placed in container
    Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.container);

    //Prevent adding same fragment on top
    if (currentFragment.getClass() == fragment.getClass()) {
        return;
    }

    //If fragment is already on stack, we can pop back stack to prevent stack infinite growth
    if (getSupportFragmentManager().findFragmentByTag(tag) != null) {
        getSupportFragmentManager().popBackStack(tag, FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }

    //Otherwise, just replace fragment
    getSupportFragmentManager()
            .beginTransaction()
            .addToBackStack(tag)
            .replace(R.id.container, fragment, tag)
            .commit();
}

Na koniec powinniśmy przesłonić onBackPressed() aby wyjść z aplikacji podczas powrotu z ostatniego fragmentu dostępnego w backstacku.

@Override
public void onBackPressed() {
    int fragmentsInStack = getSupportFragmentManager().getBackStackEntryCount();
    if (fragmentsInStack > 1) { // If we have more than one fragment, pop back stack
        getSupportFragmentManager().popBackStack();
    } else if (fragmentsInStack == 1) { // Finish activity, if only one fragment left, to prevent leaving empty screen
        finish();
    } else {
        super.onBackPressed();
    }
}

Realizacja w działalności:

replaceFragment(FragmentB.newInstance(), "fragmentB");

Realizacja poza działalnością (zakładając, że MainActivity jest naszą działalnością):

((MainActivity) getActivity()).replaceFragment(FragmentB.newInstance(), "fragmentB");

Przekaż dane z działania do fragmentu za pomocą pakietu

Wszystkie fragmenty powinny mieć pusty konstruktor (tj. Metoda konstruktora bez argumentów wejściowych). Dlatego w celu przekazania danych do tworzonego fragmentu należy użyć metody setArguments() . Ta metoda pobiera pakiet, w którym przechowujesz dane, i przechowuje pakiet w argumentach. Następnie ten pakiet można następnie pobrać w onCreate() i onCreateView() .

Czynność:

 Bundle bundle = new Bundle();
 String myMessage = "Stack Overflow is cool!";
 bundle.putString("message", myMessage );
 FragmentClass fragInfo = new FragmentClass();
 fragInfo.setArguments(bundle);
 transaction.replace(R.id.fragment_single, fragInfo);
 transaction.commit();

Fragment:

 @Override
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    String myValue = this.getArguments().getString("message");
    ...
 }

Wysyłanie zdarzeń z powrotem do działania z interfejsem zwrotnym

Jeśli chcesz wysłać zdarzenia od fragmentu do działania, jednym z możliwych rozwiązań jest zdefiniowanie interfejsu zwrotnego i wymaganie, aby działanie hosta go implementowało.

Przykład

Wyślij oddzwonienie do działania po kliknięciu przycisku fragmentu

public interface SampleCallback {
    void onButtonClicked();
}

Następnym krokiem jest przypisanie tego wywołania zwrotnego we fragmencie:

public final class SampleFragment extends Fragment {

    private SampleCallback callback;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof SampleCallback) {
            callback = (SampleCallback) context;
        } else {
            throw new RuntimeException(context.toString()
                    + " must implement SampleCallback");
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        callback = null;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        final View view = inflater.inflate(R.layout.sample, container, false);
        // Add button's click listener
        view.findViewById(R.id.actionButton).setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                callback.onButtonClicked(); // Invoke callback here
            }
        });
        return view;
    }
}

Na koniec zaimplementuj callback w działaniu:

public final class SampleActivity extends Activity implements SampleCallback {

    // ... Skipped code with settings content view and presenting the fragment

    @Override
    public void onButtonClicked() {
        // Invoked when fragment's button has been clicked
    }
}

Animuj przejście między fragmentami

Aby animować przejście między fragmentami lub animować proces pokazywania lub ukrywania fragmentu, użyj narzędzia FragmentManager do utworzenia FragmentTransaction .

W przypadku pojedynczej FragmentTransaction istnieją dwa różne sposoby animacji: możesz użyć standardowej animacji lub dostarczyć własne niestandardowe animacje.

Standardowe animacje są określane poprzez wywołanie FragmentTransaction.setTransition(int transit) i użycie jednej ze wstępnie zdefiniowanych stałych dostępnych w klasie FragmentTransaction . W momencie pisania te stałe to:

FragmentTransaction.TRANSIT_NONE
FragmentTransaction.TRANSIT_FRAGMENT_OPEN
FragmentTransaction.TRANSIT_FRAGMENT_CLOSE
FragmentTransaction.TRANSIT_FRAGMENT_FADE

Cała transakcja może wyglądać mniej więcej tak:

getSupportFragmentManager()
    .beginTransaction()
    .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
    .replace(R.id.contents, new MyFragment(), "MyFragmentTag")
    .commit();

Niestandardowe animacje są określane przez wywołanie FragmentTransaction.setCustomAnimations(int enter, int exit) lub FragmentTransaction.setCustomAnimations(int enter, int exit, int popEnter, int popExit) .

Animacje enter i exit będą odtwarzane dla FragmentTransaction , które nie wymagają wyskakiwania fragmentów z tylnego stosu. popEnter i popExit będą odtwarzane po popExit fragmentu z tylnego stosu.

Poniższy kod pokazuje, jak zastąpić fragment, przesuwając jeden fragment i przesuwając drugi na swoim miejscu.

getSupportFragmentManager()
    .beginTransaction()
    .setCustomAnimations(R.anim.slide_in_left, R.anim.slide_out_right)
    .replace(R.id.contents, new MyFragment(), "MyFragmentTag")
    .commit();

Definicje animacji XML wykorzystują znacznik objectAnimator . Przykład pliku slide_in_left.xml może wyglądać mniej więcej tak:

<?xml version="1.0" encoding="utf-8"?>
<set>
  <objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
    android:propertyName="x" 
    android:valueType="floatType"
    android:valueFrom="-1280"
    android:valueTo="0" 
    android:duration="500"/>
</set>

Komunikacja między fragmentami

Cała komunikacja między Fragmentami musi odbywać się za pośrednictwem Działania. Fragmenty NIE mogą się ze sobą komunikować bez działania.

Dodatkowe zasoby

• Jak zaimplementować OnFragmentInteractionListener
• Android | Komunikowanie się z innymi fragmentami

W tym przykładzie mamy MainActivity która hostuje dwa fragmenty, SenderFragment i ReceiverFragment , odpowiednio do wysyłania i odbierania message (w tym przypadku prosty ciąg).

Przycisk w SenderFragment inicjuje proces wysyłania wiadomości. TextView w ReceiverFragment jest aktualizowany po otrzymaniu wiadomości.

Poniżej znajduje się fragment MainActivity z komentarzami wyjaśniającymi ważne wiersze kodu:

// Our MainActivity implements the interface defined by the SenderFragment. This enables
// communication from the fragment to the activity
public class MainActivity extends AppCompatActivity implements SenderFragment.SendMessageListener {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}

/**
 * This method is called when we click on the button in the SenderFragment
 * @param message The message sent by the SenderFragment
 */
@Override
public void onSendMessage(String message) {
    // Find our ReceiverFragment using the SupportFragmentManager and the fragment's id
    ReceiverFragment receiverFragment = (ReceiverFragment)
            getSupportFragmentManager().findFragmentById(R.id.fragment_receiver);

    // Make sure that such a fragment exists
    if (receiverFragment != null) {
        // Send this message to the ReceiverFragment by calling its public method
        receiverFragment.showMessage(message);
    }
}
}

Plik układu dla MainActivity zawiera dwa fragmenty w LinearLayout:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    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="com.naru.fragmentcommunication.MainActivity">

<fragment
    android:id="@+id/fragment_sender"
    android:name="com.naru.fragmentcommunication.SenderFragment"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="1"
    tools:layout="@layout/fragment_sender" />

<fragment
    android:id="@+id/fragment_receiver"
    android:name="com.naru.fragmentcommunication.ReceiverFragment"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="1"
    tools:layout="@layout/fragment_receiver" />
</LinearLayout>

SenderFragment udostępnia interfejs SendMessageListener który pomaga MainActivity wiedzieć, kiedy kliknięto przycisk w SenderFragment .

Poniżej znajduje się fragment kodu SenderFragment wyjaśniający ważne wiersze kodu:

public class SenderFragment extends Fragment {

private SendMessageListener commander;

/**
 * This interface is created to communicate between the activity and the fragment. Any activity
 * which implements this interface will be able to receive the message that is sent by this
 * fragment.
 */
public interface SendMessageListener {
    void onSendMessage(String message);
}

/**
 * API LEVEL >= 23
 * <p>
 * This method is called when the fragment is attached to the activity. This method here will
 * help us to initialize our reference variable, 'commander' , for our interface
 * 'SendMessageListener'
 *
 * @param context
 */
@Override
public void onAttach(Context context) {
    super.onAttach(context);
    // Try to cast the context to our interface SendMessageListener i.e. check whether the
    // activity implements the SendMessageListener. If not a ClassCastException is thrown.
    try {
        commander = (SendMessageListener) context;
    } catch (ClassCastException e) {
        throw new ClassCastException(context.toString()
                + "must implement the SendMessageListener interface");
    }
}

/**
 * API LEVEL < 23
 * <p>
 * This method is called when the fragment is attached to the activity. This method here will
 * help us to initialize our reference variable, 'commander' , for our interface
 * 'SendMessageListener'
 *
 * @param activity
 */
@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
    // Try to cast the context to our interface SendMessageListener i.e. check whether the
    // activity implements the SendMessageListener. If not a ClassCastException is thrown.
    try {
        commander = (SendMessageListener) activity;
    } catch (ClassCastException e) {
        throw new ClassCastException(activity.toString()
                + "must implement the SendMessageListener interface");
    }
}

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
                         @Nullable Bundle savedInstanceState) {
    // Inflate view for the sender fragment.
    View view = inflater.inflate(R.layout.fragment_receiver, container, false);

    // Initialize button and a click listener on it
    Button send = (Button) view.findViewById(R.id.bSend);
    send.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            // Sanity check whether we were able to properly initialize our interface reference
            if (commander != null) {

                // Call our interface method. This enables us to call the implemented method
                // in the activity, from where we can send the message to the ReceiverFragment.
                commander.onSendMessage("HELLO FROM SENDER FRAGMENT!");
            }
        }
    });

    return view;
}
}

Plik układu dla SenderFragment :

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

<Button
    android:id="@+id/bSend"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="SEND"
    android:layout_gravity="center_horizontal" />
</LinearLayout>

ReceiverFragment jest prosty i udostępnia prostą metodę publiczną do aktualizacji TextView. Kiedy MainActivity odbiera komunikat od SenderFragment , wywołuje tę publiczną metodę ReceiverFragment

Poniżej znajduje się fragment kodu dla ReceiverFragment z komentarzami wyjaśniającymi ważne wiersze kodu:

public class ReceiverFragment extends Fragment {
TextView tvMessage;

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
                         @Nullable Bundle savedInstanceState) {
    // Inflate view for the sender fragment.
    View view = inflater.inflate(R.layout.fragment_receiver, container, false);

    // Initialize the TextView
    tvMessage = (TextView) view.findViewById(R.id.tvReceivedMessage);

    return view;
}


/**
 * Method that is called by the MainActivity when it receives a message from the SenderFragment.
 * This method helps update the text in the TextView to the message sent by the SenderFragment.
 * @param message Message sent by the SenderFragment via the MainActivity.
 */
public void showMessage(String message) {
    tvMessage.setText(message);
}
}

Plik układu dla ReceiverFragment :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical">
<TextView
    android:id="@+id/tvReceivedMessage"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Waiting for message!" />
</LinearLayout>