下面列出了android.support.v4.widget.ResourceCursorAdapter#android.support.v4.app.LoaderManager.LoaderCallbacks 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
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;
}