Add List storage API to Unity SDK (#1434)

* Add List API to Unity SDK

* Remove un needed vector refernce and add in the storage cmake change

* Fix Gemini Comments

* fix up testing to use aysnc pattern

Author: AustinBenoit

docs/readme.md

@@ -112,6 +112,7 @@ Release Notes
 ### Upcoming
 -   Changes
     - Firebase AI: Add support for Grounding with Google Maps.
+    - Storage: Added `ListAsync` API to list items and prefixes under a reference.
 
 ### 13.10.0
 -   Changes

storage/CMakeLists.txt

@@ -30,6 +30,7 @@ set(firebase_storage_src_documented
   src/StorageException.cs
   src/StorageProgress.cs
   src/StorageReference.cs
+  src/StorageListResult.cs
   src/UploadState.cs
 )
 

storage/src/StorageListResult.cs

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2026 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.
+ */
+
+using System;
+using System.Collections.Generic;
+using Firebase.Storage.Internal;
+
+namespace Firebase.Storage {
+  /// <summary>
+  /// Represents the result of a List operation.
+  /// </summary>
+  public sealed class StorageListResult {
+    private readonly StorageListResultInternal internalResult;
+    private readonly List<StorageReference> prefixes;
+    private readonly List<StorageReference> items;
+
+    internal StorageListResult(FirebaseStorage storage, StorageListResultInternal internalResult) {
+      this.internalResult = internalResult;
+
+      var prefixesCount = internalResult.prefixes_count();
+      prefixes = new List<StorageReference>((int)prefixesCount);
+      for (uint i = 0; i < prefixesCount; i++) {
+        prefixes.Add(new StorageReference(storage, internalResult.prefixes_get(i)));
+      }
+
+      var itemsCount = internalResult.items_count();
+      items = new List<StorageReference>((int)itemsCount);
+      for (uint i = 0; i < itemsCount; i++) {
+        items.Add(new StorageReference(storage, internalResult.items_get(i)));
+      }
+    }
+
+    /// <summary>
+    /// Gets the list of prefixes (folders) returned by the List operation.
+    /// </summary>
+    public IReadOnlyList<StorageReference> Prefixes { get { return prefixes; } }
+
+    /// <summary>
+    /// Gets the list of items (files) returned by the List operation.
+    /// </summary>
+    public IReadOnlyList<StorageReference> Items { get { return items; } }
+
+    /// <summary>
+    /// Gets a page token that can be used to resume the List operation, or an empty string if there are no more results.
+    /// </summary>
+    public string NextPageToken { get { return internalResult.next_page_token(); } }
+  }
+}

storage/src/StorageReference.cs

@@ -480,6 +480,33 @@ public Task<StorageMetadata> GetMetadataAsync() {
       return result.Task;
     }
 
+    /// <summary>
+    ///   Retrieves a list of prefixes and items under this
+    ///   <see cref="StorageReference" />
+    ///   .
+    /// </summary>
+    /// <param name="maxResults">The maximum number of items to return.</param>
+    /// <param name="pageToken">A page token to resume from.</param>
+    /// <returns>
+    ///   A <see cref="Task"/>
+    ///   which can be used to monitor the operation and obtain the result.
+    /// </returns>
+    public Task<StorageListResult> ListAsync(int maxResults = 1000, string pageToken = null) {
+      Task<StorageListResultInternal> internalTask;
+      if (pageToken != null) {
+        internalTask = Internal.ListAsync(maxResults, pageToken);
+      } else {
+        internalTask = Internal.ListAsync(maxResults);
+      }
+
+      var tcs = new TaskCompletionSource<StorageListResult>();
+      internalTask.ContinueWith(task => {
+          CompleteTask(task, tcs, () => { return new StorageListResult(this.Storage, task.Result); },
+                       "ListAsync");
+        });
+      return tcs.Task;
+    }
+
     /// <summary>
     ///   Retrieves a long lived download URL with a revokable token.
     /// </summary>

storage/src/swig/storage.i

@@ -71,6 +71,7 @@ static CppInstanceManager<Storage> g_storage_instances;
 %SWIG_FUTURE(Future_StorageMetadata, MetadataInternal, internal,
              firebase::storage::Metadata, FirebaseException)
 %SWIG_FUTURE(Future_Size, long, internal, size_t, FirebaseException)
+%SWIG_FUTURE(Future_StorageListResult, StorageListResultInternal, internal, firebase::storage::StorageListResult, FirebaseException)
 
 
 // TODO: Move this into App
@@ -160,10 +161,6 @@ static AttributeType& %mangle(Class) ##_## AttributeName ## _get_func(Class* sel
 %ignore firebase::storage::StorageReference::GetBytes;
 %ignore firebase::storage::StorageReference::PutBytes;
 %ignore firebase::storage::StorageReference::PutFile;
-// Ignore List methods and StorageListResult since StorageListResult is not wrapped yet.
-%ignore firebase::storage::StorageReference::List;
-%ignore firebase::storage::StorageReference::ListLastResult;
-%ignore firebase::storage::StorageListResult;
 
 // Remove the copy operator as the proxy uses the copy constructor.
 %ignore firebase::storage::StorageReference::operator=(const StorageReference&);
@@ -217,6 +214,7 @@ static AttributeType& %mangle(Class) ##_## AttributeName ## _get_func(Class* sel
   }
 }
 
