I have a fragment which contains a ViewPager.  The ViewPager is associated with an adapter that contains a set of fragments.

Upon loading the parent fragment, I am met with an `IllegalStateException` with the message: `java.lang.IllegalStateException: Recursive entry to executePendingTransactions`.

Some research has led me to the conclusion that the system is unable display fragments within another fragment, HOWEVER there seems to be some indication that it is possible to do exactly this with the use of a ViewPager ([A bug in ViewPager using it with other fragment][1]).

In fact, if I add a button to my parent fragment which calls `mPager.setAdapter(mAdapter)` on my ViewPager when pressed, the ViewPager successfully loads.  This is not ideal.

The issue then must be related to the fragment lifecycle.  My question therefore, is this:
Has anybody else found a way around this issue, and if so, how?

Is there some way to delay settings the adapter on the ViewPager until after the fragment transaction?

Here is my parent fragment code:

    	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
		
		mView = inflater.inflate(R.layout.team_card_master, container, false);
		mViewPager = (ViewPager)mView.findViewById(R.id.team_card_master_view_pager);
		
		final Button button = (Button)mView.findViewById(R.id.load_viewpager_button);
		button.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				mViewPager.setAdapter(mAdapter);
				button.setVisibility(View.GONE);
			}
		});
		
		mAdapter = new ViewPagerAdapter(getFragmentManager());
     //		mViewPager.setAdapter(mAdapter);
		
		return mView;
	}


And the adapter:

	public class ViewPagerAdapter extends FragmentPagerAdapter {
		public ViewPagerAdapter(FragmentManager fm) {
			super(fm);
		}
		
		@Override
		public int getCount() {
			if (mCursor == null) return 0;
			else return mCursor.getCount();
		}
		
		@Override
		public Fragment getItem(int position) {
			Bundle b = createBundle(position, mCursor);
			return TeamCardFragment.newInstance(b);
		}
	}

  [1]: https://stackoverflow.com/questions/7241153/a-bug-in-viewpager-using-it-with-other-fragment/7654881#7654881

Display fragment viewpager within a fragment

I have a ViewModel class just like the one defined in the **Connecting ViewModel and repository** section of [Architecture guide][1]. When I run my app I get a runtime exception. Does anyone know how to get around this? Should I not be injecting the ViewModel? Is there a way to tell the `ViewModelProvider` to use Dagger to create the model?


&lt;!-- language: lang-java --&gt;

    public class DispatchActivityModel extends ViewModel {

        private final API api;

        @Inject
        public DispatchActivityModel(API api) {
            this.api = api;
        }
    }

&gt;    Caused by: java.lang.InstantiationException: java.lang.Class&lt;com.example.dispatch.DispatchActivityModel&gt; has no zero argument constructor
        at java.lang.Class.newInstance(Native Method)
        at android.arch.lifecycle.ViewModelProvider$NewInstanceFactory.create(ViewModelProvider.java:143)
        at android.arch.lifecycle.ViewModelProviders$DefaultFactory.create(ViewModelProviders.java:143)&#160;
        at android.arch.lifecycle.ViewModelProvider.get(ViewModelProvider.java:128)&#160;
        at android.arch.lifecycle.ViewModelProvider.get(ViewModelProvider.java:96)&#160;
        at com.example.base.BaseActivity.onCreate(BaseActivity.java:65)&#160;
        at com.example.dispatch.DispatchActivity.onCreate(DispatchActivity.java:53)&#160;
        at android.app.Activity.performCreate(Activity.java:6682)&#160;
        at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1118)&#160;
        at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2619)        at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2727)&#160;
        at android.app.ActivityThread.-wrap12(ActivityThread.java)&#160;
        at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1478)&#160;
        at android.os.Handler.dispatchMessage(Handler.java:102)&#160;
        at android.os.Looper.loop(Looper.java:154)&#160;
        at android.app.ActivityThread.main(ActivityThread.java:6121)

  [1]: https://developer.android.com/topic/libraries/architecture/guide.html

Android lifecycle library ViewModel using dagger 2

