Develop Reference

java.lang.IllegalStateException: Fragment not attached to Activity in Android

I am working on an application in which I have multiple Fragments inside my Activity but the problem is that sometimes on "BackPress" my application got crashed and it shows me error i.e. "java.lang.IllegalStateException: Fragment not attached to Activity in Android" . And my logcat redirect me to Toast i.e.
Code
catch (Exception e) {
Toast.makeText(getActivity(), R.string.some_error_occured, Toast.LENGTH_LONG).show();
e.printStackTrace();
}
Have I done something wrong with Toast?

if you have a viewpager in your fragments then you need to add in your viewpager adapter.
#Override
public Parcelable saveState() {
return null;
}

Check back stack count and remove all active fragments then call parent class's onBackPressed() method.
override fun onBackPressed() {
supportFragmentManager.beginTransaction().remove(fragment)
super.onBackPressed()
}

hey check if you are attached to activity or not then make context related calls like getString which you are doing in Toast. so move your code inside
isAdded() : Return true if the fragment is currently added to its
activity.
if (isAdded()){
//your code goes here
} else {
//handle the case
}
docs

It's crashing because when you are pressing back button that time your activity is not attached to the view and if you want to show toast message then you need an instance of that activity.
Try this, to check fragment is attached to the activity
Activity activity = getActivity();
if(activity! = null && isAdded){
Toast.makeText(getActivity, "Show message", Toast.LENGTH_SHORT).show();
}

The answer is very simple.
Your fragment is not getting proper context refrence you should do like this it will never force stop.
Take reference of your activity in which fragments are integrated.
For example, your fragment is lying under MainActivity so you should code like this
MainActivity mainactivity;
#Override
public void onCreate(Bundle bundle) {
super.onCreate(bundle);
// use this mainactivity object instead of getActivity() or getContext() or requireContext() or requireActivity()
mainactivity = (MainActivity) getActivity();
}
#D Developer
I guarantee, your app will work smoothly without any single error.

Fragment activity communication by passing Context object to onAttach()

Im trying to implement fragment to activity communication.
Went through android developer doc where an Activity object is passed to onAttach life cycle and set up the Fragment-Activity communication.
This documentation asks to pass Context object instead of Activity. I replaced all the Activity objects by Context objects in the life cycle method onAttach. But it is throwing a NullPointerException while calling the method of the interface from Fragment.
#Override
public void onAttach(Context context) {
super.onAttach(context);
try {
colourChangerInterface = (ColourChangerInterface) context;
}
catch (Exception exp){
System.out.println("error!");
}
}
Can anyone please give a small example of the usage in the new way ?
Thanks
Edit :
Found this link where detail discussion is there on the same issue.
The issue is because of the broken API 'onAttach()'; it doesn't get called at all when Context object is passed.
A simple and quick solution found from the above link is to move the code from onAttach to onCreate.

Here is a small example that will describe you the communication between Activity and Fragment. Suppose you have a Interface ICommunication. This is given below:
public interface ICommunication {
public void testMethod();
}
Now you have a Activity name MainActivity that implements ICommunication then it must have implements the method testMethod(). This method will like this:
#Override
public void testMethod() {
Toast toast = Toast.makeText(getActivity(), "It's called from Fragment", Toast.LENGTH_SHORT).show();
}
Now, suppose this MainActivity belongs a Fragment name TestFragment . If you want to access testMethod() of MainActivity from TestFragment then you can simply call using this way :
((ICommunication)getActivity()).testMethod();
Here , TestFragment must be hold on MainActivity.
My related answer with source is here
Thats it :)

Fragment getActivity() -- avoiding NPE

I have a single Activity application with a number of Fragments (15 or so). Some of the methods in my MyActivity are required by all the Fragments, such as displaying Dialogs. So what I have in a sample call from a Fragment (and they all extend MyFragment) is something like:
getMyActivity().displayDialog(msg);
and getMyActivity is defined as in MyFragment:
MyActivity getMyActivity() {
return (MyActivity) getActivity();
}
however, sometimes getActivity() is null so I get NPEs in that case. So what I'm doing is moving those methods into MyFragment such that:
protected void displayDialog(String msg) {
if (getMyActivity() != null) {
getMyActivity().displayDialog(msg);
} else {
// what do I do here?
}
}
Does this approach make sense for the 10 or so methods I need to reference from MyActivity (and are there any pitfalls to doing so)? Also, what would I do to provide feedback in the case where getActivity() is null?
Edit: A common example of a cause for a NullPointerException would be something like a network call being dispatched by the Fragment and on completion of said network call, trying to display a Dialog when the Activity was destroyed in the meantime.

