Add file stream api

Author: wangmengyan95

Parse/src/main/java/com/parse/GetDataStreamCallback.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015-present, Parse, LLC.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+package com.parse;
+
+import java.io.InputStream;
+
+/**
+ * A {@code GetDataStreamCallback} is used to run code after a {@link ParseFile} fetches its data on
+ * a background thread.
+ * <p/>
+ * The easiest way to use a {@code GetDataStreamCallback} is through an anonymous inner class.
+ * Override the {@code done} function to specify what the callback should do after the fetch is
+ * complete. The {@code done} function will be run in the UI thread, while the fetch happens in a
+ * background thread. This ensures that the UI does not freeze while the fetch happens.
+ * <p/>
+ * <pre>
+ * file.getDataStreamInBackground(new GetDataStreamCallback() {
+ *   public void done(InputSteam input, ParseException e) {
+ *     // ...
+ *   }
+ * });
+ * </pre>
+ */
+public interface GetDataStreamCallback extends ParseCallback2<InputStream, ParseException> {
+  /**
+   * Override this function with the code you want to run after the fetch is complete.
+   *
+   * @param input
+   *          The data that was retrieved, or {@code null} if it did not succeed.
+   * @param e
+   *          The exception raised by the fetch, or {@code null} if it succeeded.
+   */
+  @Override
+  public void done(InputStream input, ParseException e);
+}

Parse/src/main/java/com/parse/GetFileCallback.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015-present, Parse, LLC.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+package com.parse;
+
+import java.io.File;
+
+/**
+ * A {@code GetFileCallback} is used to run code after a {@link ParseFile} fetches its data on
+ * a background thread.
+ * <p/>
+ * The easiest way to use a {@code GetFileCallback} is through an anonymous inner class.
+ * Override the {@code done} function to specify what the callback should do after the fetch is 
+ * complete. The {@code done} function will be run in the UI thread, while the fetch happens in a
+ * background thread. This ensures that the UI does not freeze while the fetch happens.
+ * <p/>
+ * <pre>
+ * file.getFileInBackground(new GetFileCallback() {
+ *   public void done(File file, ParseException e) {
+ *     // ...
+ *   }
+ * });
+ * </pre>
+ */
+public interface GetFileCallback extends ParseCallback2<File, ParseException> {
+  /**
+   * Override this function with the code you want to run after the fetch is complete.
+   *
+   * @param file
+   *          The data that was retrieved, or {@code null} if it did not succeed.
+   * @param e
+   *          The exception raised by the fetch, or {@code null} if it succeeded.
+   */
+  @Override
+  public void done(File file, ParseException e);
+}

Parse/src/main/java/com/parse/ParseFile.java