Google deprecate fragment’s onActivityCreated() on Android and recommend to use LifeCycleObserver:

     To get a callback specifically when a Fragment activity&#39;s
         * {@link Activity#onCreate(Bundle)} is called, register a
         * {@link androidx.lifecycle.LifecycleObserver} on the Activity&#39;s
         * {@link Lifecycle} in {@link #onAttach(Context)}, removing it when it receives the
         * {@link Lifecycle.State#CREATED} callback.


So I try to make it in recommended way, but only state I can observe in Logcat is just **State: INITIALIZED**. 

     private lateinit var lifecycleObserver: LifecycleObserver
    
     override fun onAttach(context: Context) {
        super.onAttach(context)

        hostActivity = context as HostActivity

        lifecycleObserver = object : LifecycleObserver {

            @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
            fun onCreate() {
                Logger.tag(&quot;SOME-TAG&quot;)d(&quot;State: ${lifecycle.currentState}&quot;)
                
                if(lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)) {
                    Logger.tag(&quot;SOME-TAG&quot;).d(&quot;CREATED&quot;)
                    hostActivity.lifecycle.removeObserver(lifecycleObserver)
                }
            }
        }

        hostActivity.lifecycle.addObserver(lifecycleObserver)
    }

What is wrong in code above?

**UPDATE 1**: Looks like I forgot to use hostActivity.lifecycle.currentState and checked fragment&#39;s lifecycle instead of Activities lifecycle.

**UPDATE 2**: Suggested by Google approach not worked for 
1 Host activity and 2 fragments when you click back button from one to another, cause onAttach never called, but onActivityCreated called.

onActivityCreated is deprecated, how to properly use LifecycleObserver?

I&#39;m trying to create an app that lets users log routes (locations/GPS). To ensure locations are logged even when the screen is off, I have created a `foreground service` for the location logging. I store the locations in a `Room Database` which is injected into my service using `Dagger2`.

However, this service is killed by Android which is, of course, not good. I could subscribe to low memory warnings but that doesn&#39;t solve the underlying problem of my service getting killed after ~30 minutes on a modern high-end phone running Android 8.0

I have created a minimal project with only a &quot;Hello world&quot; activity and the service: https://github.com/RandomStuffAndCode/AndroidForegroundService

The service is started in my `Application` class, and route logging is started through a `Binder`:

	// Application
	@Override
    public void onCreate() {
        super.onCreate();
        mComponent = DaggerAppComponent.builder()
                .appModule(new AppModule(this))
                .build();

        Intent startBackgroundIntent = new Intent();
        startBackgroundIntent.setClass(this, LocationService.class);
        startService(startBackgroundIntent);
    }

	// Binding activity
	bindService(new Intent(this, LocationService.class), mConnection, Context.BIND_AUTO_CREATE | Context.BIND_IMPORTANT);
	// mConnection starts the route logging through `Binder` once connected. The binder calls startForeground()

I probably don&#39;t need the `BIND_AUTO_CREATE` flag, I&#39;ve been testing different flags in an attempt to not get my service killed - no luck so far.

Using the profiler it does not seem like I have any memory leaks, memory usage is stable at ~35mb:

[![profiler][1]][1]

Using `adb shell dumpsys activity processes &gt; tmp.txt` i can confirm that `foregroundServices=true` and my service is listed 8th in the LRU list:

`Proc # 3: prcp  F/S/FGS  trm: 0 31592:com.example.foregroundserviceexample/u0a93 (fg-service)`

It seems like it is not possible to create a foreground service that you can trust to not get killed. So what can we do? Well...

1. Put the service in a separate process, in an attempt to let Android kill the UI/Activities while leaving the service alone. Would probably help, but doesn&#39;t seem like a guarantee
2. Persist *everything* in the service in e.g. a Room database. Every variable, every custom class, every time any of the changes and then start the service with `START_STICKY`. This seems kind of wasteful and doesn&#39;t lead to very beautiful code, but it would probably work... somewhat. Depending on how long it takes for Android to re-create the service after killing it, a large portion of locations may be lost.

Is this really the current state of doing stuff in the background on Android? Isn&#39;t there a better way?

EDIT: Whitelisting the app for battery optimization (disabling it) does not stop my service from being killed

EDIT: Using `Context.startForegroundService()` to start the service does not improve the situation

EDIT: So this indeed only occurs on *some* devices, but it occurs consistently on them. I guess you have to make a choice of either not supporting a huge number of users or write really ugly code. Awesome.


  [1]: https://i.stack.imgur.com/R5QGQ.png

Minimal android foreground service killed on high-end phone

All activities in my application require a user to be logged-in to view. Users can log out from almost any activity. This is a requirement of the application. At any point if the user logs-out, I want to send the user to the Login `Activity`. At this point I want this activity to be at the bottom of the history stack so that pressing the &quot;back&quot; button returns the user to Android&#39;s home screen.

I&#39;ve seen this question asked a few different places, all answered with similar answers (that I outline here), but I want to pose it here to collect feedback.

I&#39;ve tried opening the Login activity by setting its `Intent` flags to `FLAG_ACTIVITY_CLEAR_TOP` which seems to do as is outlined in the documentation, but does not achieve my goal of placing the Login activity at the bottom of the history stack, and preventing the user from navigating back to previously-seen logged-in activities. I also tried using `android:launchMode=&quot;singleTop&quot;` for the Login activity in the manifest, but this does not accomplish my goal either (and seems to have no effect anyway).

I believe I need to either clear the history stack, or finish all previously- opened activities.

One option is to have each activity&#39;s `onCreate` check logged-in status, and `finish()` if not logged-in. I do not like this option, as the back button will still be available for use, navigating back as activities close themselves.

The next option is to maintain a `LinkedList` of references to all open activities that is statically accessible from everywhere (perhaps using weak references). On logout I will access this list and iterate over all previously-opened activities, invoking `finish()` on each one. I&#39;ll probably begin implementing this method soon.

I&#39;d rather use some `Intent` flag trickery to accomplish this, however. I&#39;d be beyond happy to find that I can fulfill my application&#39;s requirements without having to use either of the two methods that I&#39;ve outlined above.

Is there a way to accomplish this by using `Intent` or manifest settings, or is my second option, maintaining a `LinkedList` of opened activities the best option? Or is there another option that I&#39;m completely overlooking?

On logout, clear Activity history stack, preventing &quot;back&quot; button from opening logged-in-only Activities

Hopefully someone can help me figure out, if not a solution, at least an explanation for a behaviour.

**The Problem:**

*On some devices, pressing the launcher icon results in the current task being resumed, on others it results in the initial launch intent being fired (effectively restarting the app). Why does this happen?* 

**The Detail:**

When you press the &quot;Launcher Icon&quot; the app starts normally - That is, I assume, an Intent is launched with the name of your first `Activity` with the action `android.intent.action.MAIN` and the category `android.intent.category.LAUNCHER`. This can&#39;t always be the case however:

On the majority of devices, if you press the launcher icon after the app is already running, the currently running Activity in that process is resumed (**NOT** the initial `Activity`). It resumes in the same way as if you had selected it from the &quot;Recent Tasks&quot; in the OS menu. This is the behaviour I want on *all* devices.

However, on selected other devices different behaviour occurs:

* On the Motorola Xoom, when you press the launcher icon, the App will *always* start the initial launch `Activity` regardless of what is currently running. I assume that the launcher icons always start the &quot;LAUNCHER&quot; intent.

* On the Samsung Tab 2, when you press the launcher icon, if you have just installed the app, it will always launch the initial `Activity` (Same as the Xoom) - however, after you restart the device after the install, the launcher icon will instead resume the app. I assume that these devices add &quot;installed apps&quot; into a lookup table on device startup which allow the launcher icons to correctly resume running tasks?

I&#39;ve read many answer that *sound* similar to my problem  but simply adding `android:alwaysRetainTaskState=&quot;true&quot;` or using `launchMode=&quot;singleTop&quot;` to the `Activity` are not the answer.

**Edit:**

After the most recent launch of this app, we find that this behaviour has begun to occur on *all* devices after the first restart. Which seems crazy to me but looking through the restart process, I can&#39;t actually find what&#39;s going wrong.

App restarts rather than resumes

I have just started using android development and trying to use Room library. Since yesterday I am facing this warning message

&gt; w: [kapt] Incremental annotation processing requested, but support is
&gt; disabled because the following processors are not incremental:
&gt; androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL),
&gt; androidx.room.RoomProcessor (NON_INCREMENTAL).

I have tried to research and fix but unable to avoid this error here is my grale.build file. please suggest/advice what I am doing wrong.

    apply plugin: &#39;com.android.application&#39;
    
    apply plugin: &#39;kotlin-android&#39;
    
    apply plugin: &#39;kotlin-android-extensions&#39;
    
    apply plugin: &#39;kotlin-kapt&#39;
    
    android {
        compileSdkVersion 29
        buildToolsVersion &quot;29.0.2&quot;
        defaultConfig {
            applicationId &quot;ps.room.bookkeeper&quot;
            minSdkVersion 15
            targetSdkVersion 29
            versionCode 1
            versionName &quot;1.0&quot;
            testInstrumentationRunner &quot;androidx.test.runner.AndroidJUnitRunner&quot;
            javaCompileOptions {
                annotationProcessorOptions {
                    arguments = [&quot;room.schemaLocation&quot;:&quot;$projectDir/schemas&quot;.toString()]
                }
            }    
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile(&#39;proguard-android-optimize.txt&#39;), &#39;proguard-rules.pro&#39;
            }
        }
    }
    
    dependencies {
        implementation fileTree(dir: &#39;libs&#39;, include: [&#39;*.jar&#39;])
        implementation &quot;org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version&quot;
        implementation &#39;androidx.appcompat:appcompat:1.0.2&#39;
        implementation &#39;androidx.core:core-ktx:1.0.2&#39;
        implementation &#39;androidx.constraintlayout:constraintlayout:1.1.3&#39;
        implementation &#39;com.google.android.material:material:1.0.0&#39;
        testImplementation &#39;junit:junit:4.12&#39;
        androidTestImplementation &#39;androidx.test:runner:1.2.0&#39;
        androidTestImplementation &#39;androidx.test.espresso:espresso-core:3.2.0&#39;
    
        // life cycle dependencies
        def lifecycle_version = &quot;2.0.0&quot;
        implementation &quot;android.arch.lifecycle:extensions:$lifecycle_version&quot;
        kapt &quot;android.arch.lifecycle:compiler:$lifecycle_version&quot;
    
        //Room dependencies
        //def room_version = &quot;2.1.0&quot;
        implementation &#39;android.arch.persistence.room:runtime:2.1.0&#39;
        kapt &#39;android.arch.persistence.room:compiler:2.1.0&#39;
        //annotationProcessor &#39;android.arch.persistence.room:compiler:2.1.0&#39;
    
    //    implementation &quot;android.arch.lifecycle:extensions:$room_version&quot;
    //    kapt &quot;android.arch.persistence.room:compiler:$room_version&quot;
    //    androidTestImplementation &quot;android.arch.persistence.room:testing:$room_version&quot;
    
        //implementation &#39;androidx.room:room-runtime:2.1.0&#39;
        //annotationProcessor &#39;androidx.room:room-compiler:2.1.0&#39;
    }




How to get rid of Incremental annotation processing requested warning?

I am rarely getting this error while making an API call.

    java.lang.IllegalStateException: Fragment  not attached to Activity

I tried putting the code inside `isAdded()` method to check whether  fragment is currently added to its activity but still i rarely gets this error. I fail to understand why I am still getting this error. How can i prevent it?

Its showing error on the line-

    cameraInfo.setId(getResources().getString(R.string.camera_id));
Below is the sample api call that i am making.     
 

    SAPI.getInfo(getActivity(),
                    new APIResponseListener() {
                        @Override
                        public void onResponse(Object response) {
        
                      
                            cameraInfo = new SInfo();
                            if(isAdded()) {
                                cameraInfo.setId(getResources().getString(R.string.camera_id));
                                cameraInfo.setName(getResources().getString(R.string.camera_name));
                                cameraInfo.setColor(getResources().getString(R.string.camera_color));
                                cameraInfo.setEnabled(true);
                            }
        
                         
                        }
        
                        @Override
                        public void onError(VolleyError error) {
                            mProgressDialog.setVisibility(View.GONE);
                            if (error instanceof NoConnectionError) {
                                String errormsg = getResources().getString(R.string.no_internet_error_msg);
                                Toast.makeText(getActivity(), errormsg, Toast.LENGTH_LONG).show();
                            }
                        }
                    });


java.lang.IllegalStateException: Fragment not attached to Activity

From android doc here http://developer.android.com/reference/android/app/Activity.html,
it said &#39;Activity comes into foreground&#39; will call `onPause()`, and &#39;Activity is no longer visible&#39; will call `onStop()`.

Isn&#39;t &#39;Activity comes into foreground&#39; same as &#39;Activity is no longer visible&#39;?
Can you please tell me what is the difference between them?



What is the difference between onPause() and onStop() of Android Activites?

The app I&#39;m currently building has the requirement that the app has to prevent the OS to take a screenshot of the app when it&#39;s being pushed into the background for security reasons. This way it won&#39;t be able to see the last active screen when switching between apps.

I&#39;m planning to put this functionality in the application class&#39;s onPause method, but first I need to find out how I can achieve this functionality.

So is there anybody out there, that has a clue how to fix this? 

How do I prevent Android taking a screenshot when my app goes to the background?

I am thinking of implementing one screen with `Activity` and all other sreens with `Fragments` and `managing all the fragments thru the activity`.

**Is it a good idea?** and my answer is **NO** but still I want to know more clearly about this thought.

**What are the pros and cons of the idea?**

**Note:**

Please don&#39;t give me the link for fragment and activity.

**EDIT:**

Here is something over Fragments and activity:

**Pros:**

1. Fragments are meant to be used with activities as a sub activity.
2. Fragments are not the replacement for activities.
3. Fragments are meant for reusability(Need to know in what way reusability can be achieved.).
4. Fragments are the best way to write code to support both tablets and phones.


**Cons:**

1. We need to implement the interface to get the data from fragments.
2. For dialog we have to go a long way to show it.

**Why should we use fragments if we are not considering tablets?
What is the starting time difference between activity and fragment?**

One Activity and all other Fragments

In an Android application, how do you start a new activity (GUI) when a button in another activity is clicked, and how do you pass data between these two activities?

How to start new activity on button click

The following figure (from [the official doc][1]) describes the well-known __lifecycle__ of an Android activity:

![enter image description here][2]

On the other hand, when the activity is destroyed by the system (for example because memory needs to be reclaimed), the state of the activity is sometimes automatically __saved and restored__ by means of the methods `onSaveInstanceState()` and `onRestoreInstanceState()`, as illustrated by the following figure (also from [the official doc][3]):

![enter image description here][4]

I&#39;m aware that `onSaveInstanceState()` is [not always called][5] when an activity is about to be destroyed. For example, if it is destroyed because the user has pressed the &quot;back&quot; button, the activity state is not preserved. But in the cases when the state _is_ saved and restored, and `onSaveInstanceState()` / `onRestoreInstanceState()` get called, __when exactly are they called__?

For example, according to the above figures, `onRestoreInstanceState()` might be called before `onStart()`,  or after `onStart()` but before `onResume()`, or after `onResume()`. Similarly, several possibilities exist for `onSaveInstanceState()`. So when are they called exactly?

Ideally, what I would like is to see a __combined diagram showing the activity lifecycle states and the save/restore methods__, if that exists.


  [1]: http://developer.android.com/training/basics/activity-lifecycle/starting.html
  [2]: http://i.stack.imgur.com/kChdb.png
  [3]: http://developer.android.com/training/basics/activity-lifecycle/recreating.html
  [4]: http://i.stack.imgur.com/RcBiQ.png
  [5]: http://developer.android.com/training/basics/activity-lifecycle/recreating.html

When exactly are onSaveInstanceState() and onRestoreInstanceState() called?

I am creating event search application, we set search criteria from one screen populate in another screen then user can edit search criteria from 3rd screen and goes to 4th screen.

To achieve above task i am using static object which remember the values around the application and i don&#39;t need to do any thing extra.

But i am afraid if about static object life cycle in android if low memory found android delete static objects ???

As android supports multi tasking, if user switches to another application and when user comes back application start acting crazy, does static object get removed when it multi task ??? any idea ?? and also suggest holding static object via singleton method is better approach ???

Android static object lifecycle

When developing for `Android`, you can set your target (or minimum) sdk to 4 (API 1.6) and add the android compatibility package (v4) to add support for `Fragments`. Yesterday I did this and successfully implemented `Fragments` to visualize data from a custom class. 

My question is this: what is the benefit for using `Fragments` as opposed to simply getting a View from a custom object, and still supporting API 1.5?

For example, say I have the class Foo.java:

    public class Foo extends Fragment {

        /** Title of the Foo object*/
        private String title;
        /** A description of Foo */
        private String message;

        /** Create a new Foo
         * @param title
         * @param message */
        public Foo(String title, String message) {
            this.title = title;
            this.message = message;
        }//Foo

        /** Retrieves the View to display (supports API 1.5. To use,
         * remove &#39;extends Fragment&#39; from the class statement, along with
         * the method {@link #onCreateView(LayoutInflater, ViewGroup, Bundle)}) 
         * @param context Used for retrieving the inflater */
        public View getView(Context context) {
            LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            View v = inflater.inflate(R.layout.foo, null);
            TextView t = (TextView) v.findViewById(R.id.title);
            t.setText(this.title);
            TextView m = (TextView) v.findViewById(R.id.message);
            m.setText(this.message);
            return v;
        }//getView 

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            if (container == null) {
                return null;
            }
            View v = inflater.inflate(R.layout.foo, null);
            TextView t = (TextView) v.findViewById(R.id.title);
            t.setText(this.title);
            TextView m = (TextView) v.findViewById(R.id.message);
            m.setText(this.message);
            return v;
        }//onCreateView
        
    }//Foo

Both methods are very simple to create and to work with in an Activity that, say, has a `List&lt;Foo&gt;` to display (for example, programmatically adding each to a `ScrollView`), so are `Fragments` really all that useful, or are they just an over-glorified simplification of getting a View, such as through the code above?


What is the benefit of using Fragments in Android, rather than Views?

I was just going through the Android Developer Site, refreshing on the Activity Life cycle, and in each code example, there is a comment beside the super class methods that says &quot;Always call the superclass method first&quot;. 

Though this makes sense in the creation half cycle: onCreate, onStart and onResume, I&#39;m a little confused as to what is the correct procedure on the destruction half cycle : onPause,onStop,onDestroy.

Destroying the instance specific resources first, before destroying superclass resources that the instance specific resources may depend upon makes sense, not the other way round.But the comments suggest otherwise. What am I missing? 

**Edit**: Since people seem to be getting confused as to the intent in the question, what I want to know is which of the following is correct? **AND WHY ?**

**1.Google suggests**

        @Override
        protected void onStop() {
          super.onStop();  // Always call the superclass method first
          
          //my implementation here
        }

**2.The other way**

        @Override
        protected void onStop() {
           //my implementation here

           super.onStop();  
        }


What is the correct order of calling superclass methods in onPause, onStop and onDestroy methods? and Why?

Can anyone give me an example that uses `onResume()` in Android?

Also, if I want to restart the activity at the end of the execution of another, which method is executed—`onCreate()` or `onResume()`?

And if I want to update data, how do I put it in `onResume()?`

How to use onResume()?

    FATAL EXCEPTION: main
    Process: com.example.loan, PID: 24169
    java.lang.IllegalStateException: Fragment already added: FormFragment{428f10c8 #1 id=0x7f050055 form}
    	at android.support.v4.app.FragmentManagerImpl.addFragment(FragmentManager.java:1192)
    	at android.support.v4.app.BackStackRecord.popFromBackStack(BackStackRecord.java:722)
    	at android.support.v4.app.FragmentManagerImpl.popBackStackState(FragmentManager.java:1533)
    	at android.support.v4.app.FragmentManagerImpl$2.run(FragmentManager.java:489)
    	at android.support.v4.app.FragmentManagerImpl.execPendingActions(FragmentManager.java:1484)
    	at android.support.v4.app.FragmentManagerImpl$1.run(FragmentManager.java:450)
    	at android.os.Handler.handleCallback(Handler.java:733)
    	at android.os.Handler.dispatchMessage(Handler.java:95)
    	at android.os.Looper.loop(Looper.java:136)
    	at android.app.ActivityThread.main(ActivityThread.java:5068)
    	at java.lang.reflect.Method.invokeNative(Native Method)
    	at java.lang.reflect.Method.invoke(Method.java:515)
    	at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:792)
    	at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:608)
    	at dalvik.system.NativeStart.main(Native Method)

