Plumb through error messages for Query and Document listens in C++ and Unity.

NOTE: This changelist is a breaking change in that it changes the public C++ Firestore API in a backwards-incompatible manner.
PiperOrigin-RevId: 330757239

Author: Googler

firestore/src/android/document_reference_android.cc

@@ -151,7 +151,8 @@ Future<void> DocumentReferenceInternal::Delete() {
 
 ListenerRegistration DocumentReferenceInternal::AddSnapshotListener(
     MetadataChanges metadata_changes,
-    std::function<void(const DocumentSnapshot&, Error)> callback) {
+    std::function<void(const DocumentSnapshot&, Error, const std::string&)>
+        callback) {
   LambdaEventListener<DocumentSnapshot>* listener =
       new LambdaEventListener<DocumentSnapshot>(firebase::Move(callback));
   return AddSnapshotListener(metadata_changes, listener,

firestore/src/android/document_reference_android.h

@@ -146,7 +146,8 @@ class DocumentReferenceInternal : public Wrapper {
    */
   ListenerRegistration AddSnapshotListener(
       MetadataChanges metadata_changes,
-      std::function<void(const DocumentSnapshot&, Error)> callback);
+      std::function<void(const DocumentSnapshot&, Error, const std::string&)>
+          callback);
 #endif  // defined(FIREBASE_USE_STD_FUNCTION)
 
   /**

firestore/src/android/event_listener_android.cc

@@ -10,6 +10,7 @@
 #include "firestore/src/android/firebase_firestore_exception_android.h"
 #include "firestore/src/android/query_snapshot_android.h"
 #include "firestore/src/android/util_android.h"
+#include "firestore/src/common/util.h"
 #include "firestore/src/include/firebase/firestore/query_snapshot.h"
 #include "firestore/src/jni/env.h"
 #include "firebase/firestore/firestore_errors.h"
@@ -65,15 +66,17 @@ void EventListenerInternal::DocumentEventListenerNativeOnEvent(
       reinterpret_cast<EventListener<DocumentSnapshot>*>(listener_ptr);
   Error error_code =
       FirebaseFirestoreExceptionInternal::ToErrorCode(env, error);
+  std::string error_message =
+      FirebaseFirestoreExceptionInternal::ToString(env, error);
   if (error_code != Error::kErrorOk) {
-    listener->OnEvent(DocumentSnapshot{}, error_code);
+    listener->OnEvent(DocumentSnapshot{}, error_code, error_message);
     return;
   }
 
   FirestoreInternal* firestore =
       reinterpret_cast<FirestoreInternal*>(firestore_ptr);
   DocumentSnapshot snapshot(new DocumentSnapshotInternal{firestore, value});
-  listener->OnEvent(snapshot, error_code);
+  listener->OnEvent(snapshot, error_code, error_message);
 }
 
 /* static */
@@ -87,15 +90,17 @@ void EventListenerInternal::QueryEventListenerNativeOnEvent(
       reinterpret_cast<EventListener<QuerySnapshot>*>(listener_ptr);
   Error error_code =
       FirebaseFirestoreExceptionInternal::ToErrorCode(env, error);
+  std::string error_message =
+      FirebaseFirestoreExceptionInternal::ToString(env, error);
   if (error_code != Error::kErrorOk) {
-    listener->OnEvent(QuerySnapshot{}, error_code);
+    listener->OnEvent(QuerySnapshot{}, error_code, error_message);
     return;
   }
 
   FirestoreInternal* firestore =
       reinterpret_cast<FirestoreInternal*>(firestore_ptr);
   QuerySnapshot snapshot(new QuerySnapshotInternal{firestore, value});
-  listener->OnEvent(snapshot, error_code);
+  listener->OnEvent(snapshot, error_code, error_message);
 }
 
 /* static */
@@ -108,7 +113,7 @@ void EventListenerInternal::VoidEventListenerNativeOnEvent(JNIEnv* env,
   EventListener<void>* listener =
       reinterpret_cast<EventListener<void>*>(listener_ptr);
 
-  listener->OnEvent(Error::kErrorOk);
+  listener->OnEvent(Error::kErrorOk, EmptyString());
 }
 
 Local<Object> EventListenerInternal::Create(

firestore/src/android/lambda_event_listener.h

@@ -18,17 +18,19 @@ namespace firestore {
 template <typename T>
 class LambdaEventListener : public EventListener<T> {
  public:
-  LambdaEventListener(std::function<void(const T&, Error)> callback)
+  LambdaEventListener(
+      std::function<void(const T&, Error, const std::string&)> callback)
       : callback_(firebase::Move(callback)) {
     FIREBASE_ASSERT(callback_);
   }
 
-  void OnEvent(const T& value, Error error) override {
-    callback_(value, error);
+  void OnEvent(const T& value, Error error_code,
+               const std::string& error_message) override {
+    callback_(value, error_code, error_message);
   }
 
  private:
-  std::function<void(const T&, Error)> callback_;
+  std::function<void(const T&, Error, const std::string&)> callback_;
 };
 
 template <>
@@ -39,7 +41,7 @@ class LambdaEventListener<void> : public EventListener<void> {
     FIREBASE_ASSERT(callback_);
   }
 
-  void OnEvent(Error) override { callback_(); }
+  void OnEvent(Error, const std::string&) override { callback_(); }
 
  private:
   std::function<void()> callback_;

firestore/src/android/query_android.cc

@@ -196,7 +196,8 @@ Query QueryInternal::WithBound(query::Method method,
 #if defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
 ListenerRegistration QueryInternal::AddSnapshotListener(
     MetadataChanges metadata_changes,
-    std::function<void(const QuerySnapshot&, Error)> callback) {
+    std::function<void(const QuerySnapshot&, Error, const std::string&)>
+        callback) {
   LambdaEventListener<QuerySnapshot>* listener =
       new LambdaEventListener<QuerySnapshot>(firebase::Move(callback));
   return AddSnapshotListener(metadata_changes, listener,

firestore/src/android/query_android.h

@@ -406,7 +406,8 @@ class QueryInternal : public Wrapper {
    */
   ListenerRegistration AddSnapshotListener(
       MetadataChanges metadata_changes,
-      std::function<void(const QuerySnapshot&, Error)> callback);
+      std::function<void(const QuerySnapshot&, Error, const std::string&)>
+          callback);
 
 #endif  // defined(FIREBASE_USE_STD_FUNCTION)
 

firestore/src/common/document_reference.cc

@@ -152,14 +152,16 @@ Future<void> DocumentReference::Delete() {
 
 #if defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
 ListenerRegistration DocumentReference::AddSnapshotListener(
-    std::function<void(const DocumentSnapshot&, Error)> callback) {
+    std::function<void(const DocumentSnapshot&, Error, const std::string&)>
+        callback) {
   return AddSnapshotListener(MetadataChanges::kExclude,
                              firebase::Move(callback));
 }
 
 ListenerRegistration DocumentReference::AddSnapshotListener(
     MetadataChanges metadata_changes,
-    std::function<void(const DocumentSnapshot&, Error)> callback) {
+    std::function<void(const DocumentSnapshot&, Error, const std::string&)>
+        callback) {
   FIREBASE_ASSERT_MESSAGE(callback, "invalid callback parameter is passed in.");
   if (!internal_) return {};
   return internal_->AddSnapshotListener(metadata_changes,

firestore/src/common/query.cc

@@ -244,14 +244,16 @@ Future<QuerySnapshot> Query::Get(Source source) const {
 
 #if defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
 ListenerRegistration Query::AddSnapshotListener(
-    std::function<void(const QuerySnapshot&, Error)> callback) {
+    std::function<void(const QuerySnapshot&, Error, const std::string&)>
+        callback) {
   return AddSnapshotListener(MetadataChanges::kExclude,
                              firebase::Move(callback));
 }
 
 ListenerRegistration Query::AddSnapshotListener(
     MetadataChanges metadata_changes,
-    std::function<void(const QuerySnapshot&, Error)> callback) {
+    std::function<void(const QuerySnapshot&, Error, const std::string&)>
+        callback) {
   FIREBASE_ASSERT_MESSAGE(callback, "invalid callback parameter is passed in.");
   if (!internal_) return {};
   return internal_->AddSnapshotListener(metadata_changes,

firestore/src/include/firebase/csharp/document_event_listener.cc

@@ -1,30 +1,21 @@
 #include "firebase/csharp/document_event_listener.h"
 
-#include "app/src/assert.h"
 #include "firebase/firestore/document_reference.h"
 
 namespace firebase {
 namespace firestore {
 namespace csharp {
 
-void DocumentEventListener::OnEvent(const DocumentSnapshot& value,
-                                    Error error) {
-  // Ownership of this pointer is passed into the C# handler
-  auto* copy = new DocumentSnapshot(value);
-
-  callback_(callback_id_, copy, error);
-}
-
-/* static */
-ListenerRegistration DocumentEventListener::AddListenerTo(
+ListenerRegistration AddDocumentSnapshotListener(
     DocumentReference* reference, MetadataChanges metadata_changes,
     int32_t callback_id, DocumentEventListenerCallback callback) {
-  DocumentEventListener listener(callback_id, callback);
-
   return reference->AddSnapshotListener(
       metadata_changes,
-      [listener](const DocumentSnapshot& value, Error error) mutable {
-        listener.OnEvent(value, error);
+      [callback, callback_id](const DocumentSnapshot& value, Error error_code,
+                              const std::string& error_message) {
+        // Ownership of the DocumentSnapshot pointer is passed to C#.
+        callback(callback_id, new DocumentSnapshot(value), error_code,
+                 error_message.c_str());
       });
 }
 

firestore/src/include/firebase/csharp/document_event_listener.h

@@ -1,14 +1,10 @@
 #ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_INCLUDE_FIREBASE_CSHARP_DOCUMENT_EVENT_LISTENER_H_
 #define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_INCLUDE_FIREBASE_CSHARP_DOCUMENT_EVENT_LISTENER_H_
 
-#include <cstdint>
-
-#include "app/src/callback.h"
-#include "app/src/mutex.h"
 #include "firebase/firestore/document_snapshot.h"
-#include "firebase/firestore/event_listener.h"
 #include "firebase/firestore/listener_registration.h"
 #include "firebase/firestore/metadata_changes.h"
+#include "firebase/firestore/firestore_errors.h"
 
 namespace firebase {
 namespace firestore {
@@ -25,33 +21,19 @@ namespace csharp {
 #endif
 
 // The callbacks that are used by the listener, that need to reach back to C#
-// callbacks.
-typedef void(SWIGSTDCALL* DocumentEventListenerCallback)(int callback_id,
-                                                         void* snapshot,
-                                                         Error error);
-
-// Provide a C++ implementation of the EventListener for DocumentSnapshot that
-// can forward the calls back to the C# delegates.
-class DocumentEventListener : public EventListener<DocumentSnapshot> {
- public:
-  explicit DocumentEventListener(int32_t callback_id,
-                                 DocumentEventListenerCallback callback)
-      : callback_id_(callback_id), callback_(callback) {}
-
-  void OnEvent(const DocumentSnapshot& value, Error error) override;
-
-  // This method is a proxy to DocumentReference::AddSnapshotListener()
-  // that can be easily called from C#. It allows our C# wrapper to
-  // track user callbacks in a dictionary keyed off of a unique int
-  // for each user callback and then raise the correct one later.
-  static ListenerRegistration AddListenerTo(
-      DocumentReference* reference, MetadataChanges metadata_changes,
-      int32_t callback_id, DocumentEventListenerCallback callback);
-
- private:
-  int32_t callback_id_;
-  DocumentEventListenerCallback callback_;
-};
+// callbacks. The error_message pointer is only valid for the duration of the
+// callback.
+typedef void(SWIGSTDCALL* DocumentEventListenerCallback)(
+    int callback_id, DocumentSnapshot* snapshot, Error error_code,
+    const char* error_message);
+
+// This method is a proxy to DocumentReference::AddSnapshotListener()
+// that can be easily called from C#. It allows our C# wrapper to
+// track user callbacks in a dictionary keyed off of a unique int
+// for each user callback and then raise the correct one later.
+ListenerRegistration AddDocumentSnapshotListener(
+    DocumentReference* reference, MetadataChanges metadata_changes,
+    int32_t callback_id, DocumentEventListenerCallback callback);
 
 }  // namespace csharp
 }  // namespace firestore