Feat: storage add in list command

Author: AustinBenoit

storage/CMakeLists.txt

@@ -19,6 +19,7 @@ set(common_SRCS
     src/common/common.cc
     src/common/controller.cc
     src/common/listener.cc
+    src/common/list_result.cc
     src/common/metadata.cc
     src/common/storage.cc
     src/common/storage_reference.cc

storage/integration_test/src/integration_test.cc

@@ -744,6 +744,71 @@ TEST_F(FirebaseStorageTest, TestDeleteFile) {
                     firebase::storage::kErrorObjectNotFound);
 }
 
+TEST_F(FirebaseStorageTest, TestList) {
+  SignIn();
+
+  firebase::storage::StorageReference ref = CreateFolder().Child("list_test");
+
+  // Upload a few files
+  const char* file_contents[] = {"file0", "file1", "file2"};
+  for (int i = 0; i < 3; ++i) {
+    char file_name[16];
+    snprintf(file_name, sizeof(file_name), "file_%d.txt", i);
+    firebase::storage::StorageReference file_ref = ref.Child(file_name);
+    firebase::Future<firebase::storage::Metadata> put_future =
+        file_ref.PutBytes(file_contents[i], strlen(file_contents[i]));
+    WaitForCompletion(put_future, "PutBytes");
+    EXPECT_EQ(put_future.error(), firebase::storage::kErrorNone);
+    cleanup_files_.push_back(file_ref);
+  }
+
+  // Upload to a subfolder to test prefixes
+  firebase::storage::StorageReference subfolder_ref = ref.Child("subfolder/sub_file.txt");
+  firebase::Future<firebase::storage::Metadata> subfolder_put_future =
+      subfolder_ref.PutBytes("sub", 3);
+  WaitForCompletion(subfolder_put_future, "PutBytes subfolder");
+  EXPECT_EQ(subfolder_put_future.error(), firebase::storage::kErrorNone);
+  cleanup_files_.push_back(subfolder_ref);
+
+  // Test List
+  LogDebug("Testing List");
+  firebase::Future<firebase::storage::StorageListResult> list_future = ref.List();
+  WaitForCompletionAnyResult(list_future, "List");
+  
+  if (list_future.error() != firebase::storage::kErrorNone) {
+      if (list_future.error() == firebase::storage::kErrorUnknown) {
+          LogWarning("Skipping TestList as the test project is likely using an older rules_version.");
+          return;
+      }
+      EXPECT_EQ(list_future.error(), firebase::storage::kErrorNone);
+  }
+
+  if (list_future.error() != firebase::storage::kErrorNone) return;
+
+  firebase::storage::StorageListResult result = *list_future.result();
+  EXPECT_EQ(result.items().size(), 3);
+  EXPECT_EQ(result.prefixes().size(), 1);
+  EXPECT_EQ(result.next_page_token(), "");
+
+  // Test Pagination
+  LogDebug("Testing List Pagination");
+  firebase::Future<firebase::storage::StorageListResult> page1_future = ref.List(2);
+  WaitForCompletionAnyResult(page1_future, "List Page 1");
+  EXPECT_EQ(page1_future.error(), firebase::storage::kErrorNone);
+  
+  firebase::storage::StorageListResult page1_result = *page1_future.result();
+  EXPECT_TRUE(page1_result.items().size() + page1_result.prefixes().size() == 2);
+  EXPECT_NE(page1_result.next_page_token(), "");
+
+  firebase::Future<firebase::storage::StorageListResult> page2_future = ref.List(2, page1_result.next_page_token().c_str());
+  WaitForCompletionAnyResult(page2_future, "List Page 2");
+  EXPECT_EQ(page2_future.error(), firebase::storage::kErrorNone);
+  
+  firebase::storage::StorageListResult page2_result = *page2_future.result();
+  EXPECT_TRUE(page2_result.items().size() + page2_result.prefixes().size() == 2);
+  EXPECT_EQ(page2_result.next_page_token(), "");
+}
+
 // Only test retries on desktop since Android and iOS don't have an option
 // to retry file-not-found errors and just pass-through to native
 // implementations.

storage/src/android/storage_reference_android.cc