So, I have an android app that build with the tabhost. There are three tabs in total, in the tab2, there is a button to make the fragment transaction in tab2 (which is calling the function in the fragment activity)

    FragmentTransaction t = getSupportFragmentManager().beginTransaction();
    		t.replace(R.id.realtabcontent, mFrag);
    		t.addToBackStack(null);
    		t.commit();

There is exception if I run like this:

1. Inside the tab2, I press the button to change fragment
2. Go to other tab (eg. tab 1 or tab 3)
3. Press back button
4. Throw exception

How to fix that? Thanks for helping

IllegalStateException: Fragment already added in the tabhost fragment

I need to know when the user kills my app (Force stop). I&#39;ve been reading the android lifecycle, which has the `onStop()` and `onDestroy()` functions, these are related to each activity the user ends on my app, but not when the user forces stop or kills my app.

Is there any way to know when the user kills the app?

How to know when my app has been killed?

Here is how my app is laid out:

1. onResume() user is prompted to login
2. If user logs in, he can continue using the app
**3. If the user logs out at any time, I want to prompt login again**

How can I achieve this?

Here is my MainActivity:

    @Override
    	protected void onResume(){
    		super.onResume();
    		
    		isLoggedIn = prefs.getBoolean(&quot;isLoggedIn&quot;, false);
    		
    		if(!isLoggedIn){
    			showLoginActivity();
    		}
    	}

