Is there a convention for creating, updating and passing data to Fragments or Activities in Android?

Question

I have this Activity (Foo) that hosts this Fragment (Bar) which is filled with information coming from another Activity.

The process goes like this:

MainActivity → Bundle → Foo → Bar → gather data and return to MainActivity.

• Should I store that information in private fields of the Foo Activity at onCreate, and just making the Fragment use them?
• Should I pass the Bundle directly to my Bar Fragment as arguments?
• Should I make a new Bundle out of the received one and pass the new Bundle to the Fragment?
• Should I completely replace the whole fragment each time data changes or should I only update the changing views, when data isn't directly being provided by the user e.g. by a Dialog?

The fragment only has one view whose value may be changed, but this value has to be formatted (it's received from a Dialog).

• Should I store only that changing value in a private field of my Activity and access it when I have to update the view or retrieve the result of the Activity when it finishes?
• Should I implement an Adapter on such view so it stores the value, but shows the formatted information to the user?
• Should I store the formatted value in the view and parse it back to the raw value I need to receive the information it contains when I have to return the gathered data?
• Should I store all the information gathered, replace the fragment for a new one with the information previously collected (by using one of the methods in the first section)?

Is there a convention that covers passing data from one activity to another, and how the data may be used through the lifecyle of the second activity? Or at least some kind of best practices for this?

EDIT:

I'm aware of how to do all of the above points, so I'm not asking for code; the thing is that I find a lack of homogeneity between how I pass the data from the main activity to the child activity, how I pass it to the fragment and how do I update the fragment in the case that data is changed.

Answer 1

I think the method that you are looking for to pass data from Fragment bar to Activity foo is called onAttach. This method gets called when the activity launches the fragment for the first time and passes to the fragment itself. Create an interface for the activity that the fragment uses to pass data back to the Activity. The activity can pass data to the fragment directly.

• the thing is that I find a lack of homogeneity between how I pass the data to the activity

  You pass data to the activity from an fragment through an interface

• how I pass it to the fragment

  Pass data to the fragment directly through public methods (that is if the fragment is alive. If you are instantiating one, use Bundle and Arguments)

• and how do I update the fragment in the case that data is changed

  If a value changed in the activity and you want to notify the fragment to display something new, create a public method and call that from the activity. mFragment.updateView();

I know you didn't ask for code, but this is the basic concept.

Interface:

public interface MyActivityInterface {

    public void passInformationToActivity(Object obj);

}

Activity:

public class MyActivity implements MyActivityInterface {

    private MyFragment myFragment;

    @Override
    public void passInformationToActivity(Object obj) {
        Log.e(TAG, "Information was passed to the activity");
    }

    public void sendInformationToFragment(Object obj) {
        myFragment.sendInformation(obj);
    }
}

Fragment:

public class MyFragment extends Fragment {

    private MyActivityInterface mInterface;

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mInterface = (MyActivityInterface) activity;
        catch (ClassCastException e) {
            Log.e(TAG, "Calling activity must implement MyActivityInterface");
            throw e;
        }
    }

    @Override
    public void onDetatch() {
        super.onDetatch();
        mInterface = null;
    }

    private void notifyActivityOfObject(Object obj) {
        mInterface.passInformationToActivity(obj);
    }

    public void sendInformation(Object obj) {
        Log.e(TAG, "Object received by Fragment");
    }
}

The fragment can talk to the activity through MyActivityInterface and the Activity can talk to the fragment by calling public methods directly on it.

Hope this helps/answers your question. If not, I'm happy to try to help more

Answer 2

For Activity --> AnotherActivity

You use Intents

For Activity --> Fragment

On creation You use setArguments() it is good practice to use newInstance() method like

class MyFragment extends Fragment {

    private static final String ARG_1 = "arg1";
    private static final String ARG_2 = "arg2";

    public static MyFragment newInstance(String arg1, int arg2) {
        MyFragment fragment = new MyFragment();
        Bundle args = new Bundle();
        args.putString(ARG_1, arg1);
        args.putInt(ARG_2, arg2);
        fragment.setArguments(args);
        return fragment;
    }
    public MyFragment() {
        // Required empty public constructor
    }
}

To send something to existing fragment, You get reference to this fragment from FragmentManager or keep it in class scope variable in Activity. You define public method in fragment to be called.

For example:

class MyFragment extends Fragment {

    public static final String TAG = "my_fragment_tag";

    public void updateSomething(String newValue) {
        //do what you need here
    }
}



class MyActivity extends FragmentActivity {

    private MyFragment myFragment;

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

        FragmentManager fragmentManager = getSupportFragmentManager();
        myFragment = fragmentManager.findFragmentByTag(MyFragment.TAG);
        //if it is not null there was configuration change and fragment got recreated
        //use fragment lifecycle methods to get correct state
        if(myFragment==null) {
            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

            myFragment = MyFragment.newInstance("arg1",2);

            fragmentTransaction.add(R.id.main, myFragment, MyFragment.TAG);

            fragmentTransaction.commit();
        }

    }
}

In this example I keep reference to MyFragment in myFragment so I can call myFragment.updateSomething() if needed from Activity.

For Fragment -> Activity

Use interface

class MyFragment extends Fragment {

    private OnMyFragmentInteractionListener mListener;

    public interface OnMyFragmentInteractionListener {
        public void onMyFragmentInteraction(int arg);
    }


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

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

    public void onSomethinfHappend(int arg) {
        mListener.onMyFragmentInteraction(arg);
    }
}

class MyActivity extends FragmentActivity 
    implements MyFragment.OnMyFragmentInteractionListener {

    public void onMyFragmentInteraction(int arg) {
        //receive message from MyFragment
    }
}

For Fragment --> AnotherFragment

You need to go through Activity so You will have

Fragment -> Activity --> AnotherFragment

and You achieve it using methods described above.

Additionally You may startActivityForResult() from fragment and receive result in fragment, but fragments won't receive result if startActivityForResult() was called in Activity. Little more on this here

To answer Your question about Bundle, if this bundle contains data You need to pass to fragment then yes you can use the same Bundle. You can make your newInstance() method to take Bundle as argument or overload it.

Answer 3

The recommended practice of passing data from activity to activity is through bundle in intents. For Fragment - Activity or Fragment - Fragment communication an interface is the recommended way. Passing bundles to fragment is achieved in two ways.

1. First fragment.setArguments(bundle); then commit the fragmenttransaction

2. Second way is by defining a static newInstance() method.

   public class FiveFragment extends Fragment {
   
   public FiveFragment() {
   }
   
   // for id
   public static FiveFragment newInstance(Bundle bundle) {
       FiveFragment myFragment = new FiveFragment();
       myFragment.setArguments(bundle);
       return myFragment;
   }
   
   @Override
   public View onCreateView(LayoutInflater inflater, ViewGroup container,
           Bundle savedInstanceState) {
       // TODO Auto-generated method stub
       View view = inflater.inflate(R.layout.fragment_five, container, false);
       return view;
   }
   
   @Override
   public void onStart() {
       // TODO Auto-generated method stub
       super.onStart();
   
       if (getArguments() != null) {
           // bundle arguments fetch
           }
       }
   }
   }
   

   Update:

should I create a new Bundle or pass the same one

If the data you need is already in the current bundle I don't see any need to create a new one just for passing it.

If data changes, should I only update the views or should I create a new fragment and replace the previous one.

If the data changes are not so much then updating the view is better. But if most of the data changes then instantiating a new Fragment seems logical to me.