public <D> Loader<D> initLoader(int id, Bundle args, LoaderCallbacks<D> callback) {
    if (this.mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }
    LoaderInfo info = (LoaderInfo) this.mLoaders.get(id);
    if (DEBUG) {
        Log.v(TAG, "initLoader in " + this + ": args=" + args);
    }
    if (info == null) {
        info = createAndInstallLoader(id, args, callback);
        if (DEBUG) {
            Log.v(TAG, "  Created new loader " + info);
        }
    } else {
        if (DEBUG) {
            Log.v(TAG, "  Re-using existing loader " + info);
        }
        info.mCallbacks = callback;
    }
    if (info.mHaveData && this.mStarted) {
        info.callOnLoadFinished(info.mLoader, info.mData);
    }
    return info.mLoader;
}
 

private LoaderInfo createAndInstallLoader(int id, Bundle args, LoaderCallbacks<Object> callback) {
    try {
        this.mCreatingLoader = true;
        LoaderInfo info = createLoader(id, args, callback);
        installLoader(info);
        return info;
    } finally {
        this.mCreatingLoader = false;
    }
}
 

RepositoriesLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<Repositories>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}
 

TweetsLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<Timeline>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}
 

PhotosLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<ContactsPhotos>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}
 

public LoadableDecorator(LoaderCallbacks<Result<T>> callbacks, int loaderId,
        ListFragment listFragment) {
    super();
    this.mCallbacks = Preconditions.checkNotNull(callbacks);
    this.mLoaderId = loaderId;
    this.mListFragment = Preconditions.checkNotNull(listFragment);
    this.mAdapterView = Preconditions.checkNotNull(listFragment.getListView());

    mListFragment.setListShown(false);
}
 

PlurksLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<Timeline>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    /*
     * Register MainActivity as an OnPreferenceChangedListener to receive a callback when a
     * SharedPreference has changed. Please note that we must unregister MainActivity as an
     * OnSharedPreferenceChanged listener in onDestroy to avoid any memory leaks.
     */
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    /*
     * Register MainActivity as an OnPreferenceChangedListener to receive a callback when a
     * SharedPreference has changed. Please note that we must unregister MainActivity as an
     * OnSharedPreferenceChanged listener in onDestroy to avoid any memory leaks.
     */
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    /*
     * Register MainActivity as an OnPreferenceChangedListener to receive a callback when a
     * SharedPreference has changed. Please note that we must unregister MainActivity as an
     * OnSharedPreferenceChanged listener in onDestroy to avoid any memory leaks.
     */
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    /*
     * Register MainActivity as an OnPreferenceChangedListener to receive a callback when a
     * SharedPreference has changed. Please note that we must unregister MainActivity as an
     * OnSharedPreferenceChanged listener in onDestroy to avoid any memory leaks.
     */
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    /*
     * Register MainActivity as an OnPreferenceChangedListener to receive a callback when a
     * SharedPreference has changed. Please note that we must unregister MainActivity as an
     * OnSharedPreferenceChanged listener in onDestroy to avoid any memory leaks.
     */
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    // COMPLETED (6) Register MainActivity as a OnSharedPreferenceChangedListener in onCreate
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

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

    /*
     * Using findViewById, we get a reference to our RecyclerView from xml. This allows us to
     * do things like set the adapter of the RecyclerView and toggle the visibility.
     */
    mRecyclerView = (RecyclerView) findViewById(R.id.recyclerview_forecast);

    /* This TextView is used to display errors and will be hidden if there are no errors */
    mErrorMessageDisplay = (TextView) findViewById(R.id.tv_error_message_display);

    /*
     * A LinearLayoutManager is responsible for measuring and positioning item views within a
     * RecyclerView into a linear list. This means that it can produce either a horizontal or
     * vertical list depending on which parameter you pass in to the LinearLayoutManager
     * constructor. In our case, we want a vertical list, so we pass in the constant from the
     * LinearLayoutManager class for vertical lists, LinearLayoutManager.VERTICAL.
     *
     * There are other LayoutManagers available to display your data in uniform grids,
     * staggered grids, and more! See the developer documentation for more details.
     */
    int recyclerViewOrientation = LinearLayoutManager.VERTICAL;

    /*
     *  This value should be true if you want to reverse your layout. Generally, this is only
     *  true with horizontal lists that need to support a right-to-left layout.
     */
    boolean shouldReverseLayout = false;
    LinearLayoutManager layoutManager
            = new LinearLayoutManager(this, recyclerViewOrientation, shouldReverseLayout);
    mRecyclerView.setLayoutManager(layoutManager);

    /*
     * Use this setting to improve performance if you know that changes in content do not
     * change the child layout size in the RecyclerView
     */
    mRecyclerView.setHasFixedSize(true);

    /*
     * The ForecastAdapter is responsible for linking our weather data with the Views that
     * will end up displaying our weather data.
     */
    mForecastAdapter = new ForecastAdapter(this);

    /* Setting the adapter attaches it to the RecyclerView in our layout. */
    mRecyclerView.setAdapter(mForecastAdapter);

    /*
     * The ProgressBar that will indicate to the user that we are loading data. It will be
     * hidden when no data is loading.
     *
     * Please note: This so called "ProgressBar" isn't a bar by default. It is more of a
     * circle. We didn't make the rules (or the names of Views), we just follow them.
     */
    mLoadingIndicator = (ProgressBar) findViewById(R.id.pb_loading_indicator);

    /*
     * 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.
     */
    int loaderId = FORECAST_LOADER_ID;

    /*
     * From MainActivity, we have implemented the LoaderCallbacks interface with the type of
     * String array. (implements LoaderCallbacks<String[]>) The variable callback is passed
     * to the call to initLoader below. This means that whenever the loaderManager has
     * something to notify us of, it will do so through this callback.
     */
    LoaderCallbacks<String[]> callback = MainActivity.this;

    /*
     * The second parameter of the initLoader method below is a Bundle. Optionally, you can
     * pass a Bundle to initLoader that you can then access from within the onCreateLoader
     * callback. In our case, we don't actually use the Bundle, but it's here in case we wanted
     * to.
     */
    Bundle bundleForLoader = null;

    /*
     * Ensures a loader is initialized and active. If the loader doesn't already exist, one is
     * created and (if the activity/fragment is currently started) starts the loader. Otherwise
     * the last created loader is re-used.
     */
    getSupportLoaderManager().initLoader(loaderId, bundleForLoader, callback);

    Log.d(TAG, "onCreate: registering preference changed listener");

    /*
     * Register MainActivity as an OnPreferenceChangedListener to receive a callback when a
     * SharedPreference has changed. Please note that we must unregister MainActivity as an
     * OnSharedPreferenceChanged listener in onDestroy to avoid any memory leaks.
     */
    PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
}
 