Its better to use some ParentFragment for example
public abstract class ParentFragment extends Fragment {
public Activity activity;
#Override
public void onAttach(Activity activity) {
super.onAttach(activity);
this.activity = activity;
}
}
then you must owerride all yor fragments
public class SomeFragment extends ParentFragment {}
and use there activity for
activity.displayDialog(msg);

If the return value of getActivity () == null, then the Fragment is not attached in the FragmentManager of your parent activity.
A common mistake is to hold references of those fragments as object variables in the parent activity. This results in NPEs from Fragments.
I would recomend you to check whether this is your case.
If not, then:
See whether you are removing the Fragments from FragmentManager correctly
See whether you are adding the Fragments to the Framgnetmanager the right way.
if yes, remove the object variables and add the Fragments through the FragmentManager, see: http://www.survivingwithandroid.com/2013/04/android-fragment-transaction.html
Hope this helps

Android: Is There A Way To Wait Until A Fragment Attaches To An Activity?

So Adopting The Design Pattern described here whereby a Async Task wrapped around a retained fragment via the setRetainInstance as seen described here
http://www.androiddesignpatterns.com/2013/04/retaining-objects-across-config-changes.html
Im having an issue where a task is started before the worker fragment can attach to the activity leaving the mCallBack to be null at the same time onPreExecute is called which throws a nullPointerException/
This is largely due to the fact that the async task is started via a method call (a start method which creates an instance of the inner async task) and not inside onCreate or OnActivityCreated since the task can be started again (under a new instance of it) and cannot be done so in onCreate or OnActivity created since the life cycle of these methods only call 1 time because of the setRetainInstance as far I as know.
My question is where a way to program some sort of routine whereby a wait until fragment has attached to activity routine and if so do the task that you need to do?
Many thanks.
Update1: Code Posted
This is how the worker fragment is being added. When the user presses the send feedback button. This OnClick Listener is invoked. The final if statement you see is what starts the async task. Note that this code is inside another fragment.
#Override
public void onClick(View v)
{
// TODO Auto-generated method stub
FragmentManager fm = getActivity().getSupportFragmentManager();
mThreadFragment = (ConnectToServerForResults) fm.findFragmentByTag(ConnectToServerForResults.class.getName());
if(mThreadFragment == null)
{
mThreadFragment = new ConnectToServerForResults();
fm.beginTransaction().add(mThreadFragment, ConnectToServerForResults.class.getName()).commit();
}
if(!mThreadFragment.isRunning())
{
mThreadFragment.startSendFeedBack(3, preventSQLInjections(),getResources().getString(R.string.app_name));
}
else
{
//Work in progress :D
}
}
Worker Fragment Start Task Method
public void startSendFeedBack(int requestCode,String feedback,String appName)
{
XAMPP_URL ="http://10.0.2.2/testStuff/feed.php";
http = new HTTPConnection();
http.execute(String.valueOf(requestCode),XAMPP_URL,feedback,appName);
mRunning = true;
}
Worker Fragment OnAttach
#Override
public void onAttach(Activity activity)
{
// TODO Auto-generated method stub
super.onAttach(activity);
Log.d("ERSEN", "onAttach");
if(!(activity instanceof ResultAsyncTaskCallbacks))
{
throw new IllegalStateException("activity must implement the AsyncTaskCallbacks interface.");
}
mCallback = (ResultAsyncTaskCallbacks) activity;
}

