I'm new to Android development and have a question about OnAttach(Context context) method. As far as I understand you override OnAttach method in the class that you extend Fragment and what it basically does is it attaches the fragment to the Activity(Context) that gets passed as a parameter. However, in a lot of example codes I've seen on the internet, people create an interface with methods that the main Activity needs to implement and in OnAttach method, they typecast context as the interface for ex)
public class exampleFragment extends Fragment{
exampleFragmentListener activityCommander;
public interface exampleFragmentListener{
public void someMethod(String top, String bot);
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
try{
activityCommander = (exampleFragmentListener)context;
}catch(Exception e){
throw new ClassCastException(context.toString());
}
}
What I don't get is this piece of code :
activityCommander = (exampleFragmentListener)context;
What's the purpose of typecasting context as exampleFragmentListener? Why would we typecast our main activity to fragment? Why can't the main activity just implement the interface/implement interface methods? Thank you in advance.
-
i think you can refer this answer, it will solve your query stackoverflow.com/a/37031546/4980791avez raj– avez raj2017年12月20日 07:11:10 +00:00Commented Dec 20, 2017 at 7:11
4 Answers 4
When we want a fragment to communicate with an Activity we use a interface. Now suppose if there are 2 Activities which host the same Fragment, and at runtime we don't know from which activity is the fragment is currently. That is the reason we use onAttach(). The Context provided to us in the parameter is the context of the Activity which is hosting it. So once we have the casted instance, we can use that to communicate with the activity.
Here is an example of Fragment to Activity communication:
public class HeadlinesFragment extends ListFragment {
OnHeadlineSelectedListener mCallback;
// Container Activity must implement this interface
public interface OnHeadlineSelectedListener {
public void onArticleSelected(int position);
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
// This makes sure that the container activity has implemented
// the callback interface. If not, it throws an exception
try {
mCallback = (OnHeadlineSelectedListener) activity;
} catch (ClassCastException e) {
throw new ClassCastException(activity.toString()
+ " must implement OnHeadlineSelectedListener");
}
}
...
}
Now the fragment can deliver messages and commuticate to the activity by calling the onArticleSelected() method (or other methods in the interface) using the mCallback instance of the OnHeadlineSelectedListener interface. So basically it's for callbacks
The purpose of using the onAttach with the following code:
public void onAttach(Context context) {
super.onAttach(context);
try{
activityCommander = (exampleFragmentListener)context;
}catch(Exception e){
throw new ClassCastException(context.toString());
}
}
simply is to make a dead contract of Activity and Fragment. Whenever the contract is not obeyed by the Activity, both the Activity and Fragment will be dead. Both of them will die by throwing the exception.
For onAttach details, please read my previous answer: What if onAttach() is not overridden inside the fragment code?
Comments
Add This on your Fragemnt
Activity activity;
@Override
public void onAttach(@NonNull Context context) {
super.onAttach(context);
activity = context instanceof Activity ? (Activity) context : null;
}
Then change getContext() , getActivity() , requireActivity() or requireContext() with activity