Add getResult Callback

Author: cherylEnkidu

Firestore/Source/API/FIRQuery.mm

@@ -63,6 +63,8 @@
 #include "Firestore/core/src/util/exception.h"
 #include "Firestore/core/src/util/statusor.h"
 #include "Firestore/core/src/util/string_apple.h"
+#include "Firestore/core/swift/include/pipeline.h"
+#include "Firestore/core/swift/include/pipeline_result.h"
 #include "absl/strings/match.h"
 
 namespace nanopb = firebase::firestore::nanopb;
@@ -71,6 +73,8 @@
 using firebase::firestore::google_firestore_v1_Value_fields;
 using firebase::firestore::api::Firestore;
 using firebase::firestore::api::MakeListenSource;
+using firebase::firestore::api::PipelineResult;
+using firebase::firestore::api::PipelineSnapshotListener;
 using firebase::firestore::api::Query;
 using firebase::firestore::api::QueryListenerRegistration;
 using firebase::firestore::api::QuerySnapshot;
@@ -175,6 +179,35 @@ - (void)getDocumentsWithCompletion:(void (^)(FIRQuerySnapshot *_Nullable snapsho
   _query.GetDocuments(Source::Default, [self wrapQuerySnapshotBlock:completion]);
 }
 
++ (PipelineSnapshotListener)
+    wrapPipelineCallback:(std::shared_ptr<api::Firestore>)firestore
+              completion:(void (^)(std::shared_ptr<std::vector<PipelineResult>> result,
+                                   NSError *_Nullable error))completion {
+  class Converter : public EventListener<std::vector<PipelineResult>> {
+   public:
+    explicit Converter(std::shared_ptr<api::Firestore> firestore, PipelineBlock completion)
+        : firestore_(firestore), completion_(completion) {
+    }
+
+    void OnEvent(StatusOr<std::vector<PipelineResult>> maybe_snapshot) override {
+      if (maybe_snapshot.ok()) {
+        completion_(
+            std::make_shared<std::vector<PipelineResult>>(
+                std::initializer_list<PipelineResult>{PipelineResult::GetTestResult(firestore_)}),
+            nullptr);
+      } else {
+        completion_(nullptr, MakeNSError(maybe_snapshot.status()));
+      }
+    }
+
+   private:
+    std::shared_ptr<api::Firestore> firestore_;
+    PipelineBlock completion_;
+  };
+
+  return absl::make_unique<Converter>(firestore, completion);
+}
+
 - (void)getDocumentsWithSource:(FIRFirestoreSource)publicSource
                     completion:(void (^)(FIRQuerySnapshot *_Nullable snapshot,
                                          NSError *_Nullable error))completion {
@@ -534,6 +567,29 @@ void OnEvent(StatusOr<QuerySnapshot> maybe_snapshot) override {
   return absl::make_unique<Converter>(block);
 }
 
++ (QuerySnapshotListener)wrapPipelineCallbackBlock:(FIRQuerySnapshotBlock)block {
+  class Converter : public EventListener<QuerySnapshot> {
+   public:
+    explicit Converter(FIRQuerySnapshotBlock block) : block_(block) {
+    }
+
+    void OnEvent(StatusOr<QuerySnapshot> maybe_snapshot) override {
+      if (maybe_snapshot.ok()) {
+        FIRQuerySnapshot *result =
+            [[FIRQuerySnapshot alloc] initWithSnapshot:std::move(maybe_snapshot).ValueOrDie()];
+        block_(result, nil);
+      } else {
+        block_(nil, MakeNSError(maybe_snapshot.status()));
+      }
+    }
+
+   private:
+    FIRQuerySnapshotBlock block_;
+  };
+
+  return absl::make_unique<Converter>(block);
+}
+
 - (Filter)parseFieldFilter:(FSTUnaryFilter *)unaryFilter {
   auto describer = [&unaryFilter] {
     return MakeString(NSStringFromClass([unaryFilter.value class]));

Firestore/Source/Public/FirebaseFirestore/FIRQuery.h

@@ -15,6 +15,7 @@
  */
 
 #import <Foundation/Foundation.h>
+#import <memory>
 
 #import "FIRFirestoreSource.h"
 #import "FIRListenerRegistration.h"
@@ -28,6 +29,24 @@
 @class FIRQuerySnapshot;
 @class FIRDocumentSnapshot;
 
+namespace firebase {
+namespace firestore {
+namespace api {
+class Firestore;
+class PipelineResult;
+}  // namespace api
+
+namespace core {
+template <typename T>
+class EventListener;
+}  // namespace core
+
+}  // namespace firestore
+}  // namespace firebase
+
+namespace api = firebase::firestore::api;
+namespace core = firebase::firestore::core;
+
 NS_ASSUME_NONNULL_BEGIN
 
 /**
@@ -37,6 +56,12 @@ typedef void (^FIRQuerySnapshotBlock)(FIRQuerySnapshot *_Nullable snapshot,
                                       NSError *_Nullable error)
     NS_SWIFT_UNAVAILABLE("Use Swift's closure syntax instead.");
 
+typedef void (^PipelineBlock)(std::shared_ptr<std::vector<api::PipelineResult>> result,
+                              NSError *_Nullable error)
+    NS_SWIFT_UNAVAILABLE("Use Swift's closure syntax instead.");
+
+typedef std::shared_ptr<std::vector<api::PipelineResult>> PipelineResultVectorPtr;
+
 /**
  * A `Query` refers to a query which you can read or listen to. You can also construct
  * refined `Query` objects by adding filters and ordering.
@@ -66,6 +91,11 @@ NS_SWIFT_NAME(Query)
     (void (^)(FIRQuerySnapshot *_Nullable snapshot, NSError *_Nullable error))completion
     NS_SWIFT_NAME(getDocuments(completion:));
 
++ (std::unique_ptr<core::EventListener<std::vector<api::PipelineResult>>>)
+    wrapPipelineCallback:(std::shared_ptr<api::Firestore>)firestore
+              completion:(void (^)(std::shared_ptr<std::vector<api::PipelineResult>> result,
+                                   NSError *_Nullable error))completion
+    NS_SWIFT_NAME(wrapPipelineCallback(firestore:completion:));
 /**
  * Reads the documents matching this query.
  *

Firestore/Swift/Source/SwiftAPI/Pipeline.swift

@@ -14,22 +14,18 @@ public class Pipeline {
   }
 
   @discardableResult
-  public func GetPipelineResult() async throws -> PipelineResult {
-//    return try await withCheckedThrowingContinuation { continuation in
-//
-//      let callback: (
-//        firebase.firestore.api.PipelineResult,
-//        Bool
-//      ) -> Void = { result, isSucceed in
-//        if isSucceed {
-//          continuation.resume(returning: PipelineResult(result))
-//        } else {
-//          continuation.resume(throwing: "ERROR!" as! Error)
-//        }
-//              }
-
-    // cppPtr.fetchDataWithCppCallback(callback)
-    return PipelineResult(firebase.firestore.api.PipelineResult
-      .GetTestResult(cppPtr.GetFirestore()))
+  public func GetPipelineResult() async throws -> [PipelineResult] {
+    return try await withCheckedThrowingContinuation { continuation in
+      let listener = Query.wrapPipelineCallback(firestore: cppPtr.GetFirestore()) {
+        result, error in
+        if let error {
+          continuation.resume(throwing: error)
+        } else {
+          // Our callbacks guarantee that we either return an error or a progress event.
+          continuation.resume(returning: PipelineResult.convertToArrayFromCppVector(result))
+        }
+      }
+      cppPtr.GetPipelineResult(listener)
+    }
   }
 }

Firestore/Swift/Source/SwiftAPI/PipelineResult.swift

@@ -5,10 +5,24 @@
 //  Created by Cheryl Lin on 2024-12-18.
 //
 
+@available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
 public class PipelineResult {
   let cppPtr: firebase.firestore.api.PipelineResult
 
   public init(_ cppSource: firebase.firestore.api.PipelineResult) {
     cppPtr = cppSource
   }
+
+  static func convertToArrayFromCppVector(_ vectorPtr: PipelineResultVectorPtr)
+    -> [PipelineResult] {
+    // Create a Swift array and populate it by iterating over the C++ vector
+    var swiftArray: [PipelineResult] = []
+
+    for index in vectorPtr.pointee.indices {
+      let cppResult = vectorPtr.pointee[index]
+      swiftArray.append(PipelineResult(cppResult))
+    }
+
+    return swiftArray
+  }
 }

Firestore/core/swift/include/pipeline.h

@@ -31,8 +31,7 @@ class Pipeline {
  public:
   Pipeline(std::shared_ptr<Firestore> firestore, Stage stage);
 
-  void GetPipelineResult(
-      std::function<void(PipelineResult, bool)> callback) const;
+  void GetPipelineResult(PipelineSnapshotListener callback) const;
 
   std::shared_ptr<Firestore> GetFirestore() const {
     return firestore_;

Firestore/core/swift/src/pipeline.cc

@@ -1,24 +1,78 @@
 #include "Firestore/core/swift/include/pipeline.h"
+
+#include <future>  // NOLINT(build/c++11)
+#include <memory>
+
 #include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/api/firestore.h"
+#include "Firestore/core/src/api/listener_registration.h"
+#include "Firestore/core/src/api/source.h"
 #include "Firestore/core/src/core/event_listener.h"
+#include "Firestore/core/src/core/listen_options.h"
+#include "Firestore/core/src/core/view_snapshot.h"
 #include "Firestore/core/swift/include/pipeline_result.h"
 
 namespace firebase {
 namespace firestore {
 
 namespace api {
 
+using core::EventListener;
+using core::ListenOptions;
+using core::ViewSnapshot;
+
 Pipeline::Pipeline(std::shared_ptr<Firestore> firestore, Stage stage)
     : firestore_(firestore), stage_(stage) {
 }
 
-void Pipeline::GetPipelineResult(
-    std::function<void(PipelineResult, bool)> callback) const {
-  callback(PipelineResult(firestore_, std::make_shared<Timestamp>(0, 0),
-                          std::make_shared<Timestamp>(0, 0),
-                          std::make_shared<Timestamp>(0, 0)),
-           true);
+void Pipeline::GetPipelineResult(PipelineSnapshotListener callback) const {
+  ListenOptions options(
+      /*include_query_metadata_changes=*/true,
+      /*include_document_metadata_changes=*/true,
+      /*wait_for_sync_when_online=*/true);
+
+  class ListenOnce : public EventListener<std::vector<PipelineResult>> {
+   public:
+    ListenOnce(PipelineSnapshotListener listener)
+        : listener_(std::move(listener)) {
+    }
+
+    void OnEvent(
+        StatusOr<std::vector<PipelineResult>> maybe_snapshot) override {
+      if (!maybe_snapshot.ok()) {
+        listener_->OnEvent(std::move(maybe_snapshot));
+        return;
+      }
+
+      std::vector<PipelineResult> snapshot =
+          std::move(maybe_snapshot).ValueOrDie();
+
+      // Remove query first before passing event to user to avoid user actions
+      // affecting the now stale query.
+      std::unique_ptr<ListenerRegistration> registration =
+          registration_promise_.get_future().get();
+      registration->Remove();
+
+      listener_->OnEvent(std::move(snapshot));
+    };
+
+    void Resolve(std::unique_ptr<ListenerRegistration> registration) {
+      registration_promise_.set_value(std::move(registration));
+    }
+
+   private:
+    PipelineSnapshotListener listener_;
+
+    std::promise<std::unique_ptr<ListenerRegistration>> registration_promise_;
+  };
+
+  auto listener = absl::make_unique<ListenOnce>(std::move(callback));
+  auto* listener_unowned = listener.get();
+
+  //  std::unique_ptr<ListenerRegistration> registration =
+  //      AddSnapshotListener(std::move(options), std::move(listener));
+  //
+  //  listener_unowned->Resolve(std::move(registration));
 }
 
 }  // namespace api