Here is my LoginActivity:

    @Override
    		protected void onPostExecute(JSONObject json) {
    			String authorized = &quot;200&quot;;
    			String unauthorized = &quot;401&quot;;
    			String notfound = &quot;404&quot;;
    			String status = new String();
    			
    			try {
    				// Get the messages array
    				JSONObject response = json.getJSONObject(&quot;response&quot;);
    				status = response.getString(&quot;status&quot;);
    				
    				if(status.equals(authorized)){
    					Toast.makeText(getApplicationContext(), &quot;You have been logged into the app!&quot;,Toast.LENGTH_SHORT).show();
    				    prefs.edit().putBoolean(&quot;isLoggedIn&quot;,true);
    				    
    				    setResult(RESULT_OK, getIntent());
    					finish();
    				}
    				else if (status.equals(unauthorized)){
    					Toast.makeText(getApplicationContext(), &quot;The username and password you provided are incorrect!&quot;,Toast.LENGTH_SHORT).show();
    					 prefs.edit().putBoolean(&quot;isLoggedIn&quot;,true);
    				}
    				else if(status.equals(notfound)){
    					Toast.makeText(getApplicationContext(), &quot;Not found&quot;,Toast.LENGTH_SHORT).show();
    					 prefs.edit().putBoolean(&quot;isLoggedIn&quot;,true);
    				}
    			} catch (JSONException e) {
    				System.out.println(e);
    			} catch (NullPointerException e) {
    				System.out.println(e);
    			}
    		}
    	}