@@ -86,6 +86,10 @@ namespace internal {
     "Lcom/google/firebase/storage/FileDownloadTask;"),                         \
   X(Delete, "delete",                                                          \
     "()Lcom/google/android/gms/tasks/Task;"),                                  \
+  X(List, "list",                                                              \
+    "(I)Lcom/google/android/gms/tasks/Task;"),                                 \
+  X(ListWithToken, "list",                                                     \
+    "(ILjava/lang/String;)Lcom/google/android/gms/tasks/Task;"),                \
   X(ToString, "toString",                                                      \
     "()Ljava/lang/String;")
 // clang-format on
@@ -96,6 +100,19 @@ METHOD_LOOKUP_DEFINITION(storage_reference,
                          "com/google/firebase/storage/StorageReference",
                          STORAGE_REFERENCE_METHODS)
 
+// clang-format off
+#define LIST_RESULT_METHODS(X)                                                 \
+  X(GetItems, "getItems", "()Ljava/util/List;"),                               \
+  X(GetPrefixes, "getPrefixes", "()Ljava/util/List;"),                         \
+  X(GetPageToken, "getPageToken", "()Ljava/lang/String;")
+// clang-format on
+
+METHOD_LOOKUP_DECLARATION(list_result, LIST_RESULT_METHODS)
+METHOD_LOOKUP_DEFINITION(list_result,
+                         PROGUARD_KEEP_CLASS
+                         "com/google/firebase/storage/ListResult",
+                         LIST_RESULT_METHODS)
+
 enum StorageReferenceFn {
   kStorageReferenceFnDelete = 0,
   kStorageReferenceFnGetBytes,
@@ -105,6 +122,7 @@ enum StorageReferenceFn {
   kStorageReferenceFnUpdateMetadata,
   kStorageReferenceFnPutBytes,
   kStorageReferenceFnPutFile,
+  kStorageReferenceFnList,
   kStorageReferenceFnCount,
 };
 
@@ -309,6 +327,49 @@ void StorageReferenceInternal::FutureCallback(JNIEnv* env, jobject result,
                     file_download_task_task_snapshot::kGetBytesTransferred));
     data->impl->Complete<size_t>(data->handle, kErrorNone, status_message,
                                  [bytes](size_t* size) { *size = bytes; });
+  } else if (result && env->IsInstanceOf(result, list_result::GetClass())) {
+    LogDebug("FutureCallback: Completing a Future from a ListResult.");
+    // Complete a Future<StorageListResult> from a Java ListResult object.
+    jobject prefixes_list = env->CallObjectMethod(
+        result, list_result::GetMethodId(list_result::kGetPrefixes));
+    jobject items_list = env->CallObjectMethod(
+        result, list_result::GetMethodId(list_result::kGetItems));
+    jstring page_token_jstr = static_cast<jstring>(env->CallObjectMethod(
+        result, list_result::GetMethodId(list_result::kGetPageToken)));
+
+    std::vector<StorageReference> prefixes;
+    std::vector<StorageReference> items;
+    std::string page_token = util::JStringToString(env, page_token_jstr);
+
+    if (prefixes_list) {
+      int size = env->CallIntMethod(prefixes_list, util::list::GetMethodId(util::list::kSize));
+      for (int i = 0; i < size; ++i) {
+        jobject ref_obj = env->CallObjectMethod(prefixes_list, util::list::GetMethodId(util::list::kGet), i);
+        prefixes.push_back(StorageReference(new StorageReferenceInternal(data->storage, ref_obj)));
+        env->DeleteLocalRef(ref_obj);
+      }
+      env->DeleteLocalRef(prefixes_list);
+    }
+
+    if (items_list) {
+      int size = env->CallIntMethod(items_list, util::list::GetMethodId(util::list::kSize));
+      for (int i = 0; i < size; ++i) {
+        jobject ref_obj = env->CallObjectMethod(items_list, util::list::GetMethodId(util::list::kGet), i);
+        items.push_back(StorageReference(new StorageReferenceInternal(data->storage, ref_obj)));
+        env->DeleteLocalRef(ref_obj);
+      }
+      env->DeleteLocalRef(items_list);
+    }
+
+    if (page_token_jstr) env->DeleteLocalRef(page_token_jstr);
+
+    data->impl->Complete<StorageListResult>(
+        data->handle, kErrorNone, status_message,
+        [prefixes, items, page_token](StorageListResult* list_result) {
+          internal::StorageListResultInternal* list_result_internal = new internal::StorageListResultInternal(
+              prefixes, items, page_token);
+          *list_result = internal::StorageListResultInternal::AsStorageListResult(list_result_internal);
+        });
   } else {
     LogDebug("FutureCallback: Completing a Future from a default result.");
     // Unknown or null result type, treat this as a Future<void> and just
@@ -541,6 +602,49 @@ Future<Metadata> StorageReferenceInternal::UpdateMetadataLastResult() {
       future()->LastResult(kStorageReferenceFnUpdateMetadata));
 }
 
