Przekazywanie danych między fragmentem a jego działaniem w kontenerze

Jak mogę przekazać dane między fragmentem a jego działaniem w kontenerze? Czy jest coś podobnego do przekazywania danych między działaniami poprzez intencje?

Czytałem to, ale niewiele to pomogło:
http://developer.android.com/guide/topics/fundamentals/fragments.html#CommunicatingWithActivity

W swoim fragmencie możesz zadzwonić getActivity().

Dzięki temu uzyskasz dostęp do aktywności, która utworzyła fragment. Stamtąd możesz oczywiście wywołać dowolne metody akcesorów, które są w działaniu.

np. dla metody wywoływanej getResult()w Twoim działaniu:

((MyActivity) getActivity()).getResult();

Spróbuj użyć interfejsów.

Każdy fragment, który powinien przekazywać dane z powrotem do swojego działania zawierającego, powinien deklarować interfejs do obsługi i przekazywania danych. Następnie upewnij się, że działanie zawierające implementuje te interfejsy. Na przykład:

JAWA

W swoim fragmencie zadeklaruj interfejs ...

public interface OnDataPass {
    public void onDataPass(String data);
}

Następnie podłącz implementację interfejsu klasy zawierającej do fragmentu w metodzie onAttach, tak jak poniżej:

OnDataPass dataPasser;

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    dataPasser = (OnDataPass) context;
}

W swoim fragmencie, gdy musisz obsłużyć przekazywanie danych, po prostu wywołaj go w obiekcie dataPasser:

public void passData(String data) {
    dataPasser.onDataPass(data);
}

Wreszcie, w Twojej działalności zawierającej, która implementuje OnDataPass ...

@Override
public void onDataPass(String data) {
    Log.d("LOG","hello " + data);
}

KOTLIN

Krok 1. Utwórz interfejs

interface OnDataPass {
    fun onDataPass(data: String)
}

Krok 2. Następnie podłącz implementację interfejsu zawierającej klasę do fragmentu w metodzie onAttach (YourFragment), tak jak poniżej:

lateinit var dataPasser: OnDataPass

override fun onAttach(context: Context) {
    super.onAttach(context)
    dataPasser = context as OnDataPass
}

Krok 3. W obrębie twojego fragmentu, kiedy musisz obsłużyć przekazywanie danych, po prostu wywołaj go w obiekcie dataPasser:

fun passData(data: String){
    dataPasser.onDataPass(data)
}

Krok 4. Wreszcie, w swojej aktywności implementuje OnDataPass

class MyActivity : AppCompatActivity(), OnDataPass {}

override fun onDataPass(data: String) {
    Log.d("LOG","hello " + data)
}

Najłatwiejsze podejście, ale nie zalecane

Możesz uzyskać dostęp do danych aktywności z fragmentu:

Czynność:

public class MyActivity extends Activity {

    private String myString = "hello";

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

    public String getMyData() {
        return myString;
    }
}

Fragment:

public class MyFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        MyActivity activity = (MyActivity) getActivity();
        String myDataFromActivity = activity.getMyData();
        return view;
    }
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
    Bundle b = getActivity().getIntent().getExtras();
            wid = b.getString("wid");
            rid = b.getString("rid");
            View view = inflater.inflate(R.layout.categoryfragment, container, false);
    return view;
 }

Przekazywanie danych między fragmentem a jego działaniem w kontenerze

Czynność:

        Bundle bundle = new Bundle();
        bundle.putString("message", "Alo Elena!");
        FragmentClass fragInfo = new FragmentClass();
        fragInfo.setArguments(bundle);
        transaction.replace(R.id.fragment_single, fragInfo);
        transaction.commit();

Fragment:

Czytanie wartości we fragmencie

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

Nie wiem, czy to najlepszy sposób, czy nie Bu Szukałem w Google od dłuższego czasu znajdując, jak mogę przekazać pakiet z fragmentu do jego aktywności w kontenerze, ale zamiast tego znalazłem tylko wysyłanie danych z działania do fragmentu (co było dla mnie trochę zagmatwane, ponieważ jestem nowicjuszem).

