Communication between nested fragments in Android

Question

I recently learned how to make nested fragments in Android. I don\'t know how communication is supposed to happen, though.

From reading the fragment commun

Answer 1

Using ViewModel to communicate between nested Fragments

With pieces of the old ViewModel and LiveData now deprecated. I would like to provide information on this process as it currently stands.

In this example I am using a the predefined TabLayout that can be selected when one creates a project.

Here I have a TextView in the parent fragment -- tab, with an EditText and a Button in the child fragment -- custom layout. It passes the text entered in the child fragment to the field in the parent fragment.

I hope this helps someone.

ViewModel Class

public class FragViewModel extends ViewModel {
  private MutableLiveData<CharSequence> digit = new MutableLiveData<>();

  public void insertDigit(CharSequence inDigit){
      digit.setValue(inDigit);
  }

  public LiveData<CharSequence> getDigit(){
      return digit;
  }
}

This is, for the most part, verbatim from the Android Developers ViewModel Overview with a small variable name change. The Overview was used as a guide for the parent and child code below.

The Parent Fragement Code

public class Tab0Main extends Fragment {

private FragViewModel model0;

// This is the Child Fragment.
private ChildFrag childFrag;

private TextView textView;

@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.tab0_main, container, false);

    // Setup the text field.
    textView = view.findViewById(R.id.tab0TextView);

    // Inserting the Child Fragment into the FrameLayout.
    childFrag = new ChildFrag();
    FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
    transaction.add(R.id.tab0Frame, childFrag).commit();

    return view;
}


@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);

    model0 = new ViewModelProvider(getActivity()).get(FragViewModel.class);
    model0.getDigit().observe(getViewLifecycleOwner(), new Observer<CharSequence>() {
        @Override
        public void onChanged(CharSequence charSequence) {
            textView.setText(charSequence);
        }
    });
}

The Child Fragment Code

public class ChildFrag extends Fragment {

private EditText fragEditText;
private Button fragButton;

// The ViewModel declaration
FragViewModel model;

@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.child_frag_layout, container, false);

    // The ViewModel Instantiation
    model = new ViewModelProvider(getActivity()).get(FragViewModel.class);

    fragEditText = view.findViewById(R.id.fragEditText);
    fragButton = view.findViewById(R.id.fragButton);
    fragButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            CharSequence in = fragEditText.getText();
            // Inserting a digit into the ViewModel carrier.
            model.insertDigit(in);
        }
    });
    return view;
  }
}

Answer 2

Although @Suragch's answer is correct, But I want to add another way to pass data between Fragments or Activity. No matter it's an Activity or Fragment you can pass data with event bus in 3 steps:

1- Define an event(message):

public class OrderMessage {
    private final long orderId;
    /* Additional fields if needed */
    public OrderMessage(long orderId) {
        this.orderId = orderId;
    }
    public long getOrderId() {
        return orderId;
    }
}

2- Register and Unregister for Events: To be able to receive events, the class must register/unregister for event bus. The best place for Activities and Fragments is onStart() and onStop()

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

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

To be able to receive an event you have to subscribe to that event. To do that, add @Subscribe annotation to one of your methods in your class.

@Subscribe(threadMode = ThreadMode.MAIN)
   public void onMessage(OrderMessage message){
       /* Do something for example: */
       getContractDetails(message.getOrderId());
   }

3- Post an event

EventBus.getDefault().post(new OrderMessage(recievedDataFromWeb.getOrderId()));

More documentation and examples could be found Here. There are also other libraries like : Otto

Answer 3

Following Rahul Sharma's advice in the comments, I used interface callbacks to communicate up from the Child Fragment to the Parent Fragment and to the Activity. I also submitted this answer to Code Review. I am taking the non-answer there (at the time of this writing) to be a sign that there are no major problems with this design pattern. It seems to me to be consistent with the general guidance given in the official fragment communication docs.

Example project

The following example project expands the example given in the question. It has buttons that initiate upward communication from the fragments to the activity and from the Child Fragment to the Parent Fragment.

