AsyncTask.java revision 83c6896cbf402623ef7d97f13ed65098df63429f
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.os; 18 19import android.annotation.MainThread; 20import android.annotation.WorkerThread; 21 22import java.util.ArrayDeque; 23import java.util.concurrent.BlockingQueue; 24import java.util.concurrent.Callable; 25import java.util.concurrent.CancellationException; 26import java.util.concurrent.Executor; 27import java.util.concurrent.ExecutionException; 28import java.util.concurrent.FutureTask; 29import java.util.concurrent.LinkedBlockingQueue; 30import java.util.concurrent.ThreadFactory; 31import java.util.concurrent.ThreadPoolExecutor; 32import java.util.concurrent.TimeUnit; 33import java.util.concurrent.TimeoutException; 34import java.util.concurrent.atomic.AtomicBoolean; 35import java.util.concurrent.atomic.AtomicInteger; 36 37/** 38 * <p>AsyncTask enables proper and easy use of the UI thread. This class allows to 39 * perform background operations and publish results on the UI thread without 40 * having to manipulate threads and/or handlers.</p> 41 * 42 * <p>AsyncTask is designed to be a helper class around {@link Thread} and {@link Handler} 43 * and does not constitute a generic threading framework. AsyncTasks should ideally be 44 * used for short operations (a few seconds at the most.) If you need to keep threads 45 * running for long periods of time, it is highly recommended you use the various APIs 46 * provided by the <code>java.util.concurrent</code> package such as {@link Executor}, 47 * {@link ThreadPoolExecutor} and {@link FutureTask}.</p> 48 * 49 * <p>An asynchronous task is defined by a computation that runs on a background thread and 50 * whose result is published on the UI thread. An asynchronous task is defined by 3 generic 51 * types, called <code>Params</code>, <code>Progress</code> and <code>Result</code>, 52 * and 4 steps, called <code>onPreExecute</code>, <code>doInBackground</code>, 53 * <code>onProgressUpdate</code> and <code>onPostExecute</code>.</p> 54 * 55 * <div class="special reference"> 56 * <h3>Developer Guides</h3> 57 * <p>For more information about using tasks and threads, read the 58 * <a href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html">Processes and 59 * Threads</a> developer guide.</p> 60 * </div> 61 * 62 * <h2>Usage</h2> 63 * <p>AsyncTask must be subclassed to be used. The subclass will override at least 64 * one method ({@link #doInBackground}), and most often will override a 65 * second one ({@link #onPostExecute}.)</p> 66 * 67 * <p>Here is an example of subclassing:</p> 68 * <pre class="prettyprint"> 69 * private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> { 70 * protected Long doInBackground(URL... urls) { 71 * int count = urls.length; 72 * long totalSize = 0; 73 * for (int i = 0; i < count; i++) { 74 * totalSize += Downloader.downloadFile(urls[i]); 75 * publishProgress((int) ((i / (float) count) * 100)); 76 * // Escape early if cancel() is called 77 * if (isCancelled()) break; 78 * } 79 * return totalSize; 80 * } 81 * 82 * protected void onProgressUpdate(Integer... progress) { 83 * setProgressPercent(progress[0]); 84 * } 85 * 86 * protected void onPostExecute(Long result) { 87 * showDialog("Downloaded " + result + " bytes"); 88 * } 89 * } 90 * </pre> 91 * 92 * <p>Once created, a task is executed very simply:</p> 93 * <pre class="prettyprint"> 94 * new DownloadFilesTask().execute(url1, url2, url3); 95 * </pre> 96 * 97 * <h2>AsyncTask's generic types</h2> 98 * <p>The three types used by an asynchronous task are the following:</p> 99 * <ol> 100 * <li><code>Params</code>, the type of the parameters sent to the task upon 101 * execution.</li> 102 * <li><code>Progress</code>, the type of the progress units published during 103 * the background computation.</li> 104 * <li><code>Result</code>, the type of the result of the background 105 * computation.</li> 106 * </ol> 107 * <p>Not all types are always used by an asynchronous task. To mark a type as unused, 108 * simply use the type {@link Void}:</p> 109 * <pre> 110 * private class MyTask extends AsyncTask<Void, Void, Void> { ... } 111 * </pre> 112 * 113 * <h2>The 4 steps</h2> 114 * <p>When an asynchronous task is executed, the task goes through 4 steps:</p> 115 * <ol> 116 * <li>{@link #onPreExecute()}, invoked on the UI thread before the task 117 * is executed. This step is normally used to setup the task, for instance by 118 * showing a progress bar in the user interface.</li> 119 * <li>{@link #doInBackground}, invoked on the background thread 120 * immediately after {@link #onPreExecute()} finishes executing. This step is used 121 * to perform background computation that can take a long time. The parameters 122 * of the asynchronous task are passed to this step. The result of the computation must 123 * be returned by this step and will be passed back to the last step. This step 124 * can also use {@link #publishProgress} to publish one or more units 125 * of progress. These values are published on the UI thread, in the 126 * {@link #onProgressUpdate} step.</li> 127 * <li>{@link #onProgressUpdate}, invoked on the UI thread after a 128 * call to {@link #publishProgress}. The timing of the execution is 129 * undefined. This method is used to display any form of progress in the user 130 * interface while the background computation is still executing. For instance, 131 * it can be used to animate a progress bar or show logs in a text field.</li> 132 * <li>{@link #onPostExecute}, invoked on the UI thread after the background 133 * computation finishes. The result of the background computation is passed to 134 * this step as a parameter.</li> 135 * </ol> 136 * 137 * <h2>Cancelling a task</h2> 138 * <p>A task can be cancelled at any time by invoking {@link #cancel(boolean)}. Invoking 139 * this method will cause subsequent calls to {@link #isCancelled()} to return true. 140 * After invoking this method, {@link #onCancelled(Object)}, instead of 141 * {@link #onPostExecute(Object)} will be invoked after {@link #doInBackground(Object[])} 142 * returns. To ensure that a task is cancelled as quickly as possible, you should always 143 * check the return value of {@link #isCancelled()} periodically from 144 * {@link #doInBackground(Object[])}, if possible (inside a loop for instance.)</p> 145 * 146 * <h2>Threading rules</h2> 147 * <p>There are a few threading rules that must be followed for this class to 148 * work properly:</p> 149 * <ul> 150 * <li>The AsyncTask class must be loaded on the UI thread. This is done 151 * automatically as of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}.</li> 152 * <li>The task instance must be created on the UI thread.</li> 153 * <li>{@link #execute} must be invoked on the UI thread.</li> 154 * <li>Do not call {@link #onPreExecute()}, {@link #onPostExecute}, 155 * {@link #doInBackground}, {@link #onProgressUpdate} manually.</li> 156 * <li>The task can be executed only once (an exception will be thrown if 157 * a second execution is attempted.)</li> 158 * </ul> 159 * 160 * <h2>Memory observability</h2> 161 * <p>AsyncTask guarantees that all callback calls are synchronized in such a way that the following 162 * operations are safe without explicit synchronizations.</p> 163 * <ul> 164 * <li>Set member fields in the constructor or {@link #onPreExecute}, and refer to them 165 * in {@link #doInBackground}. 166 * <li>Set member fields in {@link #doInBackground}, and refer to them in 167 * {@link #onProgressUpdate} and {@link #onPostExecute}. 168 * </ul> 169 * 170 * <h2>Order of execution</h2> 171 * <p>When first introduced, AsyncTasks were executed serially on a single background 172 * thread. Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed 173 * to a pool of threads allowing multiple tasks to operate in parallel. Starting with 174 * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are executed on a single 175 * thread to avoid common application errors caused by parallel execution.</p> 176 * <p>If you truly want parallel execution, you can invoke 177 * {@link #executeOnExecutor(java.util.concurrent.Executor, Object[])} with 178 * {@link #THREAD_POOL_EXECUTOR}.</p> 179 */ 180public abstract class AsyncTask<Params, Progress, Result> { 181 private static final String LOG_TAG = "AsyncTask"; 182 183 private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); 184 private static final int CORE_POOL_SIZE = CPU_COUNT + 1; 185 private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1; 186 private static final int KEEP_ALIVE = 1; 187 188 private static final ThreadFactory sThreadFactory = new ThreadFactory() { 189 private final AtomicInteger mCount = new AtomicInteger(1); 190 191 public Thread newThread(Runnable r) { 192 return new Thread(r, "AsyncTask #" + mCount.getAndIncrement()); 193 } 194 }; 195 196 private static final BlockingQueue<Runnable> sPoolWorkQueue = 197 new LinkedBlockingQueue<Runnable>(128); 198 199 /** 200 * An {@link Executor} that can be used to execute tasks in parallel. 201 */ 202 public static final Executor THREAD_POOL_EXECUTOR 203 = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, 204 TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory); 205 206 /** 207 * An {@link Executor} that executes tasks one at a time in serial 208 * order. This serialization is global to a particular process. 209 */ 210 public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); 211 212 private static final int MESSAGE_POST_RESULT = 0x1; 213 private static final int MESSAGE_POST_PROGRESS = 0x2; 214 215 private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; 216 private static InternalHandler sHandler; 217 218 private final WorkerRunnable<Params, Result> mWorker; 219 private final FutureTask<Result> mFuture; 220 221 private volatile Status mStatus = Status.PENDING; 222 223 private final AtomicBoolean mCancelled = new AtomicBoolean(); 224 private final AtomicBoolean mTaskInvoked = new AtomicBoolean(); 225 226 private static class SerialExecutor implements Executor { 227 final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>(); 228 Runnable mActive; 229 230 public synchronized void execute(final Runnable r) { 231 mTasks.offer(new Runnable() { 232 public void run() { 233 try { 234 r.run(); 235 } finally { 236 scheduleNext(); 237 } 238 } 239 }); 240 if (mActive == null) { 241 scheduleNext(); 242 } 243 } 244 245 protected synchronized void scheduleNext() { 246 if ((mActive = mTasks.poll()) != null) { 247 THREAD_POOL_EXECUTOR.execute(mActive); 248 } 249 } 250 } 251 252 /** 253 * Indicates the current status of the task. Each status will be set only once 254 * during the lifetime of a task. 255 */ 256 public enum Status { 257 /** 258 * Indicates that the task has not been executed yet. 259 */ 260 PENDING, 261 /** 262 * Indicates that the task is running. 263 */ 264 RUNNING, 265 /** 266 * Indicates that {@link AsyncTask#onPostExecute} has finished. 267 */ 268 FINISHED, 269 } 270 271 private static Handler getHandler() { 272 synchronized (AsyncTask.class) { 273 if (sHandler == null) { 274 sHandler = new InternalHandler(); 275 } 276 return sHandler; 277 } 278 } 279 280 /** @hide */ 281 public static void setDefaultExecutor(Executor exec) { 282 sDefaultExecutor = exec; 283 } 284 285 /** 286 * Creates a new asynchronous task. This constructor must be invoked on the UI thread. 287 */ 288 public AsyncTask() { 289 mWorker = new WorkerRunnable<Params, Result>() { 290 public Result call() throws Exception { 291 mTaskInvoked.set(true); 292 293 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); 294 //noinspection unchecked 295 return postResult(doInBackground(mParams)); 296 } 297 }; 298 299 mFuture = new FutureTask<Result>(mWorker) { 300 @Override 301 protected void done() { 302 try { 303 postResultIfNotInvoked(get()); 304 } catch (InterruptedException e) { 305 android.util.Log.w(LOG_TAG, e); 306 } catch (ExecutionException e) { 307 throw new RuntimeException("An error occurred while executing doInBackground()", 308 e.getCause()); 309 } catch (CancellationException e) { 310 postResultIfNotInvoked(null); 311 } 312 } 313 }; 314 } 315 316 private void postResultIfNotInvoked(Result result) { 317 final boolean wasTaskInvoked = mTaskInvoked.get(); 318 if (!wasTaskInvoked) { 319 postResult(result); 320 } 321 } 322 323 private Result postResult(Result result) { 324 @SuppressWarnings("unchecked") 325 Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, 326 new AsyncTaskResult<Result>(this, result)); 327 message.sendToTarget(); 328 return result; 329 } 330 331 /** 332 * Returns the current status of this task. 333 * 334 * @return The current status. 335 */ 336 public final Status getStatus() { 337 return mStatus; 338 } 339 340 /** 341 * Override this method to perform a computation on a background thread. The 342 * specified parameters are the parameters passed to {@link #execute} 343 * by the caller of this task. 344 * 345 * This method can call {@link #publishProgress} to publish updates 346 * on the UI thread. 347 * 348 * @param params The parameters of the task. 349 * 350 * @return A result, defined by the subclass of this task. 351 * 352 * @see #onPreExecute() 353 * @see #onPostExecute 354 * @see #publishProgress 355 */ 356 @WorkerThread 357 protected abstract Result doInBackground(Params... params); 358 359 /** 360 * Runs on the UI thread before {@link #doInBackground}. 361 * 362 * @see #onPostExecute 363 * @see #doInBackground 364 */ 365 @MainThread 366 protected void onPreExecute() { 367 } 368 369 /** 370 * <p>Runs on the UI thread after {@link #doInBackground}. The 371 * specified result is the value returned by {@link #doInBackground}.</p> 372 * 373 * <p>This method won't be invoked if the task was cancelled.</p> 374 * 375 * @param result The result of the operation computed by {@link #doInBackground}. 376 * 377 * @see #onPreExecute 378 * @see #doInBackground 379 * @see #onCancelled(Object) 380 */ 381 @SuppressWarnings({"UnusedDeclaration"}) 382 @MainThread 383 protected void onPostExecute(Result result) { 384 } 385 386 /** 387 * Runs on the UI thread after {@link #publishProgress} is invoked. 388 * The specified values are the values passed to {@link #publishProgress}. 389 * 390 * @param values The values indicating progress. 391 * 392 * @see #publishProgress 393 * @see #doInBackground 394 */ 395 @SuppressWarnings({"UnusedDeclaration"}) 396 @MainThread 397 protected void onProgressUpdate(Progress... values) { 398 } 399 400 /** 401 * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and 402 * {@link #doInBackground(Object[])} has finished.</p> 403 * 404 * <p>The default implementation simply invokes {@link #onCancelled()} and 405 * ignores the result. If you write your own implementation, do not call 406 * <code>super.onCancelled(result)</code>.</p> 407 * 408 * @param result The result, if any, computed in 409 * {@link #doInBackground(Object[])}, can be null 410 * 411 * @see #cancel(boolean) 412 * @see #isCancelled() 413 */ 414 @SuppressWarnings({"UnusedParameters"}) 415 @MainThread 416 protected void onCancelled(Result result) { 417 onCancelled(); 418 } 419 420 /** 421 * <p>Applications should preferably override {@link #onCancelled(Object)}. 422 * This method is invoked by the default implementation of 423 * {@link #onCancelled(Object)}.</p> 424 * 425 * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and 426 * {@link #doInBackground(Object[])} has finished.</p> 427 * 428 * @see #onCancelled(Object) 429 * @see #cancel(boolean) 430 * @see #isCancelled() 431 */ 432 @MainThread 433 protected void onCancelled() { 434 } 435 436 /** 437 * Returns <tt>true</tt> if this task was cancelled before it completed 438 * normally. If you are calling {@link #cancel(boolean)} on the task, 439 * the value returned by this method should be checked periodically from 440 * {@link #doInBackground(Object[])} to end the task as soon as possible. 441 * 442 * @return <tt>true</tt> if task was cancelled before it completed 443 * 444 * @see #cancel(boolean) 445 */ 446 public final boolean isCancelled() { 447 return mCancelled.get(); 448 } 449 450 /** 451 * <p>Attempts to cancel execution of this task. This attempt will 452 * fail if the task has already completed, already been cancelled, 453 * or could not be cancelled for some other reason. If successful, 454 * and this task has not started when <tt>cancel</tt> is called, 455 * this task should never run. If the task has already started, 456 * then the <tt>mayInterruptIfRunning</tt> parameter determines 457 * whether the thread executing this task should be interrupted in 458 * an attempt to stop the task.</p> 459 * 460 * <p>Calling this method will result in {@link #onCancelled(Object)} being 461 * invoked on the UI thread after {@link #doInBackground(Object[])} 462 * returns. Calling this method guarantees that {@link #onPostExecute(Object)} 463 * is never invoked. After invoking this method, you should check the 464 * value returned by {@link #isCancelled()} periodically from 465 * {@link #doInBackground(Object[])} to finish the task as early as 466 * possible.</p> 467 * 468 * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this 469 * task should be interrupted; otherwise, in-progress tasks are allowed 470 * to complete. 471 * 472 * @return <tt>false</tt> if the task could not be cancelled, 473 * typically because it has already completed normally; 474 * <tt>true</tt> otherwise 475 * 476 * @see #isCancelled() 477 * @see #onCancelled(Object) 478 */ 479 public final boolean cancel(boolean mayInterruptIfRunning) { 480 mCancelled.set(true); 481 return mFuture.cancel(mayInterruptIfRunning); 482 } 483 484 /** 485 * Waits if necessary for the computation to complete, and then 486 * retrieves its result. 487 * 488 * @return The computed result. 489 * 490 * @throws CancellationException If the computation was cancelled. 491 * @throws ExecutionException If the computation threw an exception. 492 * @throws InterruptedException If the current thread was interrupted 493 * while waiting. 494 */ 495 public final Result get() throws InterruptedException, ExecutionException { 496 return mFuture.get(); 497 } 498 499 /** 500 * Waits if necessary for at most the given time for the computation 501 * to complete, and then retrieves its result. 502 * 503 * @param timeout Time to wait before cancelling the operation. 504 * @param unit The time unit for the timeout. 505 * 506 * @return The computed result. 507 * 508 * @throws CancellationException If the computation was cancelled. 509 * @throws ExecutionException If the computation threw an exception. 510 * @throws InterruptedException If the current thread was interrupted 511 * while waiting. 512 * @throws TimeoutException If the wait timed out. 513 */ 514 public final Result get(long timeout, TimeUnit unit) throws InterruptedException, 515 ExecutionException, TimeoutException { 516 return mFuture.get(timeout, unit); 517 } 518 519 /** 520 * Executes the task with the specified parameters. The task returns 521 * itself (this) so that the caller can keep a reference to it. 522 * 523 * <p>Note: this function schedules the task on a queue for a single background 524 * thread or pool of threads depending on the platform version. When first 525 * introduced, AsyncTasks were executed serially on a single background thread. 526 * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed 527 * to a pool of threads allowing multiple tasks to operate in parallel. Starting 528 * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are back to being 529 * executed on a single thread to avoid common application errors caused 530 * by parallel execution. If you truly want parallel execution, you can use 531 * the {@link #executeOnExecutor} version of this method 532 * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings 533 * on its use. 534 * 535 * <p>This method must be invoked on the UI thread. 536 * 537 * @param params The parameters of the task. 538 * 539 * @return This instance of AsyncTask. 540 * 541 * @throws IllegalStateException If {@link #getStatus()} returns either 542 * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}. 543 * 544 * @see #executeOnExecutor(java.util.concurrent.Executor, Object[]) 545 * @see #execute(Runnable) 546 */ 547 @MainThread 548 public final AsyncTask<Params, Progress, Result> execute(Params... params) { 549 return executeOnExecutor(sDefaultExecutor, params); 550 } 551 552 /** 553 * Executes the task with the specified parameters. The task returns 554 * itself (this) so that the caller can keep a reference to it. 555 * 556 * <p>This method is typically used with {@link #THREAD_POOL_EXECUTOR} to 557 * allow multiple tasks to run in parallel on a pool of threads managed by 558 * AsyncTask, however you can also use your own {@link Executor} for custom 559 * behavior. 560 * 561 * <p><em>Warning:</em> Allowing multiple tasks to run in parallel from 562 * a thread pool is generally <em>not</em> what one wants, because the order 563 * of their operation is not defined. For example, if these tasks are used 564 * to modify any state in common (such as writing a file due to a button click), 565 * there are no guarantees on the order of the modifications. 566 * Without careful work it is possible in rare cases for the newer version 567 * of the data to be over-written by an older one, leading to obscure data 568 * loss and stability issues. Such changes are best 569 * executed in serial; to guarantee such work is serialized regardless of 570 * platform version you can use this function with {@link #SERIAL_EXECUTOR}. 571 * 572 * <p>This method must be invoked on the UI thread. 573 * 574 * @param exec The executor to use. {@link #THREAD_POOL_EXECUTOR} is available as a 575 * convenient process-wide thread pool for tasks that are loosely coupled. 576 * @param params The parameters of the task. 577 * 578 * @return This instance of AsyncTask. 579 * 580 * @throws IllegalStateException If {@link #getStatus()} returns either 581 * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}. 582 * 583 * @see #execute(Object[]) 584 */ 585 @MainThread 586 public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, 587 Params... params) { 588 if (mStatus != Status.PENDING) { 589 switch (mStatus) { 590 case RUNNING: 591 throw new IllegalStateException("Cannot execute task:" 592 + " the task is already running."); 593 case FINISHED: 594 throw new IllegalStateException("Cannot execute task:" 595 + " the task has already been executed " 596 + "(a task can be executed only once)"); 597 } 598 } 599 600 mStatus = Status.RUNNING; 601 602 onPreExecute(); 603 604 mWorker.mParams = params; 605 exec.execute(mFuture); 606 607 return this; 608 } 609 610 /** 611 * Convenience version of {@link #execute(Object...)} for use with 612 * a simple Runnable object. See {@link #execute(Object[])} for more 613 * information on the order of execution. 614 * 615 * @see #execute(Object[]) 616 * @see #executeOnExecutor(java.util.concurrent.Executor, Object[]) 617 */ 618 @MainThread 619 public static void execute(Runnable runnable) { 620 sDefaultExecutor.execute(runnable); 621 } 622 623 /** 624 * This method can be invoked from {@link #doInBackground} to 625 * publish updates on the UI thread while the background computation is 626 * still running. Each call to this method will trigger the execution of 627 * {@link #onProgressUpdate} on the UI thread. 628 * 629 * {@link #onProgressUpdate} will not be called if the task has been 630 * canceled. 631 * 632 * @param values The progress values to update the UI with. 633 * 634 * @see #onProgressUpdate 635 * @see #doInBackground 636 */ 637 @WorkerThread 638 protected final void publishProgress(Progress... values) { 639 if (!isCancelled()) { 640 getHandler().obtainMessage(MESSAGE_POST_PROGRESS, 641 new AsyncTaskResult<Progress>(this, values)).sendToTarget(); 642 } 643 } 644 645 private void finish(Result result) { 646 if (isCancelled()) { 647 onCancelled(result); 648 } else { 649 onPostExecute(result); 650 } 651 mStatus = Status.FINISHED; 652 } 653 654 private static class InternalHandler extends Handler { 655 public InternalHandler() { 656 super(Looper.getMainLooper()); 657 } 658 659 @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"}) 660 @Override 661 public void handleMessage(Message msg) { 662 AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj; 663 switch (msg.what) { 664 case MESSAGE_POST_RESULT: 665 // There is only one result 666 result.mTask.finish(result.mData[0]); 667 break; 668 case MESSAGE_POST_PROGRESS: 669 result.mTask.onProgressUpdate(result.mData); 670 break; 671 } 672 } 673 } 674 675 private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> { 676 Params[] mParams; 677 } 678 679 @SuppressWarnings({"RawUseOfParameterizedType"}) 680 private static class AsyncTaskResult<Data> { 681 final AsyncTask mTask; 682 final Data[] mData; 683 684 AsyncTaskResult(AsyncTask task, Data... data) { 685 mTask = task; 686 mData = data; 687 } 688 } 689} 690