What is the life cycle of an Android activity? Why are so many similar sounding methods (`onCreate()`, `onStart()`, `onResume()`) called during initialization, and so many others (`onPause()`, `onStop()`, `onDestroy()`) called at the end?

When are these methods called, and how should they be used properly?


Android activity life cycle - what are all these methods for?

Could you explain me the correct manner to manage the `UIViewController` lifecycle?

In particular, I would like to know how to use `Initialize`, `ViewDidLoad`, `ViewWillAppear`, `ViewDidAppear`, `ViewWillDisappear`, `ViewDidDisappear`, `ViewDidUnload` and `Dispose` methods in Mono Touch for a `UIViewController` class.

Looking to understand the iOS UIViewController lifecycle

I have a view made up of `TableLayout, TableRow and TextView`. I want it to look like a grid.  I need to get the height and width of this grid.  The methods `getHeight()` and `getWidth()` always return 0.  This happens when I format the grid dynamically and also when I use an XML version.  

How to retrieve the dimensions for a view?  

---------------------------
Here is my test program I used in Debug to check the results: 

    import android.app.Activity;
    import android.os.Bundle;
    import android.widget.TableLayout;
    import android.widget.TextView;
    
    public class appwig extends Activity {	
        @Override
        public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.maindemo);  //&lt;- includes the grid called &quot;board&quot;
          int vh = 0;	
          int vw = 0;
          
          //Test-1 used the xml layout (which is displayed on the screen):
          TableLayout tl = (TableLayout) findViewById(R.id.board);  
          tl = (TableLayout) findViewById(R.id.board);
          vh = tl.getHeight();	   //&lt;- getHeight returned 0, Why?  
          vw = tl.getWidth();     //&lt;- getWidth returned 0, Why?   
      
          //Test-2 used a simple dynamically generated view:     	
          TextView tv = new TextView(this);
          tv.setHeight(20);
          tv.setWidth(20);
          vh = tv.getHeight();	  //&lt;- getHeight returned 0, Why?      	
          vw = tv.getWidth();    //&lt;- getWidth returned 0, Why?
           
        } //eof method
    } //eof class


How to retrieve the dimensions of a view?

It looks like `componentWillReceiveProps` is going to be completely phased out in coming releases, in favor of a new lifecycle method `getDerivedStateFromProps`:[static getDerivedStateFromProps()][1].

Upon inspection, it looks like you are now unable to make a direct comparison between `this.props` and `nextProps`, like you can in `componentWillReceiveProps`. Is there any way around this?

Also, it now returns an object. Am I correct to assume that the return value is essentially `this.setState`?

Below is an example I found online: [State derived from props/state][2].


**Before**

    class ExampleComponent extends React.Component {
      state = {
        derivedData: computeDerivedState(this.props)
      };
    
      componentWillReceiveProps(nextProps) {
        if (this.props.someValue !== nextProps.someValue) {
          this.setState({
            derivedData: computeDerivedState(nextProps)
          });
        }
      }
    }

**After**

    class ExampleComponent extends React.Component {
      // Initialize state in constructor,
      // Or with a property initializer.
      state = {};
    
      static getDerivedStateFromProps(nextProps, prevState) {
        if (prevState.someMirroredValue !== nextProps.someValue) {
          return {
            derivedData: computeDerivedState(nextProps),
            someMirroredValue: nextProps.someValue
          };
        }
    
        // Return null to indicate no change to state.
        return null;
      }
    }


  [1]: https://reactjs.org/docs/react-component.html#static-getderivedstatefromprops
  [2]: https://github.com/reactjs/rfcs/blob/master/text/0006-static-lifecycle-methods.md#state-derived-from-propsstate

How to use lifecycle method getDerivedStateFromProps as opposed to componentWillReceiveProps

I&#39;m using a singleTop Activity to receive intents from a search-dialog via [`onNewIntent()`][1].

What I noticed is that `onPause()` is called before `onNewIntent()`, and then afterwards it calls `onResume()`.  Visually:

- search dialog initiated
- search intent fired to activity
- `onPause()`
- `onNewIntent()`
- `onResume()`

