java.lang.Object | |
↳ | android.content.Loader<D> |
Known Direct Subclasses |
Known Indirect Subclasses |
A class that performs asynchronous loading of data. While Loaders are active
they should monitor the source of their data and deliver new results when the contents
change. See LoaderManager
for more detail.
Note on threading: Clients of loaders should as a rule perform
any calls on to a Loader from the main thread of their process (that is,
the thread the Activity callbacks and other things occur on). Subclasses
of Loader (such as AsyncTaskLoader
) will often perform their work
in a separate thread, but when delivering their results this too should
be done on the main thread.
Subclasses generally must implement at least onStartLoading()
,
onStopLoading()
, onForceLoad()
, and onReset()
.
Most implementations should not derive directly from this class, but
instead inherit from AsyncTaskLoader
.
For more information about using loaders, read the Loaders developer guide.
Nested Classes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Loader.ForceLoadContentObserver | An implementation of a ContentObserver that takes care of connecting it to the Loader to have the loader re-load its data when the observer is told it has changed. | ||||||||||
Loader.OnLoadCanceledListener<D> | Interface that is implemented to discover when a Loader has been canceled before it finished loading its data. | ||||||||||
Loader.OnLoadCompleteListener<D> | Interface that is implemented to discover when a Loader has finished loading its data. |
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Stores away the application context associated with context.
|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
This function will normally be called for you automatically by
LoaderManager when restarting a Loader. | |||||||||||
Attempt to cancel the current load task.
| |||||||||||
Commit that you have actually fully processed a content change that
was returned by
takeContentChanged() . | |||||||||||
For debugging, converts an instance of the Loader's data class to
a string that can be printed.
| |||||||||||
Informs the registered
Loader.OnLoadCanceledListener that the load has been canceled. | |||||||||||
Sends the result of the load to the registered listener.
| |||||||||||
Print the Loader's state into the given stream.
| |||||||||||
Force an asynchronous load.
| |||||||||||
Return whether this loader has been abandoned.
| |||||||||||
Return whether this load has been reset.
| |||||||||||
Return whether this load has been started.
| |||||||||||
Called when
Loader.ForceLoadContentObserver detects a change. | |||||||||||
Registers a class that will receive callbacks when a load is complete.
| |||||||||||
Registers a listener that will receive callbacks when a load is canceled.
| |||||||||||
This function will normally be called for you automatically by
LoaderManager when destroying a Loader. | |||||||||||
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 function will normally be called for you automatically by
LoaderManager when the associated fragment/activity
is being started. | |||||||||||
This function will normally be called for you automatically by
LoaderManager when the associated fragment/activity
is being stopped. | |||||||||||
Take the current flag indicating whether the loader's content had
changed while it was stopped.
| |||||||||||
Returns a string containing a concise, human-readable description of this
object.
| |||||||||||
Remove a listener that was previously added with
registerListener(int, Loader.OnLoadCompleteListener . | |||||||||||
Unregisters a listener that was previously added with
registerOnLoadCanceledListener(Loader.OnLoadCanceledListener . |
Protected Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Subclasses implement this to take care of being abandoned.
| |||||||||||
Subclasses must implement this to take care of requests to
cancelLoad() . | |||||||||||
Subclasses must implement this to take care of requests to
forceLoad() . | |||||||||||
Subclasses must implement this to take care of resetting their loader,
as per
reset() . | |||||||||||
Subclasses must implement this to take care of loading their data,
as per
startLoading() . | |||||||||||
Subclasses must implement this to take care of stopping their loader,
as per
stopLoading() . |
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
java.lang.Object
|
Stores away the application context associated with context.
Since Loaders can be used across multiple activities it's dangerous to
store the context directly; always use getContext()
to retrieve
the Loader's Context, don't use the constructor argument directly.
The Context returned by getContext()
is safe to use across
Activity instances.
context | used to retrieve the application context. |
---|
This function will normally be called for you automatically by
LoaderManager
when restarting a Loader. When using
a Loader with 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.
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.
startLoading()
hasn't been called; returns
true otherwise. When true is returned, the task
is still running and the Loader.OnLoadCanceledListener
will be called
when the task completes.
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.
For debugging, converts an instance of the Loader's data class to a string that can be printed. Must handle a null data.
Informs the registered Loader.OnLoadCanceledListener
that the load has been canceled.
Should only be called by subclasses.
Must be called from the process's main thread.
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.
data | the result of the load |
---|
Print the Loader's state into the given stream.
prefix | Text to print at the front of each line. |
---|---|
fd | The raw file descriptor that the dump is being sent to. |
writer | A PrintWriter to which the dump is to be set. |
args | Additional arguments to the dump request. |
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.
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.
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.
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.
Called when Loader.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.
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.
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.
listener | The listener to register. |
---|
This function will normally be called for you automatically by
LoaderManager
when destroying a Loader. When using
a Loader with 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.
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.
This function will normally be called for you automatically by
LoaderManager
when the associated fragment/activity
is being started. When using a Loader with 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.
This function will normally be called for you automatically by
LoaderManager
when the associated fragment/activity
is being stopped. When using a Loader with 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.
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.
Returns a string containing a concise, human-readable description of this object. Subclasses are encouraged to override this method and provide an implementation that takes into account the object's type and data. The default implementation is equivalent to the following expression:
getClass().getName() + '@' + Integer.toHexString(hashCode())
See Writing a useful
toString
method
if you intend implementing your own toString
method.
Remove a listener that was previously added with registerListener(int, Loader.OnLoadCompleteListener
.
Must be called from the process's main thread.
Unregisters a listener that was previously added with
registerOnLoadCanceledListener(Loader.OnLoadCanceledListener
.
Must be called from the process's main thread.
listener | The listener to unregister. |
---|
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()
.
Subclasses must implement this to take care of requests to cancelLoad()
.
This will always be called from the process's main thread.
startLoading()
hasn't been called; returns
true otherwise. When true is returned, the task
is still running and the Loader.OnLoadCanceledListener
will be called
when the task completes.
Subclasses must implement this to take care of requests to forceLoad()
.
This will always be called from the process's main thread.
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()
.
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.