AbstractDataBinder (library API)

java.lang.Object
- android.os.Handler
- - de.mrapp.android.util.multithreading.AbstractDataBinder<DataType,KeyType,ViewType,ParamType>

Type Parameters:

DataType - The type of the data, which is bound to views

KeyType - The type of the keys, which allow to uniquely identify already loaded data

ViewType - The type of the views, which are used to display data

ParamType - The type of parameters, which can be passed when loading data
```
public abstract class AbstractDataBinder<DataType,KeyType,ViewType,ParamType>
extends android.os.Handler
```
An abstract base class for all data binders, which allow to asynchronously load data in order to display it by using views. Such binders are meant to be used, when loading various data items, of which each one should be displayed by a different view. Once loaded, the data can optionally be stored in a cache (it therefore must be associated with an unique key). When attempting to reload already cached data, it is retrieved from the cache and displayed immediately.
The binder supports to use adapter views, which might be recycled while data is still loaded. In such case, the recycled view is prevented from showing the data once loading has finished, because it is already used for other purposes.

Since:

1.15.0

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`AbstractDataBinder.Listener<DataType,KeyType,ViewType,ParamType>` Defines the interface, a class, which should be notified about the progress of a `AbstractDataBinder` must implement.

Nested classes/interfaces inherited from class android.os.Handler
android.os.Handler.Callback

Field Summary

Fields
Modifier and Type Field and Description

static int CACHE_SIZE
The number of items, which are stored by a cached, by default.

Fields
Modifier and Type	Field and Description
`static int`	`CACHE_SIZE` The number of items, which are stored by a cached, by default.

Constructor Summary

Constructors
Constructor and Description
`AbstractDataBinder(android.content.Context context)` Creates a new data binder.
`AbstractDataBinder(android.content.Context context, <any> cache)` Creates a new data binder, which uses a specific cache.
`AbstractDataBinder(android.content.Context context, java.util.concurrent.ExecutorService threadPool)` Creates a new data binder, which uses a specific executor service.
`AbstractDataBinder(android.content.Context context, java.util.concurrent.ExecutorService threadPool, <any> cache)` Creates a new data binder, which uses a specifc executor service and cache.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addListener(AbstractDataBinder.Listener<DataType,KeyType,ViewType,ParamType> listener)` Adds a new listener, which should be notified about the events of the data binder.
`void`	`cancel()` Cancels loading the data.
`void`	`clearCache()` Clears the cache.
`protected abstract DataType`	`doInBackground(KeyType key, ParamType... params)` The method, which is invoked on implementing subclasses, in order to load the data, which corresponds to a specific key.
`android.content.Context`	`getContext()` Returns the context, which is used by the data binder.
`LogLevel`	`getLogLevel()` Returns the log level, which is used for logging.
`void`	`handleMessage(android.os.Message msg)`
`boolean`	`isCached(KeyType key)` Returns, whether the data, which corresponds to a specific key, is currently cached, or not.
`boolean`	`isCacheUsed()` Returns, whether data is cached, or not.
`boolean`	`isCanceled()` Returns, whether loading the data has been canceled, or not.
`void`	`load(KeyType key, ViewType view, boolean async, ParamType... params)` Loads the the data, which corresponds to a specific key, and displays it in a specific view.
`void`	`load(KeyType key, ViewType view, ParamType... params)` Loads the the data, which corresponds to a specific key, and displays it in a specific view.
`protected abstract void`	`onPostExecute(ViewType view, DataType data, long duration, ParamType... params)` The method, which is invoked on implementing subclasses, in order to display data after it has been loaded.
`protected void`	`onPreExecute(ViewType view, ParamType... params)` The method, which is invoked on implementing subclasses prior to loading any data.
`void`	`removeListener(AbstractDataBinder.Listener<DataType,KeyType,ViewType,ParamType> listener)` Removes a specific listener, which should not be notified about the events of the data binder, anymore.
`void`	`setLogLevel(LogLevel logLevel)` Sets the log level, which should be used for logging.
`void`	`useCache(boolean useCache)` Sets, whether data should be cached, or not.

Methods inherited from class android.os.Handler
dispatchMessage, dump, getLooper, getMessageName, hasMessages, hasMessages, obtainMessage, obtainMessage, obtainMessage, obtainMessage, obtainMessage, post, postAtFrontOfQueue, postAtTime, postAtTime, postDelayed, removeCallbacks, removeCallbacks, removeCallbacksAndMessages, removeMessages, removeMessages, sendEmptyMessage, sendEmptyMessageAtTime, sendEmptyMessageDelayed, sendMessage, sendMessageAtFrontOfQueue, sendMessageAtTime, sendMessageDelayed, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - CACHE_SIZE
```
public static final int CACHE_SIZE
```
    The number of items, which are stored by a cached, by default.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - AbstractDataBinder
```
public AbstractDataBinder(android.content.Context context)
```
    Creates a new data binder. Caching is enabled by default. The cache, which is used to store already loaded data, caches up to CACHE_SIZE items. The executor service, which is used to manage asynchronous tasks, is created by using the static method Executors.newCachedThreadPool. Such executor services are meant to be used when many short-living tasks are executed and reuse previously created threads.
    
    Parameters:
    
    context - The context, which should be used by the data binder, as an instance of the class Context. The context may not be null
  - AbstractDataBinder
```
public AbstractDataBinder(android.content.Context context,
                          java.util.concurrent.ExecutorService threadPool)