After the user has successfully logged in:

    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    		if (resultCode == RESULT_OK) {
    			Toast.makeText(getApplicationContext(), &quot;BOOM SHAKA LAKA!&quot;,Toast.LENGTH_SHORT).show();
    		}
    	}

The problem is, onResume() is called before onActivityResult() so when the user has successfully logged in, my main activity does not get notified because onResume() gets called first.

Where is the best place to prompt for login?


Is onResume() called before onActivityResult()?

A snippet from the Android [Activities][1] document(scroll down to the &quot;**foreground lifetime**&quot; line) says :

&gt; An activity can frequently transition in and out of the foreground—for
&gt; example, `onPause()` is called when the device goes to sleep ***or when a
&gt; dialog appears***.

I don&#39;t quite understand this. Under what circumstances should this happen? Is `onPause()` called only if the context of the dialog in question is different from the activity on top of which the dialog is to be displayed?

EDIT: Adding code sample to illustrate my doubt in detail
---------------------------------------------------------
Going by the above-mentioned quote from document, should my activity&#39;s `onPause()` method get called when the `AlertDialog` (or just the `Dialog`) in the following code gets displayed? Should I see the &quot;onPause called&quot; log entry when the dialog is displayed?

But I don&#39;t see that happen. And it shouldn&#39;t either, if I have understood the Android life cycle correctly! So, what&#39;s the document pointing at then?

    public class LifeCycleTestActivity extends Activity {
    	
    	private static final String TAG = &quot;LifeCycleTest&quot;;
    	
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            
            Button btn = (Button) findViewById(R.id.button1);
            
            btn.setOnClickListener(new OnClickListener() {
    			
    			@Override
    			public void onClick(View v) {
    				Log.d(TAG, &quot;onClick&quot;);
    				 
    				AlertDialog dialog = new AlertDialog.Builder(LifeCycleTestActivity.this).create();
    				 dialog.setMessage(&quot;You Clicked on the button&quot;);
    				 dialog.setTitle(&quot;Dialog!&quot;);
    				 dialog.setButton(AlertDialog.BUTTON_NEUTRAL, &quot;OK&quot;, new DialogInterface.OnClickListener() {
    					
    					@Override
    					public void onClick(DialogInterface dialog, int which) {
    						dialog.dismiss();
    					}
    				});
    			     dialog.setCancelable(true);
    			     dialog.show();
    			    
    				
    				/*
    				Dialog dialog = new Dialog(LifeCycleTestActivity.this);
    				 dialog.setTitle(&quot;Dialog!&quot;);
    			     dialog.setCancelable(true);
    			     dialog.show();
    			    */
    			}
    		});        
        }
        
        @Override
        protected void onPause() {
        	Log.d(TAG, &quot;onPause() called&quot;);
        	super.onPause();
        	
        }
        
        @Override
        protected void onResume() {
        	super.onResume();
        	Log.d(TAG, &quot;onResume() called&quot;);
        }
    }

  [1]: http://developer.android.com/guide/topics/fundamentals/activities.html#Lifecycle