+%rename("StorageListResultInternal") firebase::storage::StorageListResult;
 %rename("MetadataInternal") firebase::storage::Metadata;
 // Configure properties for get / set methods on the Metadata class.
 %safeattributestring(firebase::storage::Metadata, std::string, Bucket, bucket);
@@ -480,6 +478,17 @@ class MonitorController;
 %include "storage/src/include/firebase/storage/common.h"
 %include "storage/src/include/firebase/storage/controller.h"
 %include "storage/src/include/firebase/storage/listener.h"
+%ignore firebase::storage::StorageListResult::items;
+%ignore firebase::storage::StorageListResult::prefixes;
+
+%extend firebase::storage::StorageListResult {
+  size_t items_count() const { return self->items().size(); }
+  firebase::storage::StorageReference items_get(size_t index) const { return self->items()[index]; }
+  size_t prefixes_count() const { return self->prefixes().size(); }
+  firebase::storage::StorageReference prefixes_get(size_t index) const { return self->prefixes()[index]; }
+}
+
+%include "storage/src/include/firebase/storage/list_result.h"
 %include "storage/src/include/firebase/storage/metadata.h"
 %include "storage/src/include/firebase/storage/storage_reference.h"
 %include "storage/src/swig/monitor_controller.h"

storage/testapp/Assets/Firebase/Sample/Storage/UIHandlerAutomated.cs

@@ -140,6 +140,7 @@ protected override void Start() {
         TestUploadSmallFileAndDownloadToFile,
         TestUploadLargeFileAndDownloadToFile,
         TestUploadLargeFileAndDownloadToFileWithCancelation,
+        TestList,
       };
 
       testRunner = AutomatedTestRunner.CreateTestRunner(
@@ -1092,6 +1093,38 @@ Task TestUploadLargeFileAndDownloadToFileWithCancelation() {
           predownloadOperation: () => { CancelAfterDelayInSeconds(CANCELATION_DELAY_SECONDS); });
     }
 
-    // TODO: Upload and attempt to partially download a file.
+    async Task TestList() {
+      string baseFolder = "test_list_" + Guid.NewGuid().ToString() + "/";
+      string file1Path = baseFolder + "file1.txt";
+      string file2Path = baseFolder + "file2.txt";
+      string file3Path = baseFolder + "file3.txt";
+      string file4Path = baseFolder + "prefix/file4.txt";
+
+      // Upload files
+      await UploadToPath(file1Path, SMALL_FILE_CONTENTS, MetadataTestMode.None, UploadBytesAsync, ValidateUploadSuccessfulNotFile);
+      await UploadToPath(file2Path, SMALL_FILE_CONTENTS, MetadataTestMode.None, UploadBytesAsync, ValidateUploadSuccessfulNotFile);
+      await UploadToPath(file3Path, SMALL_FILE_CONTENTS, MetadataTestMode.None, UploadBytesAsync, ValidateUploadSuccessfulNotFile);
+      await UploadToPath(file4Path, SMALL_FILE_CONTENTS, MetadataTestMode.None, UploadBytesAsync, ValidateUploadSuccessfulNotFile);
+
+      // List with maxResultsPerPage: 2 to test pagination
+      var storageRef = FirebaseStorage.DefaultInstance.GetReference(baseFolder);
+      var result = await storageRef.ListAsync(maxResults: 2);
+      Assert("result != null", result != null);
+      
+      // We should get 2 items (order is not guaranteed, but we should have exactly 2)
+      AssertEq("result.Items.Count + result.Prefixes.Count", result.Items.Count + result.Prefixes.Count, 2);
+      Assert("result.NextPageToken != null", !string.IsNullOrEmpty(result.NextPageToken));
+
+      // Fetch page 2
+      var result2 = await storageRef.ListAsync(maxResults: 2, pageToken: result.NextPageToken);
+      AssertEq("result2.Items.Count + result2.Prefixes.Count", result2.Items.Count + result2.Prefixes.Count, 2); // 1 item remaining + 1 prefix
+      
+      // Verify we can find the prefix
+      bool foundPrefix = false;
+      foreach (var prefix in result2.Prefixes) {
+        if (prefix.Name == "prefix") foundPrefix = true;
+      }
+      Assert("foundPrefix", foundPrefix);
+    }
   }
 }