@@ -12,7 +12,9 @@
 import org.json.JSONObject;
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
@@ -362,60 +364,14 @@ public void saveInBackground(SaveCallback callback) {
 
   /**
    * Synchronously gets the data for this object. You probably want to use
-   * {@link #getDataInBackground} instead unless you're already in a background thread.
+   * {@link #getDataInBackground()} instead unless you're already in a background thread.
    */
   public byte[] getData() throws ParseException {
     return ParseTaskUtils.wait(getDataInBackground());
   }
 
-  private Task<byte[]> getDataAsync(final ProgressCallback progressCallback, Task<Void> toAwait,
-      final Task<Void> cancellationToken) {
-    // If data is already available, just return immediately.
-    if (data != null) {
-      // in-memory
-      return Task.forResult(data);
-    }
-    if (cancellationToken != null && cancellationToken.isCancelled()) {
-      return Task.cancelled();
-    }
-
-    // Wait for our turn in the queue, and return immediately if data is now available.
-    return toAwait.continueWithTask(new Continuation<Void, Task<byte[]>>() {
-      @Override
-      public Task<byte[]> then(Task<Void> task) throws Exception {
-        // If data is already available, just return immediately.
-        if (data != null) {
-          // in-memory
-          return Task.forResult(data);
-        }
-        if (cancellationToken != null && cancellationToken.isCancelled()) {
-          return Task.cancelled();
-        }
-
-        return getFileController().fetchAsync(
-            state,
-            null,
-            progressCallbackOnMainThread(progressCallback),
-            cancellationToken).onSuccess(new Continuation<File, byte[]>() {
-              @Override
-              public byte[] then(Task<File> task) throws Exception {
-                File file = task.getResult();
-                try {
-                  data = ParseFileUtils.readFileToByteArray(file);
-                  return data;
-                } catch (IOException e) {
-                  // do nothing
-                }
-                return null;
-              }
-            });
-      }
-    });
-  }
-
   /**
-   * Gets the data for this object in a background thread. `progressCallback` is guaranteed to be
-   * called with 100 before dataCallback is called.
+   * Gets the data for this object in a background thread.
    *
    * @param progressCallback
    *          A ProgressCallback that is called periodically with progress updates.
@@ -428,7 +384,19 @@ public Task<byte[]> getDataInBackground(final ProgressCallback progressCallback)
     return taskQueue.enqueue(new Continuation<Void, Task<byte[]>>() {
       @Override
       public Task<byte[]> then(Task<Void> toAwait) throws Exception {
-        return getDataAsync(progressCallback, toAwait, cts.getTask());
+        return fetchInBackground(progressCallback, toAwait, cts.getTask()).onSuccess(new Continuation<File, byte[]>() {
+          @Override
+          public byte[] then(Task<File> task) throws Exception {
+            File file = task.getResult();
+            try {
+              data =  ParseFileUtils.readFileToByteArray(file);
+              return data;
+            } catch (IOException e) {
+              // do nothing
+            }
+            return null;
+          }
+        });
       }
     }).continueWithTask(new Continuation<byte[], Task<byte[]>>() {
       @Override
@@ -441,8 +409,7 @@ public Task<byte[]> then(Task<byte[]> task) throws Exception {
   }
 
   /**
-   * Gets the data for this object in a background thread. `progressCallback` is guaranteed to be
-   * called with 100 before dataCallback is called.
+   * Gets the data for this object in a background thread.
    *
    * @return A Task that is resolved when the data has been fetched.
    */
@@ -451,8 +418,7 @@ public Task<byte[]> getDataInBackground() {
   }
 
   /**
-   * Gets the data for this object in a background thread. `progressCallback` is guaranteed to be
-   * called with 100 before dataCallback is called.
+   * Gets the data for this object in a background thread.
    *
    * @param dataCallback
    *          A GetDataCallback that is called when the get completes.
@@ -474,6 +440,169 @@ public void getDataInBackground(GetDataCallback dataCallback) {
     ParseTaskUtils.callbackOnMainThreadAsync(getDataInBackground(), dataCallback);
   }
 
+  /**
+   * Synchronously gets the file pointer for this object. You probably want to use
+   * {@link #getFileInBackground()} instead unless you're already in a background thread.
+   */
+  public File getFile() throws ParseException {
+    return ParseTaskUtils.wait(getFileInBackground());
+  }
+
+  /**
+   * Gets the file pointer for this object in a background thread.
+   *
+   * @param progressCallback
+   *          A ProgressCallback that is called periodically with progress updates.
+   * @return A Task that is resolved when the file pointer of this object has been fetched.
+   */
+  public Task<File> getFileInBackground(final ProgressCallback progressCallback) {
+    final Task<Void>.TaskCompletionSource cts = Task.create();
+    currentTasks.add(cts);
+
+    return taskQueue.enqueue(new Continuation<Void, Task<File>>() {
+      @Override
+      public Task<File> then(Task<Void> toAwait) throws Exception {
+        return fetchInBackground(progressCallback, toAwait, cts.getTask());
+      }
+    }).continueWithTask(new Continuation<File, Task<File>>() {
+      @Override
+      public Task<File> then(Task<File> task) throws Exception {
+        cts.trySetResult(null); // release
+        currentTasks.remove(cts);
+        return task;
+      }
+    });
+  }
+
+  /**
+   * Gets the file pointer for this object in a background thread.
+   *
+   * @return A Task that is resolved when the data has been fetched.
+   */
+  public Task<File> getFileInBackground() {
+    return getFileInBackground((ProgressCallback)null);
+  }
+
+  /**
+   * Gets the file pointer for this object in a background thread. `progressCallback` is guaranteed
+   * to be called with 100 before `fileCallback` is called.
+   *
+   * @param fileCallback
+   *          A GetFileCallback that is called when the get completes.
+   * @param progressCallback
+   *          A ProgressCallback that is called periodically with progress updates.
+   */
+  public void getFileInBackground(GetFileCallback fileCallback,
+      final ProgressCallback progressCallback) {
+    ParseTaskUtils.callbackOnMainThreadAsync(getFileInBackground(progressCallback), fileCallback);
+  }
+
+  /**
+   * Gets the file pointer for this object in a background thread.
+   *
+   * @param fileCallback
+   *          A GetFileCallback that is called when the get completes.
+   */
+  public void getFileInBackground(GetFileCallback fileCallback) {
+    ParseTaskUtils.callbackOnMainThreadAsync(getFileInBackground(), fileCallback);
+  }
+
+  /**
+   * Synchronously gets the data stream for this object. You probably want to use
+   * {@link #getDataStreamInBackground} instead unless you're already in a background thread.
+   */
+  public InputStream getDataStream() throws ParseException {
+    return ParseTaskUtils.wait(getDataStreamInBackground());
+  }
+
+  /**
+   * Gets the data stream for this object in a background thread.
+   *
+   * @param progressCallback
+   *          A ProgressCallback that is called periodically with progress updates.
+   * @return A Task that is resolved when the data stream of this object has been fetched.
+   */
+  public Task<InputStream> getDataStreamInBackground(final ProgressCallback progressCallback) {
+    final Task<Void>.TaskCompletionSource cts = Task.create();
+    currentTasks.add(cts);
+
+    return taskQueue.enqueue(new Continuation<Void, Task<InputStream>>() {
+      @Override
+      public Task<InputStream> then(Task<Void> toAwait) throws Exception {
+        return fetchInBackground(progressCallback, toAwait, cts.getTask()).onSuccess(new Continuation<File, InputStream>() {
+          @Override
+          public InputStream then(Task<File> task) throws Exception {
+            return new FileInputStream(task.getResult());
+          }
+        });
+      }
+    }).continueWithTask(new Continuation<InputStream, Task<InputStream>>() {
+      @Override
+      public Task<InputStream> then(Task<InputStream> task) throws Exception {
+        cts.trySetResult(null); // release
+        currentTasks.remove(cts);
+        return task;
+      }
+    });
+  }
+
+  /**
+   * Gets the data stream for this object in a background thread.
+   *
+   * @return A Task that is resolved when the data stream has been fetched.
+   */
+  public Task<InputStream> getDataStreamInBackground() {
+    return getDataStreamInBackground((ProgressCallback) null);
+  }
+
+  /**
+   * Gets the data stream for this object in a background thread. `progressCallback` is guaranteed
+   * to be called with 100 before `dataStreamCallback` is called.
+   *
+   * @param dataStreamCallback
+   *          A GetDataCallback that is called when the get completes.
+   * @param progressCallback
+   *          A ProgressCallback that is called periodically with progress updates.
+   */
+  public void getDataStreamInBackground(GetDataStreamCallback dataStreamCallback,
+      final ProgressCallback progressCallback) {
+    ParseTaskUtils.callbackOnMainThreadAsync(
+        getDataStreamInBackground(progressCallback), dataStreamCallback);
+  }
+
+  /**
+   * Gets the data stream for this object in a background thread.
+   *
+   * @param dataStreamCallback
+   *          A GetDataCallback that is called when the get completes.
+   */
+  public void getDataStreamInBackground(GetDataStreamCallback dataStreamCallback) {
+    ParseTaskUtils.callbackOnMainThreadAsync(getDataStreamInBackground(), dataStreamCallback);
+  }
+
+  private Task<File> fetchInBackground(
+      final ProgressCallback progressCallback,
+      Task<Void> toAwait,
+      final Task<Void> cancellationToken) {
+    if (cancellationToken != null && cancellationToken.isCancelled()) {
+      return Task.cancelled();
+    }
+
+    return toAwait.continueWithTask(new Continuation<Void, Task<File>>() {
+      @Override
+      public Task<File> then(Task<Void> task) throws Exception {
+        if (cancellationToken != null && cancellationToken.isCancelled()) {
+          return Task.cancelled();
+        }
+        return getFileController().fetchAsync(
+            state,
+            null,
+            progressCallbackOnMainThread(progressCallback),
+            cancellationToken);
+      }
+    });
+  }
+
   /**
    * Cancels the current network request and callbacks whether it's uploading or fetching data from
    * the server.
@@ -490,7 +619,6 @@ public void cancel() {
   /*
    * Encode/Decode
    */
-
   @SuppressWarnings("unused")
   /* package */ ParseFile(JSONObject json, ParseDecoder decoder) {
     this(new State.Builder().name(json.optString("name")).url(json.optString("url")).build());