The problem is that I have listeners registered in `onResume()` that get removed in `onPause()`, but they are needed inside of the `onNewIntent()` call. Is there a standard way to make those listeners available?  


  [1]: http://developer.android.com/reference/android/app/Activity.html#onNewIntent%28android.content.Intent%29

onNewIntent() lifecycle and registered listeners

I&#39;m trying to wrap my head around scopes in Dagger 2, specifically the lifecycle of scoped graphs. How do you create a component that will be cleaned up when you leave the scope.

In the case of an Android application, using Dagger 1.x you generally have a root scope at the application level which you&#39;d extend to create a child scope at the activity level.

    public class MyActivity {

        private ObjectGraph mGraph;

        public void onCreate() {
            mGraph = ((MyApp) getApplicationContext())
                .getObjectGraph()
                .plus(new ActivityModule())
                .inject(this);
        }

        public void onDestroy() {
            mGraph = null;
        }
    }

The child scope existed as long as you kept a reference to it, which in this case was the lifecycle of your Activity. Dropping the reference in onDestroy ensured the scoped graph was free to be garbage collected.

**EDIT**

Jesse Wilson recently posted a [mea culpa](https://publicobject.com/2014/11/15/dagger-2-has-components/)

&gt; Dagger 1.0 badly screwed up its scope names ... The @Singleton annotation is used for both root graphs and custom graphs, so it&#39;s tricky to figure out what the actual scope of a thing is.

and everything else I&#39;ve read/heard points towards Dagger 2 improving the way scopes work, but I&#39;m struggling to understand the difference. According to @Kirill Boyarshinov&#39;s comment below, the lifecycle of a component or dependency is still determined, as usual, by concrete references. So is the difference between Dagger 1.x and 2.0 scopes purely a matter of semantic clarity?

## My understanding

### Dagger 1.x

Dependencies were either `@Singleton` or not. This was equally true of dependencies in the root graph and subgraphs, leading to ambiguity as to which graph the dependency was bound to (see https://stackoverflow.com/questions/25953525/in-dagger-are-singletons-within-the-sub-graph-cached-or-will-they-always-be-recr)

### Dagger 2.0

Custom scopes allow you to create semantically clear scopes, but are functionally equivalent to applying `@Singleton` in Dagger 1.x.

    // Application level
    @Singleton
    @Component( modules = MyAppModule.class )
    public interface MyAppComponent {
        void inject(Application app);
    }

    @Module
    public class MyAppModule {

        @Singleton @Named(&quot;SingletonScope&quot;) @Provides
        StringBuilder provideStringBuilderSingletonScope() {
            return new StringBuilder(&quot;App&quot;);
        }
    }

---

    // Our custom scope
    @Scope public @interface PerActivity {}

---

    // Activity level
    @PerActivty
    @Component(
        dependencies = MyAppComponent.class,
        modules = MyActivityModule.class
    )
    public interface MyActivityComponent {
        void inject(Activity activity);
    }

    @Module
    public class MyActivityModule {

        @PerActivity @Named(&quot;ActivityScope&quot;) @Provides
        StringBuilder provideStringBuilderActivityScope() {
            return new StringBuilder(&quot;Activity&quot;);
        }

        @Name(&quot;Unscoped&quot;) @Provides
        StringBuilder provideStringBuilderUnscoped() {
            return new StringBuilder(&quot;Unscoped&quot;);
        }
    }

---

    // Finally, a sample Activity which gets injected
    public class MyActivity {

        private MyActivityComponent component;

        @Inject @Named(&quot;AppScope&quot;)
        StringBuilder appScope

        @Inject @Named(&quot;ActivityScope&quot;)
        StringBuilder activityScope1

        @Inject @Named(&quot;ActivityScope&quot;)
        StringBuilder activityScope2

        @Inject @Named(&quot;Unscoped&quot;)
        StringBuilder unscoped1

        @Inject @Named(&quot;Unscoped&quot;)
        StringBuilder unscoped2

        public void onCreate() {
            component = Dagger_MyActivityComponent.builder()
                .myApplicationComponent(App.getComponent())
                .build()
                .inject(this);

            appScope.append(&quot; &gt; Activity&quot;)
            appScope.build() // output matches &quot;App (&gt; Activity)+&quot; 

            activityScope1.append(&quot;123&quot;)
            activityScope1.build() // output: &quot;Activity123&quot;

            activityScope2.append(&quot;456&quot;)
            activityScope1.build() // output: &quot;Activity123456&quot;

            unscoped1.append(&quot;123&quot;)
            unscoped1.build() // output: &quot;Unscoped123&quot;

            unscoped2.append(&quot;456&quot;)
            unscoped2.build() // output: &quot;Unscoped456&quot;

        }

        public void onDestroy() {
            component = null;
        }

    }

The takeaway being that using `@PerActivity` communicates your *intention* regarding the lifecycle of this component, but ultimately you can use the component anywhere/anytime. Dagger&#39;s only promise is that, for a given component, scope annotated methods will return a single instance. I also assume Dagger 2 uses the scope annotation on the component to verify that modules only provide dependencies that are either in the same scope or non-scoped.

### In Summary

Dependencies are still either singleton or non-singleton, but `@Singleton` is now intended for application-level singleton instances and custom scopes are the preferred method for annotating singleton dependencies with a shorter lifecycle.

The developer is responsible for managing the lifecycle of components/dependencies by dropping references that are no longer needed and responsible for ensuring that components are only created once in the scope for which they are intended, but custom scope annotations make it easier to identify that scope.

## The $64k Question*

Is my understanding of Dagger 2 scopes and lifecycles correct?

*\* Not actually a $64&#39;000 question.*

What determines the lifecycle of a component (object graph) in Dagger 2?

I want to know if user would return to the home screen if he exit the current activity.

How to check if an activity is the last one in the activity stack for an application?

I am using the following method to switch between Fragments (in my NavigationDrawer) by showing / hiding them.

    protected void showFragment(int container, Fragment fragment, String tag, String lastTag, boolean addToBackStack ) {
    
            FragmentManager fragmentManager = getSupportFragmentManager();
            FragmentTransaction transaction = fragmentManager.beginTransaction();
    
            if ( lastTag != null &amp;&amp; !lastTag.equals(&quot;&quot;)) {
                Fragment lastFragment = fragmentManager.findFragmentByTag( lastTag );
                if ( lastFragment != null ) {
                    transaction.hide( lastFragment );
                }
            }
    
            if ( fragment.isAdded() ) {
                transaction.show( fragment );
            }
            else {
                transaction.add( container, fragment, tag );
            }
    
            if ( addToBackStack ) {
                transaction.addToBackStack( tag );
            }
    
            transaction.commit();
            
            // set the active tag
            activeFragTag = tag;
    	}

**What I am unclear about is which method of the Fragments lifecycle is called when I show or hide it?** (since there is no method such as onShow() or onHide() im not quite sure what to use). I want to perform specific actions upon showing and hiding a certain Fragment.

Fragment lifecycle - which method is called upon show / hide?

I spent 4 full days trying everything I can to figure out the memory leak in an app I&#39;m developing, but things stopped making sense a long time ago.

The app I&#39;m developing is of social nature, so think profile Activities (P) and list Activities with data - for example badges (B). You can hop from profile to a badge list to other profiles, to other lists, etc.

So imagine a flow like this P1 -&gt; B1 -&gt; P2 -&gt; B2 -&gt; P3 -&gt; B3, etc. For consistency, I&#39;m loading profiles and badges of the same user, so each P page is the same and so is each B page.

The general gist of the problem is: after navigating for a bit, depending on the size of each page, I get an out-of-memory exception in random places - Bitmaps, Strings, etc - it doesn&#39;t seem to be consistent.

After doing everything imaginable to figure out why I am running out of memory, I have come up with nothing. What I don&#39;t understand is why Android isn&#39;t killing P1, B1, etc if it runs out of memory upon loading and instead crashes. I would expect these earlier activities to die and be resurrected if I ever Back to them via onCreate() and onRestoreInstanceState().

Let alone this - even if I do P1 -&gt; B1 -&gt; Back -&gt; B1 -&gt; Back -&gt; B1, I still get a crash. This indicates some sort of a memory leak, yet even after dumping hprof and using MAT and JProfiler, I can&#39;t pinpoint it.

I&#39;ve disabled loading of images from the web (and increased the test data loaded to make up for it and make the test fair) and made sure the image cache uses SoftReferences. Android actually tries to free up the few SoftReferences it has, but right before it crashes out of memory.

Badge pages get data from the web, load it into an array of EntityData from a BaseAdapter and feed it to a ListView (I&#39;m actually using CommonsWare&#39;s [excellent MergeAdapter][1], but in this Badge activity, there is really only 1 adapter anyway, but I wanted to mention this fact either way).

I&#39;ve gone through the code and was not able to find anything that would leak. I cleared and nulled everything I could find and even System.gc() left and right but still the app crashes.

**I still don&#39;t understand why inactive activities that are on the stack don&#39;t get reaped, and I&#39;d really love to figure that out.** 

At this point, I&#39;m looking for any hints, advice, solutions... anything that could help.

Thank you.

  [1]: https://github.com/commonsguy/cwac-merge

Android app out of memory issues - tried everything and still at a loss

Can anyone explain what is the life cycle process of iPhone? i.e from the start to end of the application life cycle.

What is the Life Cycle of an iPhone application?

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?

We all know about the Android [Activity&#39;s life cycle][1] and [Fragment&#39;s life cycle][2]s. But is there anything equivalent for views ?

This could help, for instance, building custom views or give an in-depth look at a very common and often hidden graphic operation on Android.

Thanks in advance !


  [1]: http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle
  [2]: http://developer.android.com/guide/components/fragments.html#Lifecycle

Is there any graphical representation of Android views lifecycle (a state diagram)?

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

is there any way to know the state of my application if it is in background mode or in foreground . Thanks 

Detect if the application in background or foreground in swift

Is there any lifecycle hook like window.onbeforeunload in Angular2?
I already googled and searched on stackoverflow, but found nothing

Is there any lifecycle hook like window.onbeforeunload in Angular2?

The android app I am working on overrides the Application class to store lightweight state (username, gps location, etc) in static vars.  Most of this state is set in OnCreate of the launch activity (username retrieved from prefs, location listener runs).  Is it safe to rely on the launch activity to initialize the Application class?  Are there any cases where the Application class might be re-created without the Launch activity also being created?  

The question comes up because I ran into a null pointer exception accessing a variable in the Application class on resuming the app after the phone was asleep for several hours (the app was left in the foreground before phone went to sleep).  Is it possible that the process was killed while the phone was asleep and on waking the phone, the Application class was re-created, the top activity in the stack was resumed, but the launch activity.onCreate wasn&#39;t run thus the Application class wasn&#39;t initialized?

Note that I have tried to test these kinds of scenarios by Forcing the App to stop using Settings / Manage applications.  However, I&#39;m not able to recreate the problem.  On the next run, the Application class is created,  followed by the launch activity.onCreate.


**Is it safe to assume that the Application class instance will exist as long as the process, and that when the Application class is created it is equivalent to &quot;restarting&quot; the application ie. start with a new activity stack (and first activity on stack is the launch activity)?**

Android Application Class Lifecycle

I am a newbie to React.js and I am trying hard to understand several methods in the React lifecycle methods.

So far, I have something that confuses me:

1) 

As far as I understand, the difference between `componentWillUpdate` and `componentWillReceiveProps`
is that `componentWillReceiveProps` will be called when the parent changes the props and we can use setState (setState of this child inside `componentWillReceiveProps`).

for example: [react-table-sorter-demo][1]


    var App = React.createClass({
      getInitialState: function() {
        return {source: {limit: &quot;200&quot;, source: &quot;source1&quot;}};
      },
      handleSourceChange: function(source) {
        this.setState({source: source});
      },
      render: function() {
        return (
          &lt;div&gt;
            &lt;DataSourceSelectors onSourceChange={this.handleSourceChange} source={this.state.source} /&gt;
            &lt;TableSorter dataSource={urlForDataSource(this.state.source)} config={CONFIG} headerRepeat=&quot;5&quot; /&gt;
          &lt;/div&gt;
        );
      }
    });

In TableSorter, we have

    componentWillReceiveProps: function(nextProps) {
        // Load new data when the dataSource property changes.
        if (nextProps.dataSource != this.props.dataSource) {
          this.loadData(nextProps.dataSource);
        }
      }


meaning when we change `this.state.source`, we will expect `componentWillReceiveProps` to be called in TableSorter.
    
However, I don&#39;t quite understand how to use `componentWillUpdate` in this case, the definition of `componentWillUpdate` is 

    componentWillUpdate(object nextProps, object nextState)

How can we pass nextState from parent into child? Or maybe I am wrong, is the nextState passed from the parent element?


2)
method `componentWillMount` confuses me because in the official documentation, it says that 

&gt; Invoked once, both on the client and server, immediately before the
&gt; initial rendering occurs.

In this case, if I use setState in this method, it will override the getInitialState since it will be called once only initially. In this case, what is the reason to set the parameters in the getInitialState method. In this particular case, we have: 

      getInitialState: function() {
        return {
          items: this.props.initialItems || [],
          sort: this.props.config.sort || { column: &quot;&quot;, order: &quot;&quot; },
          columns: this.props.config.columns
        };
      },
      componentWillMount: function() {
        this.loadData(this.props.dataSource);
      },
      loadData: function(dataSource) {
        if (!dataSource) return;

        $.get(dataSource).done(function(data) {
          console.log(&quot;Received data&quot;);
         this.setState({items: data});
         }.bind(this)).fail(function(error, a, b) {
          console.log(&quot;Error loading JSON&quot;);
         });
      },

items will be overriddene initially and why do we still need 
`items: this.props.initialItems || []` in the getInitialState method?

Hope you can understand my explanation, and please give me some hints if you have any. 


  [1]: https://github.com/bgerm/react-table-sorter-demo/blob/master/jsx/app.jsx

react lifecycle methods understanding

This is a very basic question, but I&#39;m struggling a bit and would like to make sure I understand properly.

After a container is started from an image and some changes done to files within (i.e.: some data stored in the DB of a WebApp running on the container), what&#39;s the appropriate way to continue working with the same data between container stop and restart?

Is my understanding correct that once the container is stopped/finished (i.e.: exit after an interactive session), then that container is gone together with all file changes?
So if I want to keep some file changes I have to commit the state of the container into a new image / new version of the image?

Do docker containers retain file changes?

I understand that when the orientation of the screen changes, the current activities onDestroy() is called followed by the onCreate() to effectively recreate the activity.
I need to know how to programmatically tell if the application is being exited or if just the orientation is being changed.

One method is for the previous activity to notify me when its onResume() method is being called, this will let me know that the user has pressed the back button and the orientation hasn&#39;t been changed.

P.S. I&#39;m looking for a solution more elegant than listening for a back hardware button click.

Here was what i wanted to do:

I have two tabs, when the activity is being entered for the first time or the user has left the activity and is now entering it, a certain tab is displayed based on some criterion.

When the orientation changes, i need to stay on the same tab.


How to distinguish between orientation change and leaving application android

How can I test all of the following methods code? I want to play scenarios when all of them are happening to see if my code works for save/restore process of an activity. So what should I do in the Emulator to get all methods tested?

    public class Activity extends ApplicationContext {
         protected void onCreate(Bundle savedInstanceState);
    
         protected void onStart();

         protected void onRestoreInstanceState(Bundle savedInstanceState);

         protected void onSaveInstanceState(Bundle savedInstanceState);
         
         protected void onRestart();
    
         protected void onResume();
    
         protected void onPause();
    
         protected void onStop();
    
         protected void onDestroy();
     }

How to test code built to save/restore Lifecycle of an Activity?

**Angular 5**

When is a service created and destroyed, what are its lifecycle hooks (if any) and how is its data shared between components?

**EDIT**: To clarify, this is **NOT** a question about the lifecycle of components. This question is about the lifecycle of services. In case a service does not have a lifecycle, how is the flow of data between components and services managed?

All Lifecycle Solutions on Gang of Coders

Total of 21 Lifecycle Solutions