public LiveFragment() {
    if (HotFix.PREVENT_VERIFY) {
        System.out.println(VerifyLoad.class);
    }
    this.SCROLL_LEFT = 1;
    this.SCROLL_RIGTH = -1;
    this.mLiveList = new ArrayList();
    this.mGotoChildPageIndex = -1;
    this.mRefreshData = new RefreshData(this) {
        final /* synthetic */ LiveFragment this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public void refreshData() {
            this.this$0.mRootView.loading(false);
            this.this$0.getData();
        }
    };
    this.mBookLoaderCallback = new LoaderCallbacks<Cursor>(this) {
        final /* synthetic */ LiveFragment this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
            return new CursorLoader(this.this$0.getContext(), LetvContentProvider.URI_LIVEBOOKTRACE, null, null, null, null);
        }

        public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
            if (cursor != null) {
                Set<String> mBookedPrograms = new HashSet();
                while (cursor.moveToNext()) {
                    try {
                        int idx = cursor.getColumnIndexOrThrow(Field.MD5_ID);
                        if (idx != -1) {
                            mBookedPrograms.add(cursor.getString(idx));
                        }
                    } catch (SQLiteException e) {
                        e.printStackTrace();
                        return;
                    }
                }
                if (this.this$0.mLiveAdapter != null) {
                    this.this$0.mLiveAdapter.setBookedPrograms(mBookedPrograms);
                }
            }
        }

        public void onLoaderReset(Loader<Cursor> loader) {
        }
    };
}
 

