+++ /dev/null
-/*
- * Copyright (C) 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.support.v2.content;
-
-import android.content.Context;
-import android.os.AsyncTask;
-import android.os.Handler;
-import android.os.SystemClock;
-import android.support.v2.util.TimeUtils;
-import android.util.Log;
-
-import java.io.FileDescriptor;
-import java.io.PrintWriter;
-import java.util.concurrent.CountDownLatch;
-
-/**
- * Static library support version of the framework's {@link android.content.AsyncTaskLoader}.
- * Used to write apps that run on platforms prior to Android 3.0. When running
- * on Android 3.0 or above, this implementation is still used; it does not try
- * to switch to the framework's implementation. See the framework SDK
- * documentation for a class overview.
- */
-public abstract class AsyncTaskLoader<D> extends Loader<D> {
- static final String TAG = "AsyncTaskLoader";
- static final boolean DEBUG = false;
-
- final class LoadTask extends AsyncTask<Void, Void, D> implements Runnable {
-
- D result;
- boolean waiting;
-
- private CountDownLatch done = new CountDownLatch(1);
-
- /* Runs on a worker thread */
- @Override
- protected D doInBackground(Void... params) {
- if (DEBUG) Log.v(TAG, this + " >>> doInBackground");
- result = AsyncTaskLoader.this.onLoadInBackground();
- if (DEBUG) Log.v(TAG, this + " <<< doInBackground");
- return result;
- }
-
- /* Runs on the UI thread */
- @Override
- protected void onPostExecute(D data) {
- if (DEBUG) Log.v(TAG, this + " onPostExecute");
- try {
- AsyncTaskLoader.this.dispatchOnLoadComplete(this, data);
- } finally {
- done.countDown();
- }
- }
-
- @Override
- protected void onCancelled() {
- if (DEBUG) Log.v(TAG, this + " onCancelled");
- try {
- AsyncTaskLoader.this.dispatchOnCancelled(this, result);
- } finally {
- done.countDown();
- }
- }
-
- @Override
- public void run() {
- waiting = false;
- AsyncTaskLoader.this.executePendingTask();
- }
- }
-
- volatile LoadTask mTask;
- volatile LoadTask mCancellingTask;
-
- long mUpdateThrottle;
- long mLastLoadCompleteTime = -10000;
- Handler mHandler;
-
- public AsyncTaskLoader(Context context) {
- super(context);
- }
-
- /**
- * Set amount to throttle updates by. This is the minimum time from
- * when the last {@link #onLoadInBackground()} call has completed until
- * a new load is scheduled.
- *
- * @param delayMS Amount of delay, in milliseconds.
- */
- public void setUpdateThrottle(long delayMS) {
- mUpdateThrottle = delayMS;
- if (delayMS != 0) {
- mHandler = new Handler();
- }
- }
-
- @Override
- protected void onForceLoad() {
- super.onForceLoad();
- cancelLoad();
- mTask = new LoadTask();
- if (DEBUG) Log.v(TAG, "Preparing load: mTask=" + mTask);
- executePendingTask();
- }
-
- /**
- * Attempt to cancel the current load task. See {@link AsyncTask#cancel(boolean)}
- * for more info. Must be called on the main thread of the process.
- *
- * <p>Cancelling 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 cancelled, 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 cancelled load is complete.
- *
- * @return Returns <tt>false</tt> if the task could not be cancelled,
- * typically because it has already completed normally, or
- * because {@link #startLoading()} hasn't been called; returns
- * <tt>true</tt> otherwise.
- */
- public boolean cancelLoad() {
- if (DEBUG) Log.v(TAG, "cancelLoad: mTask=" + mTask);
- if (mTask != null) {
- if (mCancellingTask != null) {
- // There was a pending task already waiting for a previous
- // one being canceled; just drop it.
- if (DEBUG) Log.v(TAG,
- "cancelLoad: still waiting for cancelled task; dropping next");
- if (mTask.waiting) {
- mTask.waiting = false;
- mHandler.removeCallbacks(mTask);
- }
- mTask = null;
- return false;
- } else if (mTask.waiting) {
- // There is a task, but it is waiting for the time it should
- // execute. We can just toss it.
- if (DEBUG) Log.v(TAG, "cancelLoad: task is waiting, dropping it");
- mTask.waiting = false;
- mHandler.removeCallbacks(mTask);
- mTask = null;
- return false;
- } else {
- boolean cancelled = mTask.cancel(false);
- if (DEBUG) Log.v(TAG, "cancelLoad: cancelled=" + cancelled);
- if (cancelled) {
- mCancellingTask = mTask;
- }
- mTask = null;
- return cancelled;
- }
- }
- return false;
- }
-
- /**
- * Called if the task was canceled before it was completed. Gives the class a chance
- * to properly dispose of the result.
- */
- public void onCanceled(D data) {
- }
-
- void executePendingTask() {
- if (mCancellingTask == null && mTask != null) {
- if (mTask.waiting) {
- mTask.waiting = false;
- mHandler.removeCallbacks(mTask);
- }
- if (mUpdateThrottle > 0) {
- long now = SystemClock.uptimeMillis();
- if (now < (mLastLoadCompleteTime+mUpdateThrottle)) {
- // Not yet time to do another load.
- if (DEBUG) Log.v(TAG, "Waiting until "
- + (mLastLoadCompleteTime+mUpdateThrottle)
- + " to execute: " + mTask);
- mTask.waiting = true;
- mHandler.postAtTime(mTask, mLastLoadCompleteTime+mUpdateThrottle);
- return;
- }
- }
- if (DEBUG) Log.v(TAG, "Executing: " + mTask);
- mTask.execute((Void[]) null);
- // XXX TO DO: use reflection to call this version.
- //mTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
- }
- }
-
- void dispatchOnCancelled(LoadTask task, D data) {
- onCanceled(data);
- if (mCancellingTask == task) {
- if (DEBUG) Log.v(TAG, "Cancelled task is now canceled!");
- mLastLoadCompleteTime = SystemClock.uptimeMillis();
- mCancellingTask = null;
- executePendingTask();
- }
- }
-
- void dispatchOnLoadComplete(LoadTask task, D data) {
- if (mTask != task) {
- if (DEBUG) Log.v(TAG, "Load complete of old task, trying to cancel");
- dispatchOnCancelled(task, data);
- } else {
- if (isAbandoned()) {
- // This cursor has been abandoned; just cancel the new data.
- onCanceled(data);
- } else {
- mLastLoadCompleteTime = SystemClock.uptimeMillis();
- mTask = null;
- if (DEBUG) Log.v(TAG, "Delivering result");
- deliverResult(data);
- }
- }
- }
-
- /**
- */
- public abstract D loadInBackground();
-
- /**
- * Called on a worker thread to perform the actual load. Implementations should not deliver the
- * result directly, but should return them from this method, which will eventually end up
- * calling {@link #deliverResult} on the UI thread. If implementations need to process
- * the results on the UI thread they may override {@link #deliverResult} and do so
- * there.
- *
- * @return Implementations must return the result of their load operation.
- */
- protected D onLoadInBackground() {
- return loadInBackground();
- }
-
- /**
- * Locks the current thread until the loader completes the current load
- * operation. Returns immediately if there is no load operation running.
- * Should not be called from the UI thread: calling it from the UI
- * thread would cause a deadlock.
- * <p>
- * Use for testing only. <b>Never</b> call this from a UI thread.
- *
- * @hide
- */
- public void waitForLoader() {
- LoadTask task = mTask;
- if (task != null) {
- try {
- task.done.await();
- } catch (InterruptedException e) {
- // Ignore
- }
- }
- }
-
- @Override
- public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
- super.dump(prefix, fd, writer, args);
- if (mTask != null) {
- writer.print(prefix); writer.print("mTask="); writer.print(mTask);
- writer.print(" waiting="); writer.println(mTask.waiting);
- }
- if (mCancellingTask != null) {
- writer.print(prefix); writer.print("mCancellingTask="); writer.print(mCancellingTask);
- writer.print(" waiting="); writer.println(mCancellingTask.waiting);
- }
- if (mUpdateThrottle != 0) {
- writer.print(prefix); writer.print("mUpdateThrottle=");
- TimeUtils.formatDuration(mUpdateThrottle, writer);
- writer.print(" mLastLoadCompleteTime=");
- TimeUtils.formatDuration(mLastLoadCompleteTime,
- SystemClock.uptimeMillis(), writer);
- writer.println();
- }
- }
-}
notaz.gp2x.de / android_pandora.git / blobdiff