Android: Under what circumstances would a Dialog appearing cause onPause() to be called?

I am extending Application class to work with some global variables that need context. I know there is onCreate() method in the Application class that gets called before any other onCreate() in activities, but **I would like to know if there is onDestroy() or similar method in the Application class that could be overridden** so that I would be able to store variables in persistent memory, unregister listener and send last message to server before app process gets killed? If not, is there any other way to do that?




Android: onDestroy() or similar method in Application class

Are ViewModels independent of activity/fragment lifecycles or just their configuration changes. When will they cease to exist and the subsequent onCleared() method called. 
Can the viewModel be shared with another Activity ?

A situation:

    Activity1+viewModel1---&gt;(rotation)---&gt;Activity1+viewModel1
    ---&gt;(launch Intent)---&gt;Activity2+viewModel1

is this sharing possible and is it a good practice.




Also, since the app lifecycle callbacks, onPause-&gt;onStop-&gt;onDestroy is same for both 

1.activity rotating and 

2.when an Activity ends, 

how is a ViewModel figuring out internally the right time to call onCleared and finally end its lifecycle. 



------------------------
**Findings**:

*the ViewModel uses a holderFragment internally to hold an instance of the activity and uses the setRetainInstance method like fragments to account for configuration changes.*

[Source: **dive-inside-of-androids-viewmodel-architecture-components**][2]

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/rESXi.png
  [2]: https://android.jlelse.eu/deep-dive-inside-of-androids-viewmodel-architecture-components-e6756dc0bb11