później spróbowałem czegoś własnego, co działało dla mnie dokładnie tak, jak chciałem. więc opublikuję to tutaj, jeśli ktoś taki jak ja szuka tego samego.

// Przekazywanie danych z fragmentu.

Bundle gameData = new Bundle();
        gameData.putStringArrayList(Constant.KEY_PLAYERS_ARR,players);
        gameData.putString(Constant.KEY_TEAM_NAME,custom_team_name);
        gameData.putInt(Constant.KEY_REQUESTED_OVER,requestedOver);

        Intent intent = getActivity().getIntent();
        intent.putExtras(gameData);

// Pobieranie danych z pakietu z jego aktywności w kontenerze.

Bundle gameData = getIntent().getExtras();
        if (gameData != null)
        {
            int over = gameData.getInt(Constant.KEY_REQUESTED_OVER);
            ArrayList<String> players = gameData.getStringArrayList(Constant.KEY_PLAYERS_ARR);
            String team = gameData.getString(Constant.KEY_TEAM_NAME);

        }
        else if (gameData == null)
        {
            Toast.makeText(this, "Bundle is null", Toast.LENGTH_SHORT).show();
        }

Interfejs to jedno z najlepszych rozwiązań:

Interfejs kleju:

public interface DataProviderFromActivity {

    public String getName();
    public String getId);

}  

Moja aktywność:

public class MyActivity implements DataProviderFromActivity{

    String name = "Makarov";
    String id = "sys533";

    ... ... ... ... ... .... .... 
    ... ... ... ... ... .... .... 

    public String getName(){
        return name;
    };
    public String getId(){
        return id;
    };
}

MyFragment:

public class MyFragment extends Fragment{

    String fragName = "";
    String fragId = "";

    ... ... ... ... ... .... .... 
    ... ... ... ... ... .... .... 

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

        DataProviderFromActivity myActivity= (DataProviderFromActivity) getActivity();
        fragName = myActivity.getName();
        fragId = myActivity.getId();

        ... ... ... ... ... .... .... 
        ... ... ... ... ... .... .... 

        updateFragmentView();
    }
}

Użyłem AppCompatActivity, który implementuje nasłuchiwanie dat. Fragmenty były konieczne, ponieważ musiałem zakodować selektor zakresu dat. Potrzebowałem również kontenera, aby otrzymać wybrane daty, aby przywrócić je do aktywności nadrzędnej.

W przypadku działania kontenera jest to deklaracja klasy:

public class AppCompatDateRange extends AppCompatActivity implements
    DateIniRangeFragment.OnDateIniSelectedListener, DateFimRangeFragment.OnDateFimSelectedListener

I interfejsy dla wywołań zwrotnych:

@Override
public void onDateIniSelected(String dataIni) {
    Log.i("data inicial:", dataIni);
}

@Override
public void onDateFimSelected(String dataFim) {
    Log.i("data final:", dataFim);
}

Wywołania zwrotne są ciągami, ponieważ daty są parametrami w wyborze zapytania.

Kod fragmentów (na podstawie początkowego fragmentu daty):

public class DateIniRangeFragment extends Fragment {
OnDateIniSelectedListener callbackIni;

private DatePicker startDatePicker;

public DateIniRangeFragment() {
    ///required empty constructor
}

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

///through this interface the fragment sends data to the container activity
public interface OnDateIniSelectedListener {
    void onDateIniSelected(String dataIni);
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    ///layout for the fragment
    View v = inflater.inflate(R.layout.date_ini_fragment, container, false);

    ///initial date for the picker, in this case, current date
    startDatePicker = (DatePicker) v.findViewById(R.id.start_date_picker_appcompat);
    Calendar c = Calendar.getInstance();
    int ano = c.get(Calendar.YEAR);
    int mes = c.get(Calendar.MONTH);
    int dia = c.get(Calendar.DAY_OF_MONTH);
    startDatePicker.setSpinnersShown(false);
    startDatePicker.init(ano, mes, dia, dateSetListener);