```
    Creates a new data binder, which uses a specific executor service. Caching is enabled by default. The cache, which is used to store already loaded data, caches up to CACHE_SIZE items.
    
    Parameters:
    
    context - The context, which should be used by the data binder, as an instance of the class Context. The context may not be null
    
    threadPool - The executor service, which should be used to manage asynchronous tasks, as an instance of the type ExecutorService. The executor service may not be null
  - AbstractDataBinder
```
public AbstractDataBinder(android.content.Context context,
                          <any> cache)
```
    Creates a new data binder, which uses a specific cache. Caching is enabled by default. The executor service, which is used to manage asynchronous tasks, is created by using the static method Executors.newCachedThreadPool. Such executor services are meant to be used when many short-living tasks are executed and reuse previously created threads.
    
    Parameters:
    
    context - The context, which should be used by the data binder, as an instance of the class Context. The context may not be null
    
    cache - The LRU cache, which should be used to cache already loaded data, as an instance of the class LruCache. The cache may not be null
  - AbstractDataBinder
```
public AbstractDataBinder(android.content.Context context,
                          java.util.concurrent.ExecutorService threadPool,
                          <any> cache)
```
    Creates a new data binder, which uses a specifc executor service and cache. Caching is enabled by default.
    
    Parameters:
    
    context - The context, which should be used by the data binder, as an instance of the class Context. The context may not be null
    
    threadPool - The executor service, which should be used to manage asynchronous tasks, as an instance of the type ExecutorService. The executor service may not be null
    
    cache - The LRU cache, which should be used to cache already loaded data, as an instance of the class LruCache. The cache may not be null
- Method Detail
  - onPreExecute
```
protected void onPreExecute(ViewType view,
                            ParamType... params)
```
    The method, which is invoked on implementing subclasses prior to loading any data. This method may be overridden to adapt the appearance of views.
    
    Parameters:
    
    view - The view, which should be used to display the data, as an instance of the generic type ViewType. The view may not be null
    
    params - An array, which contains optional parameters, as an array of the type ParamType or an empty array, if no parameters should be used
  - doInBackground
```
protected abstract DataType doInBackground(KeyType key,
                                           ParamType... params)
```
    The method, which is invoked on implementing subclasses, in order to load the data, which corresponds to a specific key. This method is executed in a background thread and therefore no views may be modified.
    
    Parameters:
    
    key - The key of the data, which should be loaded, as an instance of the generic type KeyType. The key may not be null
    
    params - An array, which contains optional parameters, as an array of the type ParamType or an empty array, if no parameters should be used
    
    Returns:
    
    The data, which has been loaded, as an instance of the generic type DataType or null, if no data has been loaded
  - onPostExecute
```
protected abstract void onPostExecute(ViewType view,
                                      DataType data,
                                      long duration,
                                      ParamType... params)
