Java 类android.support.v4.content.Loader.OnLoadCompleteListener 实例源码

/**
 * Runs a Loader synchronously and returns the result of the load. The loader will
 * be started, stopped, and destroyed by this method so it cannot be reused.
 *
 * @param loader The loader to run synchronously
 * @return The result from the loader
 */
public <T> T getLoaderResultSynchronously(final Loader<T> loader) {
  // The test thread blocks on this queue until the loader puts it's result in
  final ArrayBlockingQueue<AtomicReference<T>> queue = new ArrayBlockingQueue<AtomicReference<T>>(1);

  // This callback runs on the "main" thread and unblocks the test thread
  // when it puts the result into the blocking queue
  final OnLoadCompleteListener<T> listener = new OnLoadCompleteListener<T>() {
    @Override
    public void onLoadComplete(Loader<T> completedLoader, T data) {
      // Shut the loader down
      completedLoader.unregisterListener(this);
      completedLoader.stopLoading();
      completedLoader.reset();
      // Store the result, unblocking the test thread
      queue.add(new AtomicReference<T>(data));
    }
  };

  // This handler runs on the "main" thread of the process since AsyncTask
  // is documented as needing to run on the main thread and many Loaders use
  // AsyncTask
  final Handler mainThreadHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
      loader.registerListener(0, listener);
      loader.startLoading();
    }
  };

  // Ask the main thread to start the loading process
  mainThreadHandler.sendEmptyMessage(0);

  // Block on the queue waiting for the result of the load to be inserted
  T result;
  while (true) {
    try {
      result = queue.take().get();
      break;
    } catch (InterruptedException e) {
      throw new RuntimeException("waiting thread interrupted", e);
    }
  }
  return result;
}

/**
    * Runs a Loader synchronously and returns the result of the load. The loader will
    * be started, stopped, and destroyed by this method so it cannot be reused.
    *
    * @param loader The loader to run synchronously
    * @return The result from the loader
    */
   @SuppressLint("HandlerLeak")
public <T> T getLoaderResultSynchronously(final Loader<T> loader) {
       // The test thread blocks on this queue until the loader puts it's result in
       final ArrayBlockingQueue<T> queue = new ArrayBlockingQueue<T>(1);

       // This callback runs on the "main" thread and unblocks the test thread
       // when it puts the result into the blocking queue
       final OnLoadCompleteListener<T> listener = new OnLoadCompleteListener<T>() {
           @Override
           public void onLoadComplete(Loader<T> completedLoader, T data) {
               // Shut the loader down
               completedLoader.unregisterListener(this);
               completedLoader.stopLoading();
               completedLoader.reset();

               // Store the result, unblocking the test thread
               queue.add(data);
           }
       };

       // This handler runs on the "main" thread of the process since AsyncTask
       // is documented as needing to run on the main thread and many Loaders use
       // AsyncTask
       final Handler mainThreadHandler = new Handler(Looper.getMainLooper()) {
           @Override
           public void handleMessage(Message msg) {
               loader.registerListener(0, listener);
               loader.startLoading();
           }
       };

       // Ask the main thread to start the loading process
       mainThreadHandler.sendEmptyMessage(0);

       // Block on the queue waiting for the result of the load to be inserted
       T result;
       while (true) {
           try {
               result = queue.take();
               break;
           } catch (InterruptedException e) {
               throw new RuntimeException("waiting thread interrupted", e);
           }
       }

       return result;
   }