When is the viewmodel onCleared called

I know that a fragment&#39;s view hierarchy has to be inflated in onCreateView, but what other functionality can be in onCreateView vs. what should wait for onActivityCreated? My current implementation uses separate activities for everything, and a typical activity does most of its work in its onCreate method, including inflating the view, setting the content view, initializing the various widgets with data, setting up listeners, etc.

So can this probably all be moved into onCreateView, or should some functions be put into an onActivityCreated method instead?

Android Fragment onCreateView vs. onActivityCreated

I find Fragment#setRetainInstance(true) confusing. Here is the Javadoc, extracted from the [Android Developer API][1]:

&gt;public void **setRetainInstance** (boolean retain)

&gt;Control whether a fragment instance is retained across Activity re-creation (such as from a configuration change). This can only be used with fragments not in the back stack. If set, the fragment lifecycle will be slightly different when an activity is recreated:

&gt;- onDestroy() will not be called (but onDetach() still will be, because the fragment is being detached from its current activity).
- onCreate(Bundle) will not be called since the fragment is not being re-created.
- onAttach(Activity) and onActivityCreated(Bundle) **will** still be called.

**Question: How do you as a developer use this, and why does it make things easier?**

  [1]: http://developer.android.com/reference/android/app/Fragment.html#setRetainInstance%28boolean%29