+Future<StorageListResult> StorageReferenceInternal::List(
+    int max_results_per_page, const char* page_token) {
+  ReferenceCountedFutureImpl* future_impl = future();
+  FutureHandle handle = future_impl->Alloc<StorageListResult>(kStorageReferenceFnList);
+
+  JNIEnv* env = storage_->app()->GetJNIEnv();
+  jstring page_token_string =
+      page_token ? env->NewStringUTF(page_token) : nullptr;
+  jobject task = nullptr;
+
+  if (page_token_string) {
+    task = env->CallObjectMethod(
+        obj_, storage_reference::GetMethodId(storage_reference::kListWithToken),
+        (jint)max_results_per_page, page_token_string);
+    env->DeleteLocalRef(page_token_string);
+  } else {
+    task = env->CallObjectMethod(
+        obj_, storage_reference::GetMethodId(storage_reference::kList),
+        (jint)max_results_per_page);
+  }
+
+  if (util::LogException(env, kLogLevelWarning,
+                         "StorageReference::List(): Call to list() failed.")) {
+    future_impl->Complete(handle, kErrorUnknown, "Call to list() failed.");
+  } else {
+    util::RegisterCallbackOnTask(
+        env, task,
+        reinterpret_cast<util::TaskFinishedCallback>(
+            StorageReferenceInternal::FutureCallback),
+        new FutureCallbackData(handle, future_impl, storage_,
+                               kStorageReferenceFnList),
+        storage_resources::GetClass(storage_resources::kApiExecutor));
+  }
+  env->DeleteLocalRef(task);
+
+  return ListLastResult();
+}
+
+Future<StorageListResult> StorageReferenceInternal::ListLastResult() {
+  return static_cast<const Future<StorageListResult>&>(
+      future()->LastResult(kStorageReferenceFnList));
+}
+
 std::string StorageReferenceInternal::name() {
   JNIEnv* env = storage_->app()->GetJNIEnv();
   jstring name_jstring = static_cast<jstring>(env->CallObjectMethod(

storage/src/android/storage_reference_android.h

@@ -23,6 +23,7 @@
 #include "app/src/reference_counted_future_impl.h"
 #include "app/src/util_android.h"
 #include "storage/src/android/storage_android.h"
+#include "storage/src/include/firebase/storage/list_result.h"
 #include "storage/src/include/firebase/storage/storage_reference.h"
 
 namespace firebase {
@@ -129,6 +130,13 @@ class StorageReferenceInternal {
   // Returns the result of the most recent call to PutFile();
   Future<Metadata> PutFileLastResult();
 
+  // List items (files) and prefixes (folders) under this StorageReference.
+  Future<StorageListResult> List(int max_results_per_page,
+                                 const char* page_token);
+
+  // Returns the result of the most recent call to List();
+  Future<StorageListResult> ListLastResult();
+
   // Initialize JNI bindings for this class.
   static bool Initialize(App* app);
   static void Terminate(App* app);

storage/src/common/list_result.cc

@@ -0,0 +1,75 @@
+// Copyright 2019 Google LLC
+//
+// 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.
+
+#include "firebase/storage/list_result.h"
+#include "list_result_internal.h"
+
+namespace firebase {
+namespace storage {
+
+StorageListResult::StorageListResult() : internal_(nullptr) {}
+
+StorageListResult::~StorageListResult() {
+  delete internal_;
+  internal_ = nullptr;
+}
+
+StorageListResult::StorageListResult(const StorageListResult& other)
+    : internal_(other.internal_ ? new internal::StorageListResultInternal(*other.internal_)
+                               : nullptr) {}
+
+StorageListResult& StorageListResult::operator=(const StorageListResult& other) {
+  if (this != &other) {
+    delete internal_;
+    internal_ = other.internal_ ? new internal::StorageListResultInternal(*other.internal_)
+                                : nullptr;
+  }
+  return *this;
+}
+
+#if defined(FIREBASE_USE_MOVE_OPERATORS) || defined(DOXYGEN)
+StorageListResult::StorageListResult(StorageListResult&& other)
+    : internal_(other.internal_) {
+  other.internal_ = nullptr;
+}
+
+StorageListResult& StorageListResult::operator=(StorageListResult&& other) {
+  if (this != &other) {
+    delete internal_;
+    internal_ = other.internal_;
+    other.internal_ = nullptr;
+  }
+  return *this;
+}
+#endif  // defined(FIREBASE_USE_MOVE_OPERATORS) || defined(DOXYGEN)
+
+const std::vector<StorageReference>& StorageListResult::prefixes() const {
+  static const std::vector<StorageReference> empty_vector;
+  return internal_ ? internal_->prefixes_ : empty_vector;
+}
+
+const std::vector<StorageReference>& StorageListResult::items() const {
+  static const std::vector<StorageReference> empty_vector;
+  return internal_ ? internal_->items_ : empty_vector;
+}
+
+const std::string& StorageListResult::next_page_token() const {
+  static const std::string empty_string;
+  return internal_ ? internal_->next_page_token_ : empty_string;
+}
+
+bool StorageListResult::is_valid() const { return internal_ != nullptr; }
+
+}  // namespace storage
+}  // namespace firebase

storage/src/common/list_result_internal.h

@@ -0,0 +1,54 @@
+// Copyright 2019 Google LLC
+//
+// 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.
+
+#ifndef FIREBASE_STORAGE_SRC_COMMON_LIST_RESULT_INTERNAL_H_
+#define FIREBASE_STORAGE_SRC_COMMON_LIST_RESULT_INTERNAL_H_
+
+#include <string>
+#include <vector>
+
+#include "firebase/storage/storage_reference.h"
+
+namespace firebase {
+namespace storage {
+namespace internal {
+
+class StorageListResultInternal {
+ public:
+  StorageListResultInternal() {}
+
+  StorageListResultInternal(const std::vector<StorageReference>& prefixes,
+                            const std::vector<StorageReference>& items,
+                            const std::string& next_page_token)
+      : prefixes_(prefixes),
+        items_(items),
+        next_page_token_(next_page_token) {}
+
+  static StorageListResult AsStorageListResult(
+      StorageListResultInternal* internal) {
+    StorageListResult result;
+    result.internal_ = internal;
+    return result;
+  }
+
+  std::vector<StorageReference> prefixes_;
+  std::vector<StorageReference> items_;
+  std::string next_page_token_;
+};
+
+}  // namespace internal
+}  // namespace storage
+}  // namespace firebase
+
+#endif  // FIREBASE_STORAGE_SRC_COMMON_LIST_RESULT_INTERNAL_H_

storage/src/common/storage_reference.cc

@@ -246,6 +246,16 @@ Future<Metadata> StorageReference::PutFileLastResult() {
   return internal_ ? internal_->PutFileLastResult() : Future<Metadata>();
 }
 
+Future<StorageListResult> StorageReference::List(int max_results_per_page,
+                                                 const char* page_token) {
+  return internal_ ? internal_->List(max_results_per_page, page_token)
+                   : Future<StorageListResult>();
+}
+
+Future<StorageListResult> StorageReference::ListLastResult() {
+  return internal_ ? internal_->ListLastResult() : Future<StorageListResult>();
+}
+
 bool StorageReference::is_valid() const { return internal_ != nullptr; }
 
 }  // namespace storage