I set up the project layout like this:

Main Activity

The Activity implements the listeners from both fragments so that it can get messages from them.

Optional TODO: If the Activity wanted to initiate communication with the fragments, it could just get a direct reference to them and then call one of their public methods.

import android.support.v4.app.FragmentTransaction;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity implements ParentFragment.OnFragmentInteractionListener, ChildFragment.OnChildFragmentToActivityInteractionListener {

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

        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
        ft.replace(R.id.parent_fragment_container, new ParentFragment());
        ft.commit();
    }

    @Override
    public void messageFromParentFragmentToActivity(String myString) {
        Log.i("TAG", myString);
    }

    @Override
    public void messageFromChildFragmentToActivity(String myString) {
        Log.i("TAG", myString);
    }
}

Parent Fragment

The Parent Fragment implements the listener from the Child Fragment so that it can receive messages from it.

Optional TODO: If the Parent Fragment wanted to initiate communication with the Child Fragment, it could just get a direct reference to it and then call one of its public methods.

import android.content.Context;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentTransaction;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;


public class ParentFragment extends Fragment implements View.OnClickListener, ChildFragment.OnChildFragmentInteractionListener {


    // **************** start interesting part ************************

    private OnFragmentInteractionListener mListener;


    @Override
    public void onClick(View v) {
        mListener.messageFromParentFragmentToActivity("I am the parent fragment.");
    }

    @Override
    public void messageFromChildToParent(String myString) {
        Log.i("TAG", myString);
    }

    public interface OnFragmentInteractionListener {
        void messageFromParentFragmentToActivity(String myString);
    }

    // **************** end interesting part ************************



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

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_parent, container, false);
        view.findViewById(R.id.parent_fragment_button).setOnClickListener(this);
        return view;
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        Fragment childFragment = new ChildFragment();
        FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
        transaction.replace(R.id.child_fragment_container, childFragment).commit();
    }

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

}

Child Fragment

The Child Fragment defines listener interfaces for both the Activity and for the Parent Fragment. If the Child Fragment only needed to communicate with one of them, then the other interface could be removed.

import android.content.Context;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;


public class ChildFragment extends Fragment implements View.OnClickListener {


    // **************** start interesting part ************************

    private OnChildFragmentToActivityInteractionListener mActivityListener;
    private OnChildFragmentInteractionListener mParentListener;

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.child_fragment_contact_activity_button:
                mActivityListener.messageFromChildFragmentToActivity("Hello, Activity. I am the child fragment.");
                break;
            case R.id.child_fragment_contact_parent_button:
                mParentListener.messageFromChildToParent("Hello, parent. I am your child.");
                break;
        }
    }

    public interface OnChildFragmentToActivityInteractionListener {
        void messageFromChildFragmentToActivity(String myString);
    }

    public interface OnChildFragmentInteractionListener {
        void messageFromChildToParent(String myString);
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);

        // check if Activity implements listener
        if (context instanceof OnChildFragmentToActivityInteractionListener) {
            mActivityListener = (OnChildFragmentToActivityInteractionListener) context;
        } else {
            throw new RuntimeException(context.toString()
                    + " must implement OnChildFragmentToActivityInteractionListener");
        }

        // check if parent Fragment implements listener
        if (getParentFragment() instanceof OnChildFragmentInteractionListener) {
            mParentListener = (OnChildFragmentInteractionListener) getParentFragment();
        } else {
            throw new RuntimeException("The parent fragment must implement OnChildFragmentInteractionListener");
        }
    }

    // **************** end interesting part ************************



    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_child, container, false);
        view.findViewById(R.id.child_fragment_contact_activity_button).setOnClickListener(this);
        view.findViewById(R.id.child_fragment_contact_parent_button).setOnClickListener(this);
        return view;
    }

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

}

Answer 4

With the release of the architecture components you should probably have a look at the viewmodel architecture component.
In combination with live data you will be easily able to communicate between arbitrarily nested fragments. You might also to take a look at the todoapp and how they handle events there.