public LiveSubTypeActivity() {
    if (HotFix.PREVENT_VERIFY) {
        System.out.println(VerifyLoad.class);
    }
    this.mData = new ArrayList();
    this.mLunboData = new ArrayList();
    this.mPrograms = new HashMap();
    this.mCurrentActionType = 1;
    this.mBookLoaderCallback = new LoaderCallbacks<Cursor>(this) {
        final /* synthetic */ LiveSubTypeActivity this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
            return new CursorLoader(this.this$0, LetvContentProvider.URI_LIVEBOOKTRACE, null, null, null, null);
        }

        public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
            if (cursor != null) {
                Set<String> mBookedPrograms = new HashSet();
                while (cursor.moveToNext()) {
                    try {
                        int idx = cursor.getColumnIndexOrThrow(Field.MD5_ID);
                        if (idx != -1) {
                            mBookedPrograms.add(cursor.getString(idx));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        return;
                    }
                }
                if (this.this$0.mRoomAdapter != null) {
                    this.this$0.mRoomAdapter.setBookedPrograms(mBookedPrograms);
                }
            }
        }

        public void onLoaderReset(Loader<Cursor> loader) {
        }
    };
    this.mRefreshData = new RefreshData(this) {
        final /* synthetic */ LiveSubTypeActivity this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public void refreshData() {
            this.this$0.mRootView.loading(false);
            this.this$0.getData();
        }
    };
}
 

public LoaderInfo(int id, Bundle args, LoaderCallbacks<Object> callbacks) {
    this.mId = id;
    this.mArgs = args;
    this.mCallbacks = callbacks;
}
 

private LoaderInfo createLoader(int id, Bundle args, LoaderCallbacks<Object> callback) {
    LoaderInfo info = new LoaderInfo(id, args, callback);
    info.mLoader = callback.onCreateLoader(id, args);
    return info;
}
 

public <D> Loader<D> restartLoader(int id, Bundle args, LoaderCallbacks<D> callback) {
    if (this.mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }
    LoaderInfo info = (LoaderInfo) this.mLoaders.get(id);
    if (DEBUG) {
        Log.v(TAG, "restartLoader in " + this + ": args=" + args);
    }
    if (info != null) {
        LoaderInfo inactive = (LoaderInfo) this.mInactiveLoaders.get(id);
        if (inactive == null) {
            if (DEBUG) {
                Log.v(TAG, "  Making last loader inactive: " + info);
            }
            info.mLoader.abandon();
            this.mInactiveLoaders.put(id, info);
        } else if (info.mHaveData) {
            if (DEBUG) {
                Log.v(TAG, "  Removing last inactive loader: " + info);
            }
            inactive.mDeliveredData = false;
            inactive.destroy();
            info.mLoader.abandon();
            this.mInactiveLoaders.put(id, info);
        } else if (info.mStarted) {
            if (DEBUG) {
                Log.v(TAG, "  Current loader is running; attempting to cancel");
            }
            info.cancel();
            if (info.mPendingLoader != null) {
                if (DEBUG) {
                    Log.v(TAG, "  Removing pending loader: " + info.mPendingLoader);
                }
                info.mPendingLoader.destroy();
                info.mPendingLoader = null;
            }
            if (DEBUG) {
                Log.v(TAG, "  Enqueuing as new pending loader");
            }
            info.mPendingLoader = createLoader(id, args, callback);
            return info.mPendingLoader.mLoader;
        } else {
            if (DEBUG) {
                Log.v(TAG, "  Current loader is stopped; replacing");
            }
            this.mLoaders.put(id, null);
            info.destroy();
        }
    }
    return createAndInstallLoader(id, args, callback).mLoader;
}
 

@Override
public void execute(final Query request, final QueryListener listener) {
	final LoaderCallbacks<?> callbacks = new QueryLoaderCallbacks(listener);
	execute(request, callbacks);
}
 

@Override
public void execute(final Update request, final UpdateListener listener) {
	final LoaderCallbacks<?> callbacks = new UpdateLoaderCallbacks(listener);
	execute(request, callbacks);
}
 

@Override
public void execute(final Insert request, final InsertListener listener) {
	final LoaderCallbacks<?> callbacks = new InsertLoaderCallbacks(listener);
	execute(request, callbacks);
}
 

@Override
public void execute(final Delete request, final DeleteListener listener) {
	final LoaderCallbacks<?> callbacks = new DeleteLoaderCallbacks(listener);
	execute(request, callbacks);
   }
 

@Override
public void execute(final Batch request, final BatchListener listener) {
    final LoaderCallbacks<?> callbacks = new BatchLoaderCallbacks(listener);
    execute(request, callbacks);
}
 

private void execute(final Request<?> request, final LoaderCallbacks<?> callbacks) {
	final int identifier = request.getIdentifier();
	final Bundle bundle = createRequestBundle(request);
	mLoaderManager.restartLoader(identifier, bundle, callbacks);
}
 

FeedLoadable(LoaderManager loaderManager, int loaderId, LoaderCallbacks<Result<Feed>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}