Why use Fragment#setRetainInstance(boolean)?

I&#39;m requesting images from presenter in adapter:

      @Override
      public void onBindViewHolder(SiteAdapter.ViewHolder holder, int position)
      {
        Site site = sites.get(position);
        holder.siteName.setText(site.getName());
        requestHolderLogo(holder, site.getLinks().getLogoUrl());
      }
    
      private void requestHolderLogo(final ViewHolder holder, final String logoUrl)
      {
        compositeSubscription.add(
          presenter.bitmap(logoUrl)
            .subscribe(
              bitmap -&gt; {
                holder.siteLogo.setImageBitmap(bitmap);
                holder.siteLogo.setVisibility(View.VISIBLE);
              },
              error -&gt; {
                holder.siteName.setVisibility(View.VISIBLE);
              })
        );
      }

I should unsubscribe when `ViewHolder` is re-used. It is easy.

But how stop all subscription when view is destroyed? I should also probably nullify presenter reference to avoid memory leak

What is lifecycle for RecyclerView adapter?

What are the differences between `onCreate()`, `onCreateView()`, and `onActivityCreated()` in fragments and what would they each be used for?

Difference and uses of onCreate(), onCreateView() and onActivityCreated() in fragments

Actually, I would say that both iOS `ViewControllers` and Android `Activities` have their lifecycle methods. For example an equivalent of `ViewController.viewDidLoad()` is `Activity.onCreate()` ?

Else I still need to know the equivalent of the other :

 - `OnStart()`
 - `OnRestart()`
 - `OnResume()`
 - `OnStop()`
 - `OnDestroy()`
 - `OnPause()`


What the equivalent of activity life cycle in iOS?

So I have a bit of confusion with trying to set the background drawable of a view as it is displayed. The code relies upon knowing the height of the view, so I can&#39;t call it from `onCreate()` or `onResume()`, because `getHeight()` returns 0. `onResume()` seems to be the closest I can get though. Where should I put code such as the below so that the background changes upon display to the user?

        TextView tv = (TextView)findViewById(R.id.image_test);
        LayerDrawable ld = (LayerDrawable)tv.getBackground();
        int height = tv.getHeight(); //when to call this so as not to get 0?
        int topInset = height / 2;
        ld.setLayerInset(1, 0, topInset, 0, 0);
        tv.setBackgroundDrawable(ld);



When Can I First Measure a View?

Basically, this is what I&#39;m doing

1) Set AlarmManager to execute BroadcastReceiver (BCR)

    Intent intent = new Intent(m_Context, BCR.class);  
    intent.putExtras(extras);  
    PendingIntent pendingIntent = PendingIntent.getBroadcast(m_Context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);  
    AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    am.set(AlarmManager.RTC_WAKEUP, StartTime, pendingIntent)  

2) Start MyActivity from BCR  

    @Override  
    public void onReceive(Context context, Intent intent) {  
        Intent newIntent = new Intent(context, MyActivity.class);
        newIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);  
        context.startActivity(newIntent);  
    }

3) Have MyActivity turn on the screen if its not on

    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState); 
        getWindow().addFlags(LayoutParams.FLAG_DISMISS_KEYGUARD);
        getWindow().addFlags(LayoutParams.FLAG_SHOW_WHEN_LOCKED);
        getWindow().addFlags(LayoutParams.FLAG_TURN_SCREEN_ON);
        setContentView(R.layout.myactivity);  
    } 

    @Overide  
    protected void onNewIntent(Intent intent) {  
        super.onNewIntent(intent);  
    }  

For some reason, I notice that right when MyActivity is opened, it&#39;s flow goes like:  
  
onCreate/onNewIntent -&gt; onResume -&gt; onPause -&gt; onResume

I&#39;m not sure why it does an onPause right away. I notice this only happens when the screened is being turned on by the flags. Does anyone know why this happens? Is there any way this behavior can be prevented?

All Android Lifecycle Solutions on Gang of Coders

Total of 30 Android Lifecycle Solutions