    return v;
}

///listener that receives the selected date
private DatePicker.OnDateChangedListener dateSetListener = new DatePicker.OnDateChangedListener() {
    public void onDateChanged(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
        if (view.isShown()) { ///if the datepicker is on the screen
            String sDataIni = year + "-" + (monthOfYear + 1) + "-" + dayOfMonth;
            callbackIni.onDateIniSelected(sDataIni); //apply date to callback, string format
        }
    }
};

@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);

    /*
    * this function guarantees that the container activity implemented the callback interface
    * */
    try {
        callbackIni = (OnDateIniSelectedListener) activity;
    } catch (ClassCastException e) {
        throw new ClassCastException(activity.toString() + " deve implementar OnDateIniSelectedListener");
    }
}

}

Aby skomponować kontener + fragmenty, użyłem ViewPager (AppCompat) z niestandardową klasą, która rozszerza FragmentPagerAdapter. Brak okien dialogowych.

Po prostu możesz skorzystać z EventBus, jest to łatwe i działa świetnie

EventBus w 3 krokach

1. Zdefiniuj wydarzenia:

   public static class MessageEvent { /* Additional fields if needed */ }

2. Przygotuj subskrybentów: zadeklaruj i dodaj adnotacje do swojej metody subskrypcji, opcjonalnie określ tryb wątku:

   @Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {/* Do something */};

Zarejestruj i wyrejestruj swojego subskrybenta. Na przykład na Androidzie działania i fragmenty powinny zwykle rejestrować się zgodnie z ich cyklem życia:

 @Override
 public void onStart() {
     super.onStart();
     EventBus.getDefault().register(this);
 }

 @Override
 public void onStop() {
     super.onStop();
     EventBus.getDefault().unregister(this);
 }

1. Opublikuj wydarzenia:

   EventBus.getDefault().post(new MessageEvent());

Wiem, że to może być późno. Ale ja też zawsze byłem zagubiony w tej kwestii. Udostępniam ten link ... ponieważ jest to prawdopodobnie najlepsze wyjaśnienie tego problemu, jakie kiedykolwiek znalazłem w Internecie. To rozwiązuje fragment do działania i fragment do fragmentu !

Naprawdę dobrze rozwiązany i wyjaśniony

To działa dla mnie ...

w Aktywności dodaj tę metodę

    public void GetData(String data)
     {
        // do something with your data        
     }

i we fragmencie dodaj tę linię

((YourActivity)getContext).GetData("your data here");

public class Fragmentdemo extends Fragment {

  public interface onDemoEventListener {
    public void demoEvent(String s);
  }

  onDemoEventListener demoEventListener;

  @Override
  public void onAttach(Activity activity) {
    super.onAttach(activity);
        try {
          demoEventListener = (onDemoEventListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement onDemoEventListener");
        }
  }

  final String LOG_TAG = "TAG";

  public View onCreateView(LayoutInflater inflater, ViewGroup container,
      Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.fragmentdemo, null);

    Button button = (Button) v.findViewById(R.id.button);
    button.setOnClickListener(new OnClickListener() {
      public void onClick(View v) {
        demoEventListener.someEvent("Test text to Fragment1");
      }
    });
    enter code here
    return v;
  }
}

Innym prostym sposobem na pobranie danych, przekazanych z innej aktywności, we fragmencie w działaniu kontenera: na przykład:

Activity_A => Activity_B (fragment)

W swoim Activity_A tworzysz intencję, taką jak wysyłanie danych (tutaj String) do innego działania:

Intent intent = new Intent(getBaseContext(),Activity_B.class);
intent.putExtra("NAME", "Value");
startActivity(intent);

w Twoim fragmencie zawartym w Twoim Activity_B:

String data = getActivity().getIntent().getExtras();