Android – onAttach(Context) not called for API 23

I’ve updated the SDK to the latest version (API 23) and the onAttach(Activity) method for fragment is deprecated. So instead of using that method, now I’m using onAttach(Context) but this one is not called during the lifecycle. The activity is an instance of AppCompatActivity from v7 and the fragment is an instance of class Fragment (android.app.Fragment).

Any ideas how to get the onAttach working in API 23?

  • ActionBar Tabs - Fixed and Scrollable?
  • Android Studio import error
  • Create PhoneGap 3.0.0 project error - 'platform add android' i not a node
  • What's the correct way to implement key-value pair in Spinner in android
  • Cancel All Volley Requests Android
  • How to get Verbose logging in logcat for a specific module
  • Solution

    I found some answers that can help you to understand and fix this problem:

  • As I mentioned before I’m using the activity from support v7 (AppCompatActivity) and the fragment from android.app.
  • For showing fragments I get the fragment manager using the method getFragmentManager on the activity, so the fragment manager is an instance of FragmentManager from android.app -> and here is the problem
  • If you run the application on a device with API 23 (I’ve run it on the AS Emulator), you’ll see that the onAttach(Context) method will be called.
    During the process for showing a fragment by the FragmentManager, at a specific moment the onAttach(..) method is called. Using the getFragmentManager() you’ll get an instance of the fragment manager available for the Android version which is running on that device (for example API 22, 23). In case the application is running on a device with API < 23 the onAttach(Context) method is not available, the fragment manager doesn’t know that in API 23 there is a method onAttach(Context), so that’s why it is not called for the API < 23 -> the solution for this kind of problems is using the FragmentManager from support libraries.
  • Solutions:

    1. Using getSupportFragmentManager() will force you to use a Fragment from the support lib. So the first solution is to replace all fragments with the fragment from support lib and using getSupportFragmentManager().

    2. Solution that I’ve already implemented is to handle 2 possibilities (1. the app is running on a device with API < 23, the app is running on a device with API >= 23).

    Shortly, in my implementation I have a base class for all fragments from the project and I added this code there:

    /*
     * onAttach(Context) is not called on pre API 23 versions of Android and onAttach(Activity) is deprecated
     * Use onAttachToContext instead
     */
    @TargetApi(23)
    @Override
    public final void onAttach(Context context) {
        super.onAttach(context);
        onAttachToContext(context);
    }
    
    /*
     * Deprecated on API 23
     * Use onAttachToContext instead
     */
    @SuppressWarnings("deprecation")
    @Override
    public final void onAttach(Activity activity) {
        super.onAttach(activity);
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            onAttachToContext(activity);
        }
    }
    
    /*
     * Called when the fragment attaches to the context
     */
    protected void onAttachToContext(Context context) {
    }
    

    Now I simply override the onAttachToContext(Context) method on all fragments where I need this.

  • android - Execution failed for task ':app:compileDebugJavaWithJavac'
  • Detect wifi IP address on Android?
  • retrieve original adapter from expandablelistview with header
  • How can I Zip and Unzip a string using GZIPOutputStream that is compatible with .Net?
  • What happens if a Service is started multiple times?
  • Why would I ever want `setRetainInstance(false)`? - Or - The correct way to handle device rotation
  • 6 Solutions collect form web for “Android – onAttach(Context) not called for API 23”

    I solved the problem in this way:

    @TargetApi(23)
    @Override public void onAttach(Context context) {
        //This method avoid to call super.onAttach(context) if I'm not using api 23 or more
        //if (Build.VERSION.SDK_INT >= 23) {
            super.onAttach(context);
            onAttachToContext(context);
        //}
    }
    
    /*
     * Deprecated on API 23
     * Use onAttachToContext instead
     */
    @SuppressWarnings("deprecation")
    @Override public void onAttach(Activity activity) {
        super.onAttach(activity);
        if (Build.VERSION.SDK_INT < 23) {
            onAttachToContext(activity);
        }
    }
    
    /*
     * This method will be called from one of the two previous method
     */
    protected void onAttachToContext(Context context) {}
    

    You should try using the Support library version of Fragment.

    You need to switch to import android.support.v4.app.Fragment; instead of import android.app.Fragment;. You’ll also need to make sure you’re using getSupportFragmentManager() instead of getFragmentManager().

    pleas post about this BUG here

    ISSUE OPPENED ON GOOGLE AOSP PROJECT HOMESITE:

    https://code.google.com/p/android/issues/detail?id=185465

    ps. this is not your job to search for solution to this problem & to find any kind of workarounds .. but to force google to fix its broken API!
    to do this u need to complain as i said.

    related issue – getContext() from fragment:

    https://code.google.com/p/android/issues/detail?id=185848

    I came up with the same issue.
    I have a minSdkVersion of 19 and a targetSdkVersion of 23 and I am using fragmentManager in an AppCompatActivity.

    onAttach(Activity activity) is marked as deprecated but I ran into app crashes when I replaced it with onAttach(Context context).

    So instead, I now have both versions present and when I run my app on API22, onAttach(Activity activity) is fired, even though it is marked as deprecated.

    I have not tested it on an Android Marshmallow device, but my understanding is that it would run the onAttach(Context context) version, ignoring the other one.

    Update to take into account @skaar’s observation in the comments below:
    I could now test on API23 and can confirm that running on platform 23 causes both methods (with Activity and Context) to be called. Thanks for the heads up!

    I have encountered the same problem.
    What I have done to resolve it:

    1. Change the argument type of onAttach callback from Activity to Context.
      For unknown reason, this modification results in the fact that the
      method onAttach(Context) is not called anymore during the fragment lifecycle. As a
      consequence, my app was crashing since the code that was in onAttach
      method has never been executed.

    2. Move the code that was in onAttach method to onCreate one since it
      gets still executed.

    With this modification, the app turns to functionate as before. No additional import statements were required.

    After I read your answer @David Rauca
    I think the second one can solve my problem. But when I look into the source code. I found that actually, onAttach(Context context) do nothing on Android M, just called the old method.

    As a solution:

    @SuppressWarnings("deprecation")
    

    Just add it into the old method is the best solution.

    Android Babe is a Google Android Fan, All about Android Phones, Android Wear, Android Dev and Android Games Apps and so on.