AsyncTask Clase

Definición

[Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })]
public abstract class AsyncTask : Java.Lang.Object

[<Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })>]
type AsyncTask = class
    inherit Object

Herencia

Object

JavaObject

Object

AsyncTask

Derivado

Android.OS.AsyncTask<TParams,TProgress,TResult>

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentarios

AsyncTask estaba pensado para habilitar el uso adecuado y sencillo del subproceso de la interfaz de usuario. Sin embargo, el caso de uso más común era la integración en la interfaz de usuario y eso provocaría pérdidas de contexto, devoluciones de llamada perdidas o bloqueos en los cambios de configuración. También tiene un comportamiento incoherente en diferentes versiones de la plataforma, ingiere excepciones de doInBackgroundy no proporciona mucha utilidad sobre el uso Executordirecto de s.

AsyncTask está diseñado para ser una clase auxiliar en torno Thread a y Handler no constituye un marco de subproceso genérico. Idealmente, AsyncTasks debe usarse para operaciones cortas (unos segundos como máximo). Si necesita mantener los subprocesos en ejecución durante largos períodos de tiempo, se recomienda encarecidamente usar las distintas API proporcionadas por el java.util.concurrent paquete, como Executor, ThreadPoolExecutor y FutureTask.

Una tarea asincrónica se define mediante un cálculo que se ejecuta en un subproceso en segundo plano y cuyo resultado se publica en el subproceso de interfaz de usuario. Una tarea asincrónica se define mediante 3 tipos genéricos, denominados Params, Progress y Result4 pasos, denominados onPreExecute, doInBackgroundonProgressUpdate y onPostExecute.

<div class="special reference"><h3>Developer Guides</h3>

Para obtener más información sobre el uso de tareas y subprocesos, lea la guía para desarrolladores procesos y subprocesos .

</Div>

<h2>Usage</h2>

AsyncTask debe estar subclase para usarse. La subclase invalidará al menos un método (#doInBackground) y la mayoría de las veces invalidará una segunda (#onPostExecute.)

Este es un ejemplo de subclases:

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
                protected Long doInBackground(URL... urls) {
                    int count = urls.length;
                    long totalSize = 0;
                    for (int i = 0; i < count; i++) {
                        totalSize += Downloader.downloadFile(urls[i]);
                        publishProgress((int) ((i / (float) count) * 100));
                        // Escape early if cancel() is called
                        if (isCancelled()) break;
                    }
                    return totalSize;
                }

                protected void onProgressUpdate(Integer... progress) {
                    setProgressPercent(progress[0]);
                }

                protected void onPostExecute(Long result) {
                    showDialog("Downloaded " + result + " bytes");
                }
            }

Una vez creada, una tarea se ejecuta muy simplemente:

new DownloadFilesTask().execute(url1, url2, url3);

<Tipos genéricos> de h2<AsyncTask/h2>

Los tres tipos usados por una tarea asincrónica son los siguientes:

<ol><li>Params, el tipo de los parámetros enviados a la tarea tras la ejecución.</li li><>Progress, el tipo de las unidades de progreso publicadas durante el cálculo en segundo plano.</li li><>Result, el tipo del resultado del cálculo en segundo plano.</li></ol>

No todos los tipos siempre se usan en una tarea asincrónica. Para marcar un tipo como sin usar, simplemente use el tipo Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

<h2>Los 4 pasos</h2>

Cuando se ejecuta una tarea asincrónica, la tarea pasa por 4 pasos:

<ol><li>#onPreExecute(), invocado en el subproceso de interfaz de usuario antes de ejecutar la tarea. Este paso se usa normalmente para configurar la tarea, por ejemplo, mostrando una barra de progreso en la interfaz de usuario.</li><li>#doInBackground, invocado en el subproceso en segundo plano inmediatamente después #onPreExecute() de terminar de ejecutarse. Este paso se usa para realizar cálculos en segundo plano que pueden tardar mucho tiempo. Los parámetros de la tarea asincrónica se pasan a este paso. El resultado del cálculo debe devolverse en este paso y se volverá a pasar al último paso. Este paso también puede usar #publishProgress para publicar una o varias unidades de progreso. Estos valores se publican en el subproceso de la interfaz de usuario, en el #onProgressUpdate paso .</li><li>#onProgressUpdate, invocado en el subproceso de la interfaz de usuario después de una llamada a #publishProgress. El tiempo de ejecución no está definido. Este método se usa para mostrar cualquier forma de progreso en la interfaz de usuario mientras el cálculo en segundo plano todavía se está ejecutando. Por ejemplo, se puede usar para animar una barra de progreso o mostrar registros en un campo de texto.</li><li>#onPostExecute, invocado en el subproceso de la interfaz de usuario después de que finalice el cálculo en segundo plano. El resultado del cálculo en segundo plano se pasa a este paso como parámetro.</li></ol>

<h2>Cancelación de una tarea</h2>

Una tarea se puede cancelar en cualquier momento invocando #cancel(boolean). Invocar este método hará que las llamadas posteriores devuelvan #isCancelled() true. Después de invocar este método, #onCancelled(Object), en lugar de se invocará después #onPostExecute(Object) de #doInBackground(Object[]) las devoluciones. Para asegurarse de que una tarea se cancele lo antes posible, siempre debe comprobar el valor devuelto de periódicamente desde #isCancelled(), si es posible (dentro de #doInBackground(Object[]) un bucle para la instancia).

<h2>Reglas de subproceso</h2>

Hay algunas reglas de subproceso que deben seguirse para que esta clase funcione correctamente:

<ul><li>La clase AsyncTask debe cargarse en el subproceso de la interfaz de usuario. Esto se realiza automáticamente a partir de android.os.Build.VERSION_CODES#JELLY_BEAN.</li li><>La instancia de tarea debe crearse en el subproceso de la interfaz de usuario.</li><li>#execute debe invocarse en el subproceso de la interfaz de usuario.</li li><>No llame a #onPreExecute(), #onPostExecute, , #doInBackground#onProgressUpdatemanualmente.</li li><>La tarea solo se puede ejecutar una vez (se producirá una excepción si se intenta realizar una segunda ejecución).</li></ul>

<h2>Observabilidad de< memoria/h2>

AsyncTask garantiza que todas las llamadas de devolución de llamada se sincronizan para garantizar lo siguiente sin sincronizaciones explícitas.

<ul><li>Los efectos de memoria de y cualquier otra cosa ejecutada antes de #onPreExecutela llamada a #execute, incluida la construcción del objeto AsyncTask, son visibles para #doInBackground. <li>Los efectos de memoria de #doInBackground son visibles para #onPostExecute. <li>Todos los efectos de memoria de #doInBackground una llamada a #publishProgress son visibles para la llamada correspondiente #onProgressUpdate . (Pero #doInBackground sigue ejecutándose y debe tenerse cuidado de que las actualizaciones posteriores de #doInBackground no interfieran con una llamada en curso #onProgressUpdate ). <li>Los efectos de memoria anteriores a una llamada a #cancel son visibles después de una llamada a #isCancelled que devuelve true como resultado, o durante y después de una llamada resultante a #onCancelled. </ul>

<h2>Orden de ejecución</h2>

Cuando se introdujo por primera vez, AsyncTasks se ejecutó en serie en un único subproceso en segundo plano. android.os.Build.VERSION_CODES#DONUTA partir de , esto se cambió a un grupo de subprocesos que permite que varias tareas funcionen en paralelo. A partir de android.os.Build.VERSION_CODES#HONEYCOMB, las tareas se ejecutan en un único subproceso para evitar errores comunes de aplicación causados por la ejecución en paralelo.

Si realmente desea la ejecución en paralelo, puede invocar #executeOnExecutor(java.util.concurrent.Executor, Object[]) con #THREAD_POOL_EXECUTOR.

Este miembro está en desuso. En su lugar, use las java.util.concurrent estándar o Kotlin.

Java documentación para android.os.AsyncTask.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.