Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 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 | |
| 17 | package android.content; |
| 18 | |
| 19 | import android.os.AsyncTask; |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 20 | import android.os.Handler; |
| 21 | import android.os.SystemClock; |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 22 | import android.util.Slog; |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 23 | import android.util.TimeUtils; |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 24 | |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 25 | import java.io.FileDescriptor; |
| 26 | import java.io.PrintWriter; |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 27 | import java.util.concurrent.CountDownLatch; |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 28 | |
| 29 | /** |
| 30 | * Abstract Loader that provides an {@link AsyncTask} to do the work. |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 31 | * |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 32 | * @param <D> the data type to be loaded. |
| 33 | */ |
| 34 | public abstract class AsyncTaskLoader<D> extends Loader<D> { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 35 | static final String TAG = "AsyncTaskLoader"; |
| 36 | static final boolean DEBUG = false; |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 37 | |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 38 | final class LoadTask extends AsyncTask<Void, Void, D> implements Runnable { |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 39 | |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 40 | D result; |
| 41 | boolean waiting; |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 42 | |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 43 | private CountDownLatch done = new CountDownLatch(1); |
| 44 | |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 45 | /* Runs on a worker thread */ |
| 46 | @Override |
| 47 | protected D doInBackground(Void... params) { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 48 | if (DEBUG) Slog.v(TAG, this + " >>> doInBackground"); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 49 | result = AsyncTaskLoader.this.onLoadInBackground(); |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 50 | if (DEBUG) Slog.v(TAG, this + " <<< doInBackground"); |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 51 | return result; |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | /* Runs on the UI thread */ |
| 55 | @Override |
| 56 | protected void onPostExecute(D data) { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 57 | if (DEBUG) Slog.v(TAG, this + " onPostExecute"); |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 58 | try { |
| 59 | AsyncTaskLoader.this.dispatchOnLoadComplete(this, data); |
| 60 | } finally { |
| 61 | done.countDown(); |
| 62 | } |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 63 | } |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 64 | |
| 65 | @Override |
| 66 | protected void onCancelled() { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 67 | if (DEBUG) Slog.v(TAG, this + " onCancelled"); |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 68 | try { |
| 69 | AsyncTaskLoader.this.dispatchOnCancelled(this, result); |
| 70 | } finally { |
| 71 | done.countDown(); |
| 72 | } |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 73 | } |
| 74 | |
| 75 | @Override |
| 76 | public void run() { |
| 77 | waiting = false; |
| 78 | AsyncTaskLoader.this.executePendingTask(); |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 79 | } |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 80 | } |
| 81 | |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 82 | volatile LoadTask mTask; |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 83 | volatile LoadTask mCancellingTask; |
| 84 | |
| 85 | long mUpdateThrottle; |
| 86 | long mLastLoadCompleteTime = -10000; |
| 87 | Handler mHandler; |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 88 | |
| 89 | public AsyncTaskLoader(Context context) { |
| 90 | super(context); |
| 91 | } |
| 92 | |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 93 | /** |
| 94 | * Set amount to throttle updates by. This is the minimum time from |
| 95 | * when the last {@link #onLoadInBackground()} call has completed until |
| 96 | * a new load is scheduled. |
| 97 | * |
| 98 | * @param delayMS Amount of delay, in milliseconds. |
| 99 | */ |
| 100 | public void setUpdateThrottle(long delayMS) { |
| 101 | mUpdateThrottle = delayMS; |
| 102 | if (delayMS != 0) { |
| 103 | mHandler = new Handler(); |
| 104 | } |
| 105 | } |
| 106 | |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 107 | @Override |
Dianne Hackborn | a2ea747 | 2010-12-20 12:10:01 -0800 | [diff] [blame] | 108 | protected void onForceLoad() { |
Dianne Hackborn | 0e3b8f42 | 2010-12-20 23:22:11 -0800 | [diff] [blame] | 109 | super.onForceLoad(); |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 110 | cancelLoad(); |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 111 | mTask = new LoadTask(); |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 112 | if (DEBUG) Slog.v(TAG, "Preparing load: mTask=" + mTask); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 113 | executePendingTask(); |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | /** |
| 117 | * Attempt to cancel the current load task. See {@link AsyncTask#cancel(boolean)} |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 118 | * for more info. Must be called on the main thread of the process. |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 119 | * |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 120 | * <p>Cancelling is not an immediate operation, since the load is performed |
| 121 | * in a background thread. If there is currently a load in progress, this |
| 122 | * method requests that the load be cancelled, and notes this is the case; |
| 123 | * once the background thread has completed its work its remaining state |
| 124 | * will be cleared. If another load request comes in during this time, |
| 125 | * it will be held until the cancelled load is complete. |
| 126 | * |
| 127 | * @return Returns <tt>false</tt> if the task could not be cancelled, |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 128 | * typically because it has already completed normally, or |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 129 | * because {@link #startLoading()} hasn't been called; returns |
| 130 | * <tt>true</tt> otherwise. |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 131 | */ |
| 132 | public boolean cancelLoad() { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 133 | if (DEBUG) Slog.v(TAG, "cancelLoad: mTask=" + mTask); |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 134 | if (mTask != null) { |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 135 | if (mCancellingTask != null) { |
| 136 | // There was a pending task already waiting for a previous |
| 137 | // one being canceled; just drop it. |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 138 | if (DEBUG) Slog.v(TAG, |
| 139 | "cancelLoad: still waiting for cancelled task; dropping next"); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 140 | if (mTask.waiting) { |
| 141 | mTask.waiting = false; |
| 142 | mHandler.removeCallbacks(mTask); |
| 143 | } |
| 144 | mTask = null; |
| 145 | return false; |
| 146 | } else if (mTask.waiting) { |
| 147 | // There is a task, but it is waiting for the time it should |
| 148 | // execute. We can just toss it. |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 149 | if (DEBUG) Slog.v(TAG, "cancelLoad: task is waiting, dropping it"); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 150 | mTask.waiting = false; |
| 151 | mHandler.removeCallbacks(mTask); |
| 152 | mTask = null; |
| 153 | return false; |
| 154 | } else { |
| 155 | boolean cancelled = mTask.cancel(false); |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 156 | if (DEBUG) Slog.v(TAG, "cancelLoad: cancelled=" + cancelled); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 157 | if (cancelled) { |
| 158 | mCancellingTask = mTask; |
| 159 | } |
| 160 | mTask = null; |
| 161 | return cancelled; |
| 162 | } |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 163 | } |
| 164 | return false; |
| 165 | } |
Dmitri Plotnikov | bef9c7a | 2010-06-16 15:38:07 -0700 | [diff] [blame] | 166 | |
| 167 | /** |
| 168 | * Called if the task was canceled before it was completed. Gives the class a chance |
| 169 | * to properly dispose of the result. |
| 170 | */ |
Dianne Hackborn | 327fbd2 | 2011-01-17 14:38:50 -0800 | [diff] [blame] | 171 | public void onCanceled(D data) { |
Dianne Hackborn | 327fbd2 | 2011-01-17 14:38:50 -0800 | [diff] [blame] | 172 | } |
Dmitri Plotnikov | 4afde4f | 2011-01-18 09:41:29 -0800 | [diff] [blame] | 173 | |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 174 | void executePendingTask() { |
| 175 | if (mCancellingTask == null && mTask != null) { |
| 176 | if (mTask.waiting) { |
| 177 | mTask.waiting = false; |
| 178 | mHandler.removeCallbacks(mTask); |
| 179 | } |
| 180 | if (mUpdateThrottle > 0) { |
| 181 | long now = SystemClock.uptimeMillis(); |
| 182 | if (now < (mLastLoadCompleteTime+mUpdateThrottle)) { |
| 183 | // Not yet time to do another load. |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 184 | if (DEBUG) Slog.v(TAG, "Waiting until " |
| 185 | + (mLastLoadCompleteTime+mUpdateThrottle) |
| 186 | + " to execute: " + mTask); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 187 | mTask.waiting = true; |
| 188 | mHandler.postAtTime(mTask, mLastLoadCompleteTime+mUpdateThrottle); |
| 189 | return; |
| 190 | } |
| 191 | } |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 192 | if (DEBUG) Slog.v(TAG, "Executing: " + mTask); |
Dianne Hackborn | 5d9d03a | 2011-01-24 13:15:09 -0800 | [diff] [blame] | 193 | mTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 194 | } |
| 195 | } |
| 196 | |
| 197 | void dispatchOnCancelled(LoadTask task, D data) { |
Dianne Hackborn | 327fbd2 | 2011-01-17 14:38:50 -0800 | [diff] [blame] | 198 | onCanceled(data); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 199 | if (mCancellingTask == task) { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 200 | if (DEBUG) Slog.v(TAG, "Cancelled task is now canceled!"); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 201 | mLastLoadCompleteTime = SystemClock.uptimeMillis(); |
| 202 | mCancellingTask = null; |
| 203 | executePendingTask(); |
| 204 | } |
| 205 | } |
| 206 | |
Dianne Hackborn | 0e3b8f42 | 2010-12-20 23:22:11 -0800 | [diff] [blame] | 207 | void dispatchOnLoadComplete(LoadTask task, D data) { |
| 208 | if (mTask != task) { |
Dianne Hackborn | 540f86a | 2011-01-11 17:52:22 -0800 | [diff] [blame] | 209 | if (DEBUG) Slog.v(TAG, "Load complete of old task, trying to cancel"); |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 210 | dispatchOnCancelled(task, data); |
Dianne Hackborn | 0e3b8f42 | 2010-12-20 23:22:11 -0800 | [diff] [blame] | 211 | } else { |
Dianne Hackborn | 260c3c7 | 2011-01-30 16:55:55 -0800 | [diff] [blame] | 212 | if (isAbandoned()) { |
| 213 | // This cursor has been abandoned; just cancel the new data. |
| 214 | onCanceled(data); |
| 215 | } else { |
| 216 | mLastLoadCompleteTime = SystemClock.uptimeMillis(); |
| 217 | mTask = null; |
| 218 | if (DEBUG) Slog.v(TAG, "Delivering result"); |
| 219 | deliverResult(data); |
| 220 | } |
Dianne Hackborn | 0e3b8f42 | 2010-12-20 23:22:11 -0800 | [diff] [blame] | 221 | } |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | /** |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 225 | */ |
| 226 | public abstract D loadInBackground(); |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 227 | |
| 228 | /** |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 229 | * Called on a worker thread to perform the actual load. Implementations should not deliver the |
| 230 | * result directly, but should return them from this method, which will eventually end up |
| 231 | * calling {@link #deliverResult} on the UI thread. If implementations need to process |
| 232 | * the results on the UI thread they may override {@link #deliverResult} and do so |
| 233 | * there. |
| 234 | * |
| 235 | * @return Implementations must return the result of their load operation. |
| 236 | */ |
| 237 | protected D onLoadInBackground() { |
| 238 | return loadInBackground(); |
| 239 | } |
| 240 | |
| 241 | /** |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 242 | * Locks the current thread until the loader completes the current load |
| 243 | * operation. Returns immediately if there is no load operation running. |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 244 | * Should not be called from the UI thread: calling it from the UI |
| 245 | * thread would cause a deadlock. |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 246 | * <p> |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 247 | * Use for testing only. <b>Never</b> call this from a UI thread. |
Dmitri Plotnikov | 4afde4f | 2011-01-18 09:41:29 -0800 | [diff] [blame] | 248 | * |
| 249 | * @hide |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 250 | */ |
| 251 | public void waitForLoader() { |
| 252 | LoadTask task = mTask; |
| 253 | if (task != null) { |
| 254 | try { |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 255 | task.done.await(); |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 256 | } catch (InterruptedException e) { |
Dmitri Plotnikov | 59d8edd | 2011-01-09 11:05:50 -0800 | [diff] [blame] | 257 | // Ignore |
Dmitri Plotnikov | cd3676e | 2011-01-06 18:39:33 -0800 | [diff] [blame] | 258 | } |
| 259 | } |
| 260 | } |
Dianne Hackborn | 247fe74 | 2011-01-08 17:25:57 -0800 | [diff] [blame] | 261 | |
| 262 | @Override |
| 263 | public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { |
| 264 | super.dump(prefix, fd, writer, args); |
| 265 | if (mTask != null) { |
| 266 | writer.print(prefix); writer.print("mTask="); writer.print(mTask); |
| 267 | writer.print(" waiting="); writer.println(mTask.waiting); |
| 268 | } |
| 269 | if (mCancellingTask != null) { |
| 270 | writer.print(prefix); writer.print("mCancellingTask="); writer.print(mCancellingTask); |
| 271 | writer.print(" waiting="); writer.println(mCancellingTask.waiting); |
| 272 | } |
| 273 | if (mUpdateThrottle != 0) { |
| 274 | writer.print(prefix); writer.print("mUpdateThrottle="); |
| 275 | TimeUtils.formatDuration(mUpdateThrottle, writer); |
| 276 | writer.print(" mLastLoadCompleteTime="); |
| 277 | TimeUtils.formatDuration(mLastLoadCompleteTime, |
| 278 | SystemClock.uptimeMillis(), writer); |
| 279 | writer.println(); |
| 280 | } |
| 281 | } |
Jeff Hamilton | 9911b7f | 2010-05-15 02:20:31 -0500 | [diff] [blame] | 282 | } |