Passando dados entre um fragmento e sua atividade de contêiner

Como posso transmitir dados entre um fragmento e sua atividade de contêiner? Existe algo semelhante à passagem de dados entre as atividades por meio de intenções?

Eu li isso, mas não ajudou muito:
http://developer.android.com/guide/topics/fundamentals/fragments.html#CommunicatingWithActivity

No seu fragmento você pode ligar getActivity().

Isso lhe dará acesso à atividade que criou o fragmento. A partir daí, obviamente, você pode chamar qualquer tipo de método de acesso que esteja na atividade.

por exemplo, para um método chamado getResult()em sua atividade:

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

Tente usar interfaces.

Qualquer fragmento que deve transmitir dados de volta à sua atividade de contenção deve declarar uma interface para manipular e transmitir os dados. Em seguida, verifique se a atividade que contém implementa essas interfaces. Por exemplo:

JAVA

No seu fragmento, declare a interface ...

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

Em seguida, conecte a implementação da interface da classe que contém ao fragmento no método onAttach, da seguinte maneira:

OnDataPass dataPasser;

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

No seu fragmento, quando você precisar manipular a passagem de dados, basta chamá-lo no objeto dataPasser:

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

Finalmente, em sua atividade de contenção que implementa OnDataPass ...

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

KOTLIN

Etapa 1. Criar interface

interface OnDataPass {
    fun onDataPass(data: String)
}

Etapa 2. Em seguida, conecte a implementação da classe que contém a interface ao fragmento no método onAttach (YourFragment), da seguinte maneira:

lateinit var dataPasser: OnDataPass

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

Etapa 3. No seu fragmento, quando você precisar manipular a passagem de dados, basta chamá-lo no objeto dataPasser:

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

Etapa 4. Finalmente, em sua atividade implementa OnDataPass

class MyActivity : AppCompatActivity(), OnDataPass {}

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

Abordagem mais fácil, mas não recomendada

Você pode acessar os dados da atividade do fragmento:

Atividade:

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

Fragmento:

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

Passando dados entre um fragmento e sua atividade de contêiner

Atividade:

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

Fragmento:

Lendo o valor no fragmento

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

Eu não sei se essa é a melhor maneira ou não Bu, eu tenho pesquisado no google por um bom tempo, descobrindo como posso passar um Bundle de um fragmento para sua atividade de contêiner, mas tudo que eu encontrei foi enviar dados da atividade para o fragmento (o que foi um pouco confuso para mim porque sou novato).

depois, tentei algo próprio que funcionou exatamente para mim como eu queria. então eu vou postar aqui caso alguém como eu procure a mesma coisa.

// Passando dados do fragmento.

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

// Obtendo dados do pacote configurável a partir da atividade do contêiner.

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

Interface é uma das melhores soluções:

Interface de cola:

public interface DataProviderFromActivity {

    public String getName();
    public String getId);

}  

Minha atividade:

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

Eu usei um AppCompatActivity que implementa ouvintes de data. Fragmentos vieram como uma necessidade, pois eu precisava codificar um seletor de período. E também precisava que o contêiner recebesse as datas selecionadas para devolvê-las à atividade pai.

Para a atividade do contêiner, esta é a declaração de classe:

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

E as interfaces para os retornos de chamada:

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

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

Os retornos de chamada são cadeias porque datas são parâmetros em uma seleção de consulta.

O código para os fragmentos (com base no fragmento de data inicial):

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

}

Para compor o contêiner + fragmentos, usei um ViewPager (AppCompat) com uma classe personalizada que estende o FragmentPagerAdapter. Sem diálogos.

Simplesmente você pode usar o EventBus , é fácil e funciona muito bem

EventBus em 3 etapas

1. Defina eventos:

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

2. Preparar assinantes: declare e anote seu método de inscrição, opcionalmente, especifique um modo de encadeamento:

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

Registre e cancele o registro de seu assinante. Por exemplo, no Android, atividades e fragmentos geralmente devem ser registrados de acordo com seu ciclo de vida:

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

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

1. Publicar eventos:

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

Eu sei que isso pode ser tarde. Mas eu também estava sempre perdida nessa questão. Estou compartilhando este link ... porque esta é possivelmente a melhor explicação que eu já encontrei na web para isso. Isso resolve Fragmento para Atividade e Fragmento para Fragmento !

Resolvido e explicado muito bem

Isso está funcionando para mim ..

em Atividade, adicione este método

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

e no fragmento adicione esta linha

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

Outra maneira simples de obter dados, passados ​​de outra atividade, em um fragmento de uma atividade de contêiner: por exemplo:

Activity_A => Activity_B (fragmento)

Em sua Activity_A, você cria uma intenção como se estivesse enviando dados (String aqui) para outra atividade:

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

no seu fragmento, contido no seu Activity_B:

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