AsyncTaskLoader
abstract class AsyncTaskLoader<D : Any!> : Loader<D>
Abstract Loader that provides an AsyncTask to do the work. See Loader and android.app.LoaderManager for more details.
Here is an example implementation of an AsyncTaskLoader subclass that loads the currently installed applications from the package manager. This implementation takes care of retrieving the application labels and sorting its result set from them, monitoring for changes to the installed applications, and rebuilding the list when a change in configuration requires this (such as a locale change).
An example implementation of a fragment that uses the above loader to show the currently installed applications in a list is below.
Summary
| Public methods |
| open Unit |
Called on the main thread to abort a load in progress.
|
| open Unit |
|
| open Boolean |
Returns true if the current invocation of loadInBackground is being canceled.
|
| abstract D |
Called on a worker thread to perform the actual load and to return the result of the load operation.
|
| open Unit |
Called if the task was canceled before it was completed.
|
| open Unit |
Set amount to throttle updates by.
|
| Inherited functions |
From class Loader
Unit |
abandon()
This function will normally be called for you automatically by android.app.LoaderManager when restarting a Loader. When using a Loader with android.app.LoaderManager, you must not call this method yourself, or you will conflict with its management of the Loader. Tell the Loader that it is being abandoned. This is called prior to reset to have it retain its current data but not report any new data.
|
Boolean |
cancelLoad()
Attempt to cancel the current load task. Must be called on the main thread of the process.
Cancellation is not an immediate operation, since the load is performed in a background thread. If there is currently a load in progress, this method requests that the load be canceled, and notes this is the case; once the background thread has completed its work its remaining state will be cleared. If another load request comes in during this time, it will be held until the canceled load is complete.
|
Unit |
commitContentChanged()
Commit that you have actually fully processed a content change that was returned by takeContentChanged. This is for use with rollbackContentChanged() to handle situations where a load is cancelled. Call this when you have completely processed a load without it being cancelled.
|
String! |
dataToString(data: D)
For debugging, converts an instance of the Loader's data class to a string that can be printed. Must handle a null data.
|
Unit |
deliverCancellation()
Informs the registered OnLoadCanceledListener that the load has been canceled. Should only be called by subclasses. Must be called from the process's main thread.
|
Unit |
deliverResult(data: D)
Sends the result of the load to the registered listener. Should only be called by subclasses. Must be called from the process's main thread.
|
Unit |
forceLoad()
Force an asynchronous load. Unlike startLoading() this will ignore a previously loaded data set and load a new one. This simply calls through to the implementation's onForceLoad(). You generally should only call this when the loader is started -- that is, isStarted() returns true.
Must be called from the process's main thread.
|
Context! |
getContext()
|
Int |
getId()
|
Boolean |
isAbandoned()
Return whether this loader has been abandoned. In this state, the loader must not report any new data, and must keep its last reported data valid until it is finally reset.
|
Boolean |
isReset()
Return whether this load has been reset. That is, either the loader has not yet been started for the first time, or its reset() has been called.
|
Boolean |
isStarted()
Return whether this load has been started. That is, its startLoading() has been called and no calls to stopLoading() or reset() have yet been made.
|
Unit |
onAbandon()
Subclasses implement this to take care of being abandoned. This is an optional intermediate state prior to onReset() -- it means that the client is no longer interested in any new data from the loader, so the loader must not report any further updates. However, the loader must keep its last reported data valid until the final onReset() happens. You can retrieve the current abandoned state with isAbandoned.
|
Unit |
onContentChanged()
Called when ForceLoadContentObserver detects a change. The default implementation checks to see if the loader is currently started; if so, it simply calls forceLoad(); otherwise, it sets a flag so that takeContentChanged() returns true.
Must be called from the process's main thread.
|
Unit |
onReset()
Subclasses must implement this to take care of resetting their loader, as per reset(). This is not called by clients directly, but as a result of a call to reset(). This will always be called from the process's main thread.
|
Unit |
onStartLoading()
Subclasses must implement this to take care of loading their data, as per startLoading(). This is not called by clients directly, but as a result of a call to startLoading().
|
Unit |
onStopLoading()
Subclasses must implement this to take care of stopping their loader, as per stopLoading(). This is not called by clients directly, but as a result of a call to stopLoading(). This will always be called from the process's main thread.
|
Unit |
registerListener(id: Int, listener: Loader.OnLoadCompleteListener<D>!)
Registers a class that will receive callbacks when a load is complete. The callback will be called on the process's main thread so it's safe to pass the results to widgets.
Must be called from the process's main thread.
|
Unit |
registerOnLoadCanceledListener(listener: Loader.OnLoadCanceledListener<D>!)
Registers a listener that will receive callbacks when a load is canceled. The callback will be called on the process's main thread so it's safe to pass the results to widgets. Must be called from the process's main thread.
|
Unit |
reset()
This function will normally be called for you automatically by android.app.LoaderManager when destroying a Loader. When using a Loader with android.app.LoaderManager, you must not call this method yourself, or you will conflict with its management of the Loader. Resets the state of the Loader. The Loader should at this point free all of its resources, since it may never be called again; however, its startLoading() may later be called at which point it must be able to start running again.
This updates the Loader's internal state so that isStarted() and isReset() will return the correct values, and then calls the implementation's onReset().
Must be called from the process's main thread.
|
Unit |
rollbackContentChanged()
Report that you have abandoned the processing of a content change that was returned by takeContentChanged() and would like to rollback to the state where there is again a pending content change. This is to handle the case where a data load due to a content change has been canceled before its data was delivered back to the loader.
|
Unit |
startLoading()
This function will normally be called for you automatically by android.app.LoaderManager when the associated fragment/activity is being started. When using a Loader with android.app.LoaderManager, you must not call this method yourself, or you will conflict with its management of the Loader. Starts an asynchronous load of the Loader's data. When the result is ready the callbacks will be called on the process's main thread. If a previous load has been completed and is still valid the result may be passed to the callbacks immediately. The loader will monitor the source of the data set and may deliver future callbacks if the source changes. Calling stopLoading will stop the delivery of callbacks.
This updates the Loader's internal state so that isStarted() and isReset() will return the correct values, and then calls the implementation's onStartLoading().
Must be called from the process's main thread.
|
Unit |
stopLoading()
This function will normally be called for you automatically by android.app.LoaderManager when the associated fragment/activity is being stopped. When using a Loader with android.app.LoaderManager, you must not call this method yourself, or you will conflict with its management of the Loader.
Stops delivery of updates until the next time startLoading() is called. Implementations should not invalidate their data at this point -- clients are still free to use the last data the loader reported. They will, however, typically stop reporting new data if the data changes; they can still monitor for changes, but must not report them to the client until and if startLoading() is later called.
This updates the Loader's internal state so that isStarted() will return the correct value, and then calls the implementation's onStopLoading().
Must be called from the process's main thread.
|
Boolean |
takeContentChanged()
Take the current flag indicating whether the loader's content had changed while it was stopped. If it had, true is returned and the flag is cleared.
|
String |
toString()
|
Unit |
unregisterListener(listener: Loader.OnLoadCompleteListener<D>!)
Remove a listener that was previously added with registerListener. Must be called from the process's main thread.
|
Unit |
unregisterOnLoadCanceledListener(listener: Loader.OnLoadCanceledListener<D>!)
Unregisters a listener that was previously added with registerOnLoadCanceledListener. Must be called from the process's main thread.
|
|
Public constructors
AsyncTaskLoader
AsyncTaskLoader(context: Context!)
Public methods
cancelLoadInBackground
open fun cancelLoadInBackground(): Unit
Deprecated: Deprecated in Java.
Called on the main thread to abort a load in progress. Override this method to abort the current invocation of loadInBackground that is running in the background on a worker thread. This method should do nothing if loadInBackground has not started running or if it has already finished.
isLoadInBackgroundCanceled
open fun isLoadInBackgroundCanceled(): Boolean
Deprecated: Deprecated in Java.
Returns true if the current invocation of loadInBackground is being canceled.
loadInBackground
abstract fun loadInBackground(): D
Deprecated: Deprecated in Java.
Called on a worker thread to perform the actual load and to return the result of the load operation. Implementations should not deliver the result directly, but should return them from this method, which will eventually end up calling deliverResult on the UI thread. If implementations need to process the results on the UI thread they may override deliverResult and do so there. To support cancellation, this method should periodically check the value of isLoadInBackgroundCanceled and terminate when it returns true. Subclasses may also override cancelLoadInBackground to interrupt the load directly instead of polling isLoadInBackgroundCanceled. When the load is canceled, this method may either return normally or throw OperationCanceledException. In either case, the Loader will call onCanceled to perform post-cancellation cleanup and to dispose of the result object, if any.
| Return |
D |
The result of the load operation. |
| Exceptions |
android.os.OperationCanceledException |
if the load is canceled during execution. |
onCanceled
open fun onCanceled(data: D): Unit
Deprecated: Deprecated in Java.
Called if the task was canceled before it was completed. Gives the class a chance to clean up post-cancellation and to properly dispose of the result.
setUpdateThrottle
open fun setUpdateThrottle(delayMS: Long): Unit
Deprecated: Deprecated in Java.
Set amount to throttle updates by. This is the minimum time from when the last loadInBackground() call has completed until a new load is scheduled.
| Parameters |
delayMS |
Long: Amount of delay, in milliseconds. |
Protected methods
onCancelLoad
protected open fun onCancelLoad(): Boolean
Deprecated: Deprecated in Java.
| Return |
Boolean |
Returns false if the task could not be canceled, typically because it has already completed normally, or because startLoading() hasn't been called; returns true otherwise. When true is returned, the task is still running and the OnLoadCanceledListener will be called when the task completes. |
onForceLoad
protected open fun onForceLoad(): Unit
Deprecated: Deprecated in Java.
onLoadInBackground
protected open fun onLoadInBackground(): D
Deprecated: Deprecated in Java.
Calls loadInBackground(). This method is reserved for use by the loader framework. Subclasses should override loadInBackground instead of this method.
| Return |
D |
The result of the load operation. |
| Exceptions |
android.os.OperationCanceledException |
if the load is canceled during execution. |
