Lesson 6 - Lifecycle

public class MainActivity extends AppCompatActivity {

    /*
     * This constant String will be used to store the content of the TextView used.
     */
    private static final String LIFECYCLE_CALLBACKS_TEXT_KEY = "callbacks";
    
    private TextView mLifecycleDisplay;

    // ...

    /**
     * Called when the activity is first created. This is where we should do all of our normal
     * static set up: create views, bind data to lists, etc.
     * <p>
     * Always followed by onStart().
     *
     * @param savedInstanceState The Activity's previously frozen state, if there was one.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mLifecycleDisplay = (TextView) findViewById(R.id.tv_lifecycle_events_display);

        // If savedInstanceState is not null and contains LIFECYCLE_CALLBACKS_TEXT_KEY, 
        // set that text on our TextView.
        if (savedInstanceState != null) {
            if (savedInstanceState.containsKey(LIFECYCLE_CALLBACKS_TEXT_KEY)) {
                String allSavedText = savedInstanceState.getString(LIFECYCLE_CALLBACKS_TEXT_KEY);
                mLifecycleDisplay.setText(allSavedText);
            }
        }
    }

    /**
     * Called when the activity is becoming visible to the user.
     * <p>
     * Followed by onResume() if the activity comes to the foreground, or onStop() if it becomes
     * hidden.
     */
    @Override
    protected void onStart() {
        super.onStart();
    }

    /**
     * Called when the activity will start interacting with the user. At this point our activity
     * is at the top of the activity stack, with user input going to it.
     * <p>
     * Always followed by onPause().
     */
    @Override
    protected void onResume() {
        super.onResume();
    }

    /**
     * Called when the system is about to start resuming a previous activity. This is typically
     * used to commit unsaved changes to persistent data, stop animations and other things that may
     * be consuming CPU, etc. Implementations of this method must be very quick because the next
     * activity will not be resumed until this method returns.
     * <p>
     * Followed by either onResume() if the activity returns back to the front, or onStop() if it
     * becomes invisible to the user.
     */
    @Override
    protected void onPause() {
        super.onPause();
    }

    /**
     * Called when the activity is no longer visible to the user, because another activity has been
     * resumed and is covering this one. This may happen either because a new activity is being
     * started, an existing one is being brought in front of this one, or this one is being
     * destroyed.
     * <p>
     * Followed by either onRestart() if this activity is coming back to interact with the user, or
     * onDestroy() if this activity is going away.
     */
    @Override
    protected void onStop() {
        super.onStop();
    }

    /**
     * Called after our activity has been stopped, prior to it being started again.
     * <p>
     * Always followed by onStart()
     */
    @Override
    protected void onRestart() {
        super.onRestart();
    }

    /**
     * The final call we receive before our activity is destroyed. This can happen either because
     * the activity is finishing (someone called finish() on it, or because the system is
     * temporarily destroying this instance of the activity to save space. You can distinguish
     * between these two scenarios with the isFinishing() method.
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
    }


    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        // Put the text from the TextView in the outState bundle
        String textToSave = mLifecycleDisplay.getText().toString();
        outState.putString(LIFECYCLE_CALLBACKS_TEXT_KEY, textToSave);
    }

    // Rest of the activity...
}

// Implement the proper LoaderCallbacks interface and the methods of that interface
public class MainActivity extends AppCompatActivity implements
        LoaderManager.LoaderCallbacks<String[]> {

    /*
     * This ID will uniquely identify the Loader. We can use it, for example, 
     * to get a handle on our Loader at a later point in time through the 
     * support LoaderManager.
     */
    private static final int LOADER_ID = 22;

    private ProgressBar mLoadingIndicator;

    // ...

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_forecast);

        // Implementation of onCreate() ...

        // Prepare the loader.  Either re-connect with an existing one,
        // or start a new one.
        getSupportLoaderManager().initLoader(SUNSHINE_LOADER_ID, null, this);
    }

    /**
     * Instantiate and return a new Loader for the given ID.
     */
    @Override
    public Loader<String[]> onCreateLoader(int id, Bundle args) {
        return new AsyncTaskLoader<String[]>(this) {
            // When we attempt to access a loader (for example, through initLoader()), 
            // it checks to see whether the loader specified by the ID exists. 
            // If it doesn't, it triggers the LoaderManager.LoaderCallbacks method 
            // onCreateLoader(). This is where we create a new loader.

            /* This String array will hold and help cache our data */
            String[] mCachedData = null;

            /**
             * Subclasses of AsyncTaskLoader must implement this to take care of 
             * loading their data.
             */
            @Override
            protected void onStartLoading() {
                if (mCachedData != null) {
                    deliverResult(mCachedData);
                } else {
                    mLoadingIndicator.setVisibility(View.VISIBLE);
                    forceLoad();
                    // Force an asynchronous load. Unlike startLoading() this will 
                    // ignore a previously loaded data set and load a new one. 
                    // This simply calls through to the implementation's onForceLoad(). 
                    // We generally should only call this when the loader is 
                    // started -- that is, isStarted() returns true.
                    // Must be called from the process's main thread.
                }
            }

            /**
             * This is the method of the AsyncTaskLoader that will load the data
             *  in the background.
             *
             * @return The data from the source as an array of Strings.
             *         null if an error occurs
             */
            @Override
            public String[] loadInBackground() {

                URL dataRequestURL = new URL("https://get.data.example.json");

                try {
                    // This is a ficticious method that gets the data from a given
                    // URL and parses it to a String array.
                    String[] simpleJsonData = 
                            getSimpleWeatherStringsFromJson(dataRequestURL);

                    return simpleJsonData;
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }

            /**
             * Sends the result of the load to the registered listener.
             *
             * @param data The result of the load
             */
            @Override
            public void deliverResult(String[] data) {
                mCachedData = data;
                super.deliverResult(data);
            }
        };
    }

    /**
     * Called when a previously created loader has finished its load.
     *
     * @param loader The Loader that has finished.
     * @param data The data generated by the Loader.
     */
    @Override
    public void onLoadFinished(Loader<String[]> loader, String[] data) {
        mLoadingIndicator.setVisibility(View.INVISIBLE);
        if (data == null) {
            showErrorMessage();
        } else {
            // This is a ficticious method that shows the data to the user
            // by updating the app's UI.
            showDataView(data);
        }
    }

    /**
     * Called when a previously created loader is being reset, and thus
     * making its data unavailable. The application should at this point
     * remove any references it has to the Loader's data.
     *
     * @param loader The Loader that is being reset.
      */
    @Override
    public void onLoaderReset(Loader<String[]> loader) {
        /*
         * We aren't using this method in our example, but we are required to Override
         * it to implement the LoaderCallbacks<String> interface
         */
    }

    // Rest of the Activity implementation

}