```
    The method, which is invoked on implementing subclasses, in order to display data after it has been loaded.
    
    Parameters:
    
    view - The view, which should be used to display the data, as an instance of the generic type ViewType. The view may not be null
    
    data - The data, which should be displayed, as an instance of the generic type DataType or null, if no data should be displayed
    
    duration - The duration of the loading process in milliseconds as a Long value
    
    params - An array, which contains optional parameters, as an array of the type ParamType or an empty array, if no parameters should be used
  - getContext
```
public final android.content.Context getContext()
```
    Returns the context, which is used by the data binder.
    
    Returns:
    
    The context, which is used by the data binder, as an instance of the class Context. The context may not be null
  - getLogLevel
```
public final LogLevel getLogLevel()
```
    Returns the log level, which is used for logging.
    
    Returns:
    
    The log level, which is used for logging, as a value of the enum LogLevel. The log level may not be null
  - setLogLevel
```
public final void setLogLevel(LogLevel logLevel)
```
    Sets the log level, which should be used for logging.
    
    Parameters:
    
    logLevel - The log level, which should be set, as a value of the enum LogLevel. The log level may not be null
  - addListener
```
public final void addListener(AbstractDataBinder.Listener<DataType,KeyType,ViewType,ParamType> listener)
```
    Adds a new listener, which should be notified about the events of the data binder.
    
    Parameters:
    
    listener - The listener, which should be added, as an instance of the type AbstractDataBinder.Listener. The listener may not be null
  - removeListener
```
public final void removeListener(AbstractDataBinder.Listener<DataType,KeyType,ViewType,ParamType> listener)
```
    Removes a specific listener, which should not be notified about the events of the data binder, anymore.
    
    Parameters:
    
    listener - The listener, which should be removed, as an instance of the type AbstractDataBinder.Listener. The listener may not be null
  - load
```
@SafeVarargs
public final void load(KeyType key,
                                    ViewType view,
                                    ParamType... params)
```
    Loads the the data, which corresponds to a specific key, and displays it in a specific view. If the data has already been loaded, it will be retrieved from the cache. By default, the data is loaded in a background thread.
    
    Parameters:
    
    key - The key of the data, which should be loaded, as an instance of the generic type KeyType. The key may not be null
    
    view - The view, which should be used to display the data, as an instance of the generic type ViewType. The view may not be null
    
    params - An array, which contains optional parameters, as an array of the type ParamType or an empty array, if no parameters should be used
  - load
```
@SafeVarargs
public final void load(KeyType key,
                                    ViewType view,
                                    boolean async,
                                    ParamType... params)
```
    Loads the the data, which corresponds to a specific key, and displays it in a specific view. If the data has already been loaded, it will be retrieved from the cache.
    
    Parameters:
    
    key - The key of the data, which should be loaded, as an instance of the generic type KeyType. The key may not be null
    
    view - The view, which should be used to display the data, as an instance of the generic type ViewType. The view may not be null
    
    async - True, if the data should be loaded in a background thread, false otherwise
    
    params - An array, which contains optional parameters, as an array of the type ParamType or an empty array, if no parameters should be used
  - cancel
```
public final void cancel()
```
    Cancels loading the data.
  - isCanceled
```
public final boolean isCanceled()
```
    Returns, whether loading the data has been canceled, or not.
    
    Returns:
    
    True, if loading the data has been canceled, false otherwise
  - isCached
```
public final boolean isCached(KeyType key)
```
    Returns, whether the data, which corresponds to a specific key, is currently cached, or not.
    
    Parameters:
    
    key - The key, which corresponds to the data, which should be checked, as an instance of the generic type KeyType. The key may not be null
    
    Returns:
    
    True, if the data, which corresponds to the given key, is currently cached, false otherwise
  - isCacheUsed
```
public final boolean isCacheUsed()
```
    Returns, whether data is cached, or not.
    
    Returns:
    
    True, if data is cached, false otherwise
  - useCache
```
public final void useCache(boolean useCache)
```
    Sets, whether data should be cached, or not.
    
    Parameters:
    
    useCache - True, if data should be cached, false otherwise.
  - clearCache
```
public final void clearCache()
```
    Clears the cache.
  - handleMessage
```
public final void handleMessage(android.os.Message msg)
```
    Overrides:
    
    handleMessage in class android.os.Handler

Class AbstractDataBinder<DataType,KeyType,ViewType,ParamType>

Nested Class Summary

Nested classes/interfaces inherited from class android.os.Handler

Field Summary

Constructor Summary

Method Summary

Methods inherited from class android.os.Handler

Methods inherited from class java.lang.Object

Field Detail

CACHE_SIZE

Constructor Detail

AbstractDataBinder

AbstractDataBinder

AbstractDataBinder

AbstractDataBinder

Method Detail

onPreExecute

doInBackground

onPostExecute

getContext

getLogLevel

setLogLevel

addListener

removeListener

load

load

cancel

isCanceled

isCached

isCacheUsed

useCache

clearCache

handleMessage