so I made a solution which solved the problems. May not be the best solution but my problems appear resolved.
I added a call back to my interface called onThreadFragmentAttached()
public static interface ResultAsyncTaskCallbacks
{
void onPreExecuteResults();
void onCancelledResults();
void onPostExecuteResults();
void onThreadFragmentAttached();
}
I added a class variable to the worker fragment
private boolean isFirstTime=true;
This Boolean at the start says that the fragment is being added for the first time
In OnActivityCreated I can safely assume that the fragment is attached because this is what that method signifies.
In there is this logic. Check if firstTime is true (yes would be if the fragment is added for the first time). If call onThreadFragmentAttached();. Set firstTime to false because the fragment is added. This false is preserved through config changes because this fragment is retained.
if(isFirstTime == true)
{
mCallback.onThreadFragmentAttached();
isFirstTime = false;
}
In main activity which implements the callbacks
#Override
public void onThreadFragmentAttached(int fragmentCode)
{
FB = (FeedBack)fragmentManger.findFragmentByTag(FeedBack.class.getName());
FB.sendFeedback();
}
Find the feedback fragment (this was my fragment which needed to start a task) and call sendFeedBack method.
This is the method which simply calls the start method.
public void sendFeedback()
{
mThreadFragment.startSendFeedBack(3, preventSQLInjections(),getResources().getString(R.string.app_name));
}
In my onClick I have the following logic
//Check if there is not a task running at the moment
if(!mThreadFragment.isRunning()) //No task
{
//if its the first time worker fragment is being added it will start the task itself via the onThreadFragmentAttached callback (inside main activity) which then calls the sendFeedBack method that starts the task
if(mThreadFragment.getIsFirstTime() != true) //this is here in cases where the thread fragment is already attached and the task can be started as normal.
{
sendFeedback();
}
}
This checks if the fragment has already been added and just to go ahead and start the task. Note the getIsFirstTime method just returns the value of the class variable isFirstTime. If its false proceed as normal because its already attached. if it was true this would be bypassed and the task would start anyway via the onThreadAttachedCallback();

Android: NullPointerException in dialog when rotating

Sorry if this been asked before but I couldn't find an answer to my specific case. Also sorry that I'm new and a little stupid.
Problem:
I'm showing a dialog from a fragment and passing along a context in my constructor method because I need a context in my dialog to register for broadcastrecievers etc.
DialogFragment fragmentDialog = MyDialog.myConstructor(getActivity());
fragmentDialog.show(getFragmentManager(), "dialog");
Then in MyDialog class I store the context in a instance variable.
The problem arises when rotating the device and I get a nullPointerException when I try to use the context again in the dialog.
Can this be solved in some easy way?

If the device is rotated the Activity will be destroyed and recreated. So the Context you passed to your Fragment points on the Activity which was destroyed.
You could use setRetainInstance(true) in your Fragment. This way your Fragment will survive the recreation of the Activity.
To solve the NPE you have to pass the Context to the Fragment, if the Activity is recreated. Then the Context belongs to the new Activity.
In fact, without this update every line of code which points on the Activity like getActivity() or getFragmentManager() will lead in a NPE.

You get the NullPointerException because activites are destroyed and recreated when rotating the screen.
The SO post below gives more info...
https://stackoverflow.com/a/1673374/

Please be careful with the order of events if you rotate a FragmentActivity, because this can also be a source of NullPointerExceptions.
This is not documentated:
When the FragmentActivity is created the first time,
public class MyActivity extends FragmentActivity implements
MyFragment.OnFragmentInteractionListener {
private int var1;
private int var2;
#Override
protected void onCreate(Bundle savedInstanceState) {
//before
var1 = 3;
super.onCreate(Bundle savedInstanceState)
//after
var2 = 5;
}
//Interface Methods
public int getVar1() { return var1; }
public int getVar2() { return var2; }
}
both of the [before] and [after] code will be run before the fragments are attached and created. So, if you get the vars in the onCreate() call of the Fragment you get both vars. But when you rotate your device, the Activity is recreated from the savedInstanceState in the super call. Now, the fragments are reattached and created anew in this call! That means, this time the Methods of the Listener Interface are called before your [after] code. So, if you pass the Context of the activity to the fragment and get Information through the Interface like it is shown in: https://developer.android.com/training/basics/fragments/communicating.html
you get a NullPointerException for var2 because the interface methods are called from the fragments onCreate() onAttach() ... functions before the [after] code in the Activity's onCreate() is executed! So, take care that you set your Information the InterfaceFunctions are accessing before the super call.

Depending on what you're doing in your initialization you could consider creating a new class that extends Application and moving your initialization code into an overwridden onCreate method within that class.
public class MyApplicationClass extends Application {
#Override
public void onCreate() {
super.onCreate();
// TODO Put your application initialization code here.
}
}
And you are not stupid, even experts need help from time to time.