Cloud Firestore से रीयलटाइम अपडेट पाएं

onSnapshot() तरीके से, किसी दस्तावेज़ को सुना जा सकता है. आपके दिए गए कॉलबैक का इस्तेमाल करके, शुरुआती कॉल से दस्तावेज़ का स्नैपशॉट तुरंत बन जाता है. इसमें, किसी एक दस्तावेज़ का मौजूदा कॉन्टेंट शामिल होता है. इसके बाद, जब भी कॉन्टेंट में बदलाव होता है, तो एक और कॉल दस्तावेज़ के स्नैपशॉट को अपडेट करता है.

ध्यान दें: PHP क्लाइंट लाइब्रेरी में रीयलटाइम लिसनर काम नहीं करते.

Web

import { doc, onSnapshot } from "firebase/firestore";

const unsub = onSnapshot(doc(db, "cities", "SF"), (doc) => {
    console.log("Current data: ", doc.data());
});
listen_document.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

db.collection("cities").doc("SF")
    .onSnapshot((doc) => {
        console.log("Current data: ", doc.data());
    });
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

db.collection("cities").document("SF")
  .addSnapshotListener { documentSnapshot, error in
    guard let document = documentSnapshot else {
      print("Error fetching document: \(error!)")
      return
    }
    guard let data = document.data() else {
      print("Document data was empty.")
      return
    }
    print("Current data: \(data)")
  }
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

[[[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"]
    addSnapshotListener:^(FIRDocumentSnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error fetching document: %@", error);
        return;
      }
      NSLog(@"Current data: %@", snapshot.data);
    }];
ViewController.m

Kotlin

val docRef = db.collection("cities").document("SF")
docRef.addSnapshotListener { snapshot, e ->
    if (e != null) {
        Log.w(TAG, "Listen failed.", e)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d(TAG, "Current data: ${snapshot.data}")
    } else {
        Log.d(TAG, "Current data: null")
    }
}
DocSnippets.kt

Java

final DocumentReference docRef = db.collection("cities").document("SF");
docRef.addSnapshotListener(new EventListener<DocumentSnapshot>() {
    @Override
    public void onEvent(@Nullable DocumentSnapshot snapshot,
                        @Nullable FirebaseFirestoreException e) {
        if (e != null) {
            Log.w(TAG, "Listen failed.", e);
            return;
        }

        if (snapshot != null && snapshot.exists()) {
            Log.d(TAG, "Current data: " + snapshot.getData());
        } else {
            Log.d(TAG, "Current data: null");
        }
    }
});
DocSnippets.java

Dart

final docRef = db.collection("cities").doc("SF");
docRef.snapshots().listen(
      (event) => print("current data: ${event.data()}"),
      onError: (error) => print("Listen failed: $error"),
    );
firestore.dart

अक्सर, आपको अपने यूज़र इंटरफ़ेस (यूआई) को Firestore दस्तावेज़ या कलेक्शन के कॉन्टेंट में हुए बदलावों के हिसाब से बदलाव करना होता है. ऐसा करने के लिए, StreamBuilder ऐसे विजेट का इस्तेमाल करें जो Firestore की स्नैपशॉट स्ट्रीम का इस्तेमाल करता हो:

class UserInformation extends StatefulWidget {
  @override
  _UserInformationState createState() => _UserInformationState();
}

class _UserInformationState extends State<UserInformation> {
  final Stream<QuerySnapshot> _usersStream =
      FirebaseFirestore.instance.collection('users').snapshots();

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<QuerySnapshot>(
      stream: _usersStream,
      builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
        if (snapshot.hasError) {
          return const Text('Something went wrong');
        }

        if (snapshot.connectionState == ConnectionState.waiting) {
          return const Text("Loading");
        }

        return ListView(
          children: snapshot.data!.docs
              .map((DocumentSnapshot document) {
                Map<String, dynamic> data =
                    document.data()! as Map<String, dynamic>;
                return ListTile(
                  title: Text(data['full_name']),
                  subtitle: Text(data['company']),
                );
              })
              .toList()
              .cast(),
        );
      },
    );
  }
}
user_info_streambuilder.dart

Java

DocumentReference docRef = db.collection("cities").document("SF");
docRef.addSnapshotListener(
    new EventListener<DocumentSnapshot>() {
      @Override
      public void onEvent(@Nullable DocumentSnapshot snapshot, @Nullable FirestoreException e) {
        if (e != null) {
          System.err.println("Listen failed: " + e);
          return;
        }

        if (snapshot != null && snapshot.exists()) {
          System.out.println("Current data: " + snapshot.getData());
        } else {
          System.out.print("Current data: null");
        }
      }
    });
ListenDataSnippets.java

Python

# Create an Event for notifying main thread.
callback_done = threading.Event()

# Create a callback on_snapshot function to capture changes
def on_snapshot(doc_snapshot, changes, read_time):
    for doc in doc_snapshot:
        print(f"Received document snapshot: {doc.id}")
    callback_done.set()

doc_ref = db.collection("cities").document("SF")

# Watch the document
doc_watch = doc_ref.on_snapshot(on_snapshot)
snippets.py

C++

DocumentReference doc_ref = db->Collection("cities").Document("SF");
doc_ref.AddSnapshotListener(
    [](const DocumentSnapshot& snapshot, Error error, const std::string& errorMsg) {
      if (error == Error::kErrorOk) {
        if (snapshot.exists()) {
          std::cout << "Current data: " << snapshot << std::endl;
        } else {
          std::cout << "Current data: null" << std::endl;
        }
      } else {
        std::cout << "Listen failed: " << error << std::endl;
      }
    });
snippets.cpp

Node.js

const doc = db.collection('cities').doc('SF');

const observer = doc.onSnapshot(docSnapshot => {
  console.log(`Received doc snapshot: ${docSnapshot}`);
  // ...
}, err => {
  console.log(`Encountered error: ${err}`);
});
index.js

शुरू करें

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/firestore"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// listenDocument listens to a single document.
func listenDocument(ctx context.Context, w io.Writer, projectID, collection string) error {
	// projectID := "project-id"
	// Сontext with timeout stops listening to changes.
	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()

	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("firestore.NewClient: %w", err)
	}
	defer client.Close()

	it := client.Collection(collection).Doc("SF").Snapshots(ctx)
	for {
		snap, err := it.Next()
		// DeadlineExceeded will be returned when ctx is cancelled.
		if status.Code(err) == codes.DeadlineExceeded {
			return nil
		}
		if err != nil {
			return fmt.Errorf("Snapshots.Next: %w", err)
		}
		if !snap.Exists() {
			fmt.Fprintf(w, "Document no longer exists\n")
			return nil
		}
		fmt.Fprintf(w, "Received document snapshot: %v\n", snap.Data())
	}
}
listen_document.go

PHP

// Not supported in the PHP client library

Unity

DocumentReference docRef = db.Collection("cities").Document("SF");
docRef.Listen(snapshot => {
    Debug.Log("Callback received document snapshot.");
    Debug.Log(String.Format("Document data for {0} document:", snapshot.Id));
    Dictionary<string, object> city = snapshot.ToDictionary();
    foreach (KeyValuePair<string, object> pair in city) {
        Debug.Log(String.Format("{0}: {1}", pair.Key, pair.Value));
    }
});

C#

DocumentReference docRef = db.Collection("cities").Document("SF");
FirestoreChangeListener listener = docRef.Listen(snapshot =>
{
    Console.WriteLine("Callback received document snapshot.");
    Console.WriteLine("Document exists? {0}", snapshot.Exists);
    if (snapshot.Exists)
    {
        Console.WriteLine("Document data for {0} document:", snapshot.Id);
        Dictionary<string, object> city = snapshot.ToDictionary();
        foreach (KeyValuePair<string, object> pair in city)
        {
            Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
        }
    }
});
Program.cs

Ruby

doc_ref = firestore.col(collection_path).doc document_path
snapshots = []

# Watch the document.
listener = doc_ref.listen do |snapshot|
  puts "Received document snapshot: #{snapshot.document_id}"
  snapshots << snapshot
end
query_watch.rb

स्थानीय बदलावों के लिए इवेंट

आपके ऐप्लिकेशन में स्थानीय तौर पर डेटा सेव करने पर, स्नैपशॉट के लिसनर तुरंत ट्रिगर हो जाएंगे. ऐसा "इंतज़ार के समय को कम करने" की अहम सुविधा की वजह से होता है. डेटा लिखने पर, डेटा को बैकएंड पर भेजने से पहले, आपके दर्शकों को नए डेटा की सूचना दी जाएगी.

वापस लाए गए दस्तावेज़ों में metadata.hasPendingWrites प्रॉपर्टी होती है. इससे पता चलता है कि दस्तावेज़ में ऐसे स्थानीय बदलाव हुए हैं या नहीं जिन्हें अब तक बैकएंड में नहीं लिखा गया है. इस प्रॉपर्टी का इस्तेमाल करके, यह पता लगाया जा सकता है कि आपके स्नैपशॉट लिसनर को मिले इवेंट का सोर्स क्या है:

Web

import { doc, onSnapshot } from "firebase/firestore";

const unsub = onSnapshot(doc(db, "cities", "SF"), (doc) => {
  const source = doc.metadata.hasPendingWrites ? "Local" : "Server";
  console.log(source, " data: ", doc.data());
});
listen_document_local.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

db.collection("cities").doc("SF")
    .onSnapshot((doc) => {
        var source = doc.metadata.hasPendingWrites ? "Local" : "Server";
        console.log(source, " data: ", doc.data());
    });
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

db.collection("cities").document("SF")
  .addSnapshotListener { documentSnapshot, error in
    guard let document = documentSnapshot else {
      print("Error fetching document: \(error!)")
      return
    }
    let source = document.metadata.hasPendingWrites ? "Local" : "Server"
    print("\(source) data: \(document.data() ?? [:])")
  }
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

[[[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"]
    addSnapshotListener:^(FIRDocumentSnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error fetching document: %@", error);
        return;
      }
      NSString *source = snapshot.metadata.hasPendingWrites ? @"Local" : @"Server";
      NSLog(@"%@ data: %@", source, snapshot.data);
    }];
ViewController.m

Kotlin

val docRef = db.collection("cities").document("SF")
docRef.addSnapshotListener { snapshot, e ->
    if (e != null) {
        Log.w(TAG, "Listen failed.", e)
        return@addSnapshotListener
    }

    val source = if (snapshot != null && snapshot.metadata.hasPendingWrites()) {
        "Local"
    } else {
        "Server"
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d(TAG, "$source data: ${snapshot.data}")
    } else {
        Log.d(TAG, "$source data: null")
    }
}
DocSnippets.kt

Java

final DocumentReference docRef = db.collection("cities").document("SF");
docRef.addSnapshotListener(new EventListener<DocumentSnapshot>() {
    @Override
    public void onEvent(@Nullable DocumentSnapshot snapshot,
                        @Nullable FirebaseFirestoreException e) {
        if (e != null) {
            Log.w(TAG, "Listen failed.", e);
            return;
        }

        String source = snapshot != null && snapshot.getMetadata().hasPendingWrites()
                ? "Local" : "Server";

        if (snapshot != null && snapshot.exists()) {
            Log.d(TAG, source + " data: " + snapshot.getData());
        } else {
            Log.d(TAG, source + " data: null");
        }
    }
});
DocSnippets.java

Dart

final docRef = db.collection("cities").doc("SF");
docRef.snapshots().listen(
  (event) {
    final source = (event.metadata.hasPendingWrites) ? "Local" : "Server";
    print("$source data: ${event.data()}");
  },
  onError: (error) => print("Listen failed: $error"),
);
firestore.dart

Java

# Not yet supported in the Java client library

Python

// Not yet supported in Python client library

C++

DocumentReference doc_ref = db->Collection("cities").Document("SF");
doc_ref.AddSnapshotListener([](const DocumentSnapshot& snapshot,
                               Error error, const std::string& errorMsg) {
  if (error == Error::kErrorOk) {
    const char* source =
        snapshot.metadata().has_pending_writes() ? "Local" : "Server";
    if (snapshot.exists()) {
      std::cout << source << " data: " << snapshot.Get("name").string_value()
                << std::endl;
    } else {
      std::cout << source << " data: null" << std::endl;
    }
  } else {
    std::cout << "Listen failed: " << error << std::endl;
  }
});
snippets.cpp

Node.js

// Not yet supported in the Node.js client library

शुरू करें

// Not yet supported in the Go client library

PHP

// Not supported in the PHP client library

Unity

DocumentReference docRef = db.Collection("cities").Document("SF");
docRef.Listen(
  snapshot =>
  {
      string source = (snapshot != null && snapshot.Metadata.HasPendingWrites) ? "Local" : "Server";
      string snapshotData = "null";
      if (snapshot != null && snapshot.Exists)
      {
          System.Text.StringBuilder builder = new System.Text.StringBuilder();
          IDictionary<string, object> dict = snapshot.ToDictionary();
          foreach (var KVPair in dict)
          {
              builder.Append($"{KVPair.Key}: {KVPair.Value}\n");
          }
          snapshotData = builder.ToString();
      }
      Debug.Log($"{source} data: ${snapshotData}");
  });

C#

// Not yet supported in the C# client library

Ruby

// Not yet supported in the Ruby client library

मेटाडेटा में हुए बदलावों के लिए इवेंट

किसी दस्तावेज़, कलेक्शन या क्वेरी में होने वाले बदलावों को सुनते समय, लिसनर को मिलने वाले इवेंट की बारीकी को कंट्रोल करने के लिए, विकल्प दिए जा सकते हैं.

डिफ़ॉल्ट रूप से, सिर्फ़ मेटाडेटा पर असर डालने वाले बदलावों की सूचना, गाने सुनने वालों को नहीं दी जाती. देखें कि जब आपका ऐप्लिकेशन कोई नया दस्तावेज़ लिखता है, तो क्या होता है:

1. नए डेटा के साथ, बदलाव इवेंट तुरंत ट्रिगर हो जाता है. दस्तावेज़ को अब तक बैकएंड में नहीं लिखा गया है, इसलिए "लिखने की कार्रवाई बाकी है" फ़्लैग true है.
2. दस्तावेज़ को बैकएंड में लिखा जाता है.
3. बैकएंड, क्लाइंट को डेटा सेव होने की सूचना देता है. दस्तावेज़ के डेटा में कोई बदलाव नहीं हुआ है, लेकिन मेटाडेटा में बदलाव हुआ है, क्योंकि "लिखने की कार्रवाई बाकी है" फ़्लैग अब false है.

अगर आपको दस्तावेज़ या क्वेरी के मेटाडेटा में बदलाव होने पर स्नैपशॉट इवेंट चाहिए, तो अपने लिस्नर को अटैच करते समय, सुनने के विकल्पों का ऑब्जेक्ट पास करें.

ध्यान दें: नीचे दिए गए सैंपल में दिखाए गए तरीके से, दर्शकों को विकल्प दिए जा सकते हैं. मेटाडेटा में हुए बदलावों के लिए इवेंट को साफ़ तौर पर कॉन्फ़िगर करने के लिए, यहां बताए गए स्नैपशॉट के विकल्पों के लिए कॉन्फ़िगरेशन इंटरफ़ेस का भी इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, Kotlin + KTX Android, Java Android, Swift, Objective-C, और वेब मॉड्यूलर के लिए रेफ़रंस दस्तावेज़ देखें.

Web

import { doc, onSnapshot } from "firebase/firestore";

const unsub = onSnapshot(
  doc(db, "cities", "SF"), 
  { includeMetadataChanges: true }, 
  (doc) => {
    // ...
  });
listen_with_metadata.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

db.collection("cities").doc("SF")
    .onSnapshot({
        // Listen for document metadata changes
        includeMetadataChanges: true
    }, (doc) => {
        // ...
    });
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

// Listen to document metadata.
db.collection("cities").document("SF")
  .addSnapshotListener(includeMetadataChanges: true) { documentSnapshot, error in
    // ...
  }
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

// Listen for metadata changes.
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"]
    addSnapshotListenerWithIncludeMetadataChanges:YES
                                         listener:^(FIRDocumentSnapshot *snapshot, NSError *error) {
   // ...
}];
ViewController.m

Kotlin

// Listen for metadata changes to the document.
val docRef = db.collection("cities").document("SF")
docRef.addSnapshotListener(MetadataChanges.INCLUDE) { snapshot, e ->
    // ...
}
DocSnippets.kt

Java

// Listen for metadata changes to the document.
DocumentReference docRef = db.collection("cities").document("SF");
docRef.addSnapshotListener(MetadataChanges.INCLUDE, new EventListener<DocumentSnapshot>() {
    @Override
    public void onEvent(@Nullable DocumentSnapshot snapshot,
                        @Nullable FirebaseFirestoreException e) {
        // ...
    }
});
DocSnippets.java

Dart

final docRef = db.collection("cities").doc("SF");
docRef.snapshots(includeMetadataChanges: true).listen((event) {
  // ...
});
firestore.dart

Java

// Not yet supported in the Java client library

Python

// Not yet supported in Python client library

C++

DocumentReference doc_ref = db->Collection("cities").Document("SF");
doc_ref.AddSnapshotListener(
    MetadataChanges::kInclude,
    [](const DocumentSnapshot& snapshot, Error error, const std::string& errorMsg) { /* ... */ });
snippets.cpp

Node.js

// Not yet supported the Node.js client library

शुरू करें

// Not yet supported in the Go client library

PHP

// Not supported in the PHP client library

Unity

DocumentReference docRef = db.Collection("cities").Document("SF");
docRef.Listen(MetadataChanges.Include, snapshot =>
{
    // ...
});

C#

// Not yet supported in the C# client library

Ruby

// Not yet supported in the Ruby client library

ध्यान दें: अगर आपको सिर्फ़ यह जानना है कि डेटा कब लिखा गया, तो hasPendingWrites का इस्तेमाल करने के बजाय, डेटा लिखे जाने के बाद मिलने वाले कॉलबैक को सुना जा सकता है. JavaScript में, .then() कॉलबैक को अटैच करके, लिखने के ऑपरेशन से मिले Promise का इस्तेमाल करें. Swift में, अपने write फ़ंक्शन में पूरा होने का कॉलबैक पास करें.

सिर्फ़ स्थानीय बदलावों के लिए लिसनर कॉन्फ़िगर करना

Cloud Firestore स्नैपशॉट लिसनर, लोकल कैश मेमोरी से शुरुआती स्नैपशॉट लेते हैं और साथ ही, सर्वर से उससे जुड़ा डेटा फ़ेच करते हैं.

कुछ मामलों में, हो सकता है कि आपको सर्वर से फ़ॉलो-अप फ़ेच न चाहिए. क्लाइंट SDKs की मदद से, सिर्फ़ लोकल कैश मेमोरी में मौजूद डेटा के लिए, ट्रिगर होने वाले लिसनर को कॉन्फ़िगर किया जा सकता है. इससे आपको अनचाहे सर्वर कॉल और उनकी लागत से बचने में मदद मिलती है. साथ ही, क्लाइंट-साइड कैश मेमोरी का फ़ायदा भी मिलता है. इसमें स्थानीय डेटा और बदलावों की जानकारी दिखती है.

यहां क्लाइंट कोड में स्नैपशॉट के विकल्प सेट किए गए हैं, ताकि सिर्फ़ स्थानीय बदलावों को सुनने की अनुमति मिल सके.

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई से अपग्रेड करने के बारे में ज़्यादा जानें.

const unsubscribe = onSnapshot(
   doc(db, "cities", "SF"),
    { 
      includeMetadataChanges: true,
      source:'cache'
     },
    (documentSnapshot) => {//…}
  );

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई से अपग्रेड करने के बारे में ज़्यादा जानें.

// Not yet supported in the Web namespaced API

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

// Set up listener options
let options = SnapshotListenOptions()
    .withSource(ListenSource.cache)
    .withIncludeMetadataChanges(true)
db.collection("cities").document("SF")
  .addSnapshotListener(options: options) { documentSnapshot, error in
    // ...
  }

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

// Set up listener options
FIRSnapshotListenOptions *options = [[FIRSnapshotListenOptions alloc] init];
FIRSnapshotListenOptions *optionsWithSourceAndMetadata = 
                    [[options optionsWithIncludeMetadataChanges:YES] 
                      optionsWithSource:FIRListenSourceCache];
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"]
  addSnapshotListenerWithOptions:optionsWithSourceAndMetadata
  listener: ^ (FIRDocumentSnapshot * snapshot, NSError * error) {
    //…
  }
];

Kotlin

// Set up listener options
val options = SnapshotListenOptions.Builder()
  .setMetadataChanges(MetadataChanges.INCLUDE)
  .setSource(ListenSource.CACHE)
  .build();
db.collection("cities").document("SF")
  .addSnapshotListener(options) { snapshot, error ->
    //…
  }

Java

// Set up listener options
SnapshotListenOptions options = new SnapshotListenOptions.Builder()
  .setMetadataChanges(MetadataChanges.INCLUDE)
  .setSource(ListenSource.CACHE)
  .build();
db.collection("cities").document("SF").addSnapshotListener(options, new EventListener<DocumentSnapshot>() {
    //…
  });

Dart

// Not yet supported in this client library

Java

# Not yet supported in the Java client library

Python

// Not yet supported in Python client library

C++

// Not yet supported in the C++ client library

Node.js

// Not yet supported in the Node.js client library

शुरू करें

// Not yet supported in the Go client library

PHP

// Not yet supported in the PHP client library

Unity

// Not yet supported in the Unity client library

C#

// Not yet supported in the C# client library

Ruby

// Not yet supported in the Ruby client library

किसी कलेक्शन में मौजूद एक से ज़्यादा दस्तावेज़ों को सुनना

दस्तावेज़ों की तरह ही, क्वेरी के नतीजे सुनने के लिए, get() के बजाय onSnapshot() का इस्तेमाल किया जा सकता है. इससे क्वेरी का स्नैपशॉट बनता है. उदाहरण के लिए, CA स्थिति वाले दस्तावेज़ों को सुनने के लिए:

Web

import { collection, query, where, onSnapshot } from "firebase/firestore";

const q = query(collection(db, "cities"), where("state", "==", "CA"));
const unsubscribe = onSnapshot(q, (querySnapshot) => {
  const cities = [];
  querySnapshot.forEach((doc) => {
      cities.push(doc.data().name);
  });
  console.log("Current cities in CA: ", cities.join(", "));
});
listen_multiple.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

db.collection("cities").where("state", "==", "CA")
    .onSnapshot((querySnapshot) => {
        var cities = [];
        querySnapshot.forEach((doc) => {
            cities.push(doc.data().name);
        });
        console.log("Current cities in CA: ", cities.join(", "));
    });
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

db.collection("cities").whereField("state", isEqualTo: "CA")
  .addSnapshotListener { querySnapshot, error in
    guard let documents = querySnapshot?.documents else {
      print("Error fetching documents: \(error!)")
      return
    }
    let cities = documents.compactMap { $0["name"] }
    print("Current cities in CA: \(cities)")
  }
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

[[[self.db collectionWithPath:@"cities"] queryWhereField:@"state" isEqualTo:@"CA"]
    addSnapshotListener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error fetching documents: %@", error);
        return;
      }
      NSMutableArray *cities = [NSMutableArray array];
      for (FIRDocumentSnapshot *document in snapshot.documents) {
        [cities addObject:document.data[@"name"]];
      }
      NSLog(@"Current cities in CA: %@", cities);
    }];
ViewController.m

Kotlin

db.collection("cities")
    .whereEqualTo("state", "CA")
    .addSnapshotListener { value, e ->
        if (e != null) {
            Log.w(TAG, "Listen failed.", e)
            return@addSnapshotListener
        }

        val cities = ArrayList<String>()
        for (doc in value!!) {
            doc.getString("name")?.let {
                cities.add(it)
            }
        }
        Log.d(TAG, "Current cites in CA: $cities")
    }
DocSnippets.kt

Java

db.collection("cities")
        .whereEqualTo("state", "CA")
        .addSnapshotListener(new EventListener<QuerySnapshot>() {
            @Override
            public void onEvent(@Nullable QuerySnapshot value,
                                @Nullable FirebaseFirestoreException e) {
                if (e != null) {
                    Log.w(TAG, "Listen failed.", e);
                    return;
                }

                List<String> cities = new ArrayList<>();
                for (QueryDocumentSnapshot doc : value) {
                    if (doc.get("name") != null) {
                        cities.add(doc.getString("name"));
                    }
                }
                Log.d(TAG, "Current cites in CA: " + cities);
            }
        });
DocSnippets.java

Dart

db
    .collection("cities")
    .where("state", isEqualTo: "CA")
    .snapshots()
    .listen((event) {
  final cities = [];
  for (var doc in event.docs) {
    cities.add(doc.data()["name"]);
  }
  print("cities in CA: ${cities.join(", ")}");
});
firestore.dart

Java

db.collection("cities")
    .whereEqualTo("state", "CA")
    .addSnapshotListener(
        new EventListener<QuerySnapshot>() {
          @Override
          public void onEvent(
              @Nullable QuerySnapshot snapshots, @Nullable FirestoreException e) {
            if (e != null) {
              System.err.println("Listen failed:" + e);
              return;
            }

            List<String> cities = new ArrayList<>();
            for (DocumentSnapshot doc : snapshots) {
              if (doc.get("name") != null) {
                cities.add(doc.getString("name"));
              }
            }
            System.out.println("Current cites in CA: " + cities);
          }
        });
ListenDataSnippets.java

Python

# Create an Event for notifying main thread.
callback_done = threading.Event()

# Create a callback on_snapshot function to capture changes
def on_snapshot(col_snapshot, changes, read_time):
    print("Callback received query snapshot.")
    print("Current cities in California:")
    for doc in col_snapshot:
        print(f"{doc.id}")
    callback_done.set()

col_query = db.collection("cities").where(filter=FieldFilter("state", "==", "CA"))

# Watch the collection query
query_watch = col_query.on_snapshot(on_snapshot)
snippets.py

C++

db->Collection("cities")
    .WhereEqualTo("state", FieldValue::String("CA"))
    .AddSnapshotListener([](const QuerySnapshot& snapshot, Error error, const std::string& errorMsg) {
      if (error == Error::kErrorOk) {
        std::vector<std::string> cities;
        std::cout << "Current cities in CA: " << error << std::endl;
        for (const DocumentSnapshot& doc : snapshot.documents()) {
          cities.push_back(doc.Get("name").string_value());
          std::cout << "" << cities.back() << std::endl;
        }
      } else {
        std::cout << "Listen failed: " << error << std::endl;
      }
    });
snippets.cpp

Node.js

const query = db.collection('cities').where('state', '==', 'CA');

const observer = query.onSnapshot(querySnapshot => {
  console.log(`Received query snapshot of size ${querySnapshot.size}`);
  // ...
}, err => {
  console.log(`Encountered error: ${err}`);
});
index.js

शुरू करें

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/firestore"
	"google.golang.org/api/iterator"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// listenMultiple listens to a query, returning the names of all cities
// for a state.
func listenMultiple(ctx context.Context, w io.Writer, projectID, collection string) error {
	// projectID := "project-id"
	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()

	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("firestore.NewClient: %w", err)
	}
	defer client.Close()

	it := client.Collection(collection).Where("state", "==", "CA").Snapshots(ctx)
	for {
		snap, err := it.Next()
		// DeadlineExceeded will be returned when ctx is cancelled.
		if status.Code(err) == codes.DeadlineExceeded {
			return nil
		}
		if err != nil {
			return fmt.Errorf("Snapshots.Next: %w", err)
		}
		if snap != nil {
			for {
				doc, err := snap.Documents.Next()
				if err == iterator.Done {
					break
				}
				if err != nil {
					return fmt.Errorf("Documents.Next: %w", err)
				}
				fmt.Fprintf(w, "Current cities in California: %v\n", doc.Ref.ID)
			}
		}
	}
}
listen_multiple.go

PHP

// Not supported in the PHP client library

Unity

Query query = db.Collection("cities").WhereEqualTo("State", "CA");

ListenerRegistration listener = query.Listen(snapshot => {
  Debug.Log("Callback received query snapshot.");
  Debug.Log("Current cities in California:");
  foreach (DocumentSnapshot documentSnapshot in snapshot.Documents) {
    Debug.Log(documentSnapshot.Id);
  }
});

C#

CollectionReference citiesRef = db.Collection("cities");
Query query = db.Collection("cities").WhereEqualTo("State", "CA");

FirestoreChangeListener listener = query.Listen(snapshot =>
{
    Console.WriteLine("Callback received query snapshot.");
    Console.WriteLine("Current cities in California:");
    foreach (DocumentSnapshot documentSnapshot in snapshot.Documents)
    {
        Console.WriteLine(documentSnapshot.Id);
    }
});
Program.cs

Ruby

query = firestore.col(collection_path).where :state, :==, "CA"
docs = []

# Watch the collection query.
listener = query.listen do |snapshot|
  puts "Callback received query snapshot."
  puts "Current cities in California:"
  snapshot.docs.each do |doc|
    puts doc.document_id
    docs << doc
  end
end
query_watch.rb

जब भी क्वेरी के नतीजे बदलेंगे, तो स्नैपशॉट हैंडलर को एक नया क्वेरी स्नैपशॉट मिलेगा. इसका मतलब है कि जब कोई दस्तावेज़ जोड़ा जाएगा, हटाया जाएगा या उसमें बदलाव किया जाएगा.

अहम जानकारी: जैसा कि ऊपर लोकल डेटा में बदलाव होने पर सूचना देने वाले इवेंट में बताया गया है, आपको लोकल डेटा में किए गए बदलावों के लिए तुरंत इवेंट मिलेंगे. आपका दर्शक हर दस्तावेज़ पर metadata.hasPendingWrites फ़ील्ड का इस्तेमाल करके यह पता लगा सकता है कि दस्तावेज़ में ऐसे स्थानीय बदलाव हुए हैं या नहीं जिन्हें अब तक बैकएंड में नहीं डाला गया है.

स्नैपशॉट के बीच हुए बदलाव देखना

आम तौर पर, क्वेरी के पूरे स्नैपशॉट का इस्तेमाल करने के बजाय, क्वेरी के स्नैपशॉट के बीच क्वेरी के नतीजों में हुए असल बदलावों को देखना ज़्यादा मददगार होता है. उदाहरण के लिए, हो सकता है कि आप अलग-अलग दस्तावेज़ों को जोड़ने, हटाने, और उनमें बदलाव करने के बाद, कैश मेमोरी को बनाए रखना चाहें.

Web

import { collection, query, where, onSnapshot } from "firebase/firestore";

const q = query(collection(db, "cities"), where("state", "==", "CA"));
const unsubscribe = onSnapshot(q, (snapshot) => {
  snapshot.docChanges().forEach((change) => {
    if (change.type === "added") {
        console.log("New city: ", change.doc.data());
    }
    if (change.type === "modified") {
        console.log("Modified city: ", change.doc.data());
    }
    if (change.type === "removed") {
        console.log("Removed city: ", change.doc.data());
    }
  });
});
listen_diffs.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

db.collection("cities").where("state", "==", "CA")
    .onSnapshot((snapshot) => {
        snapshot.docChanges().forEach((change) => {
            if (change.type === "added") {
                console.log("New city: ", change.doc.data());
            }
            if (change.type === "modified") {
                console.log("Modified city: ", change.doc.data());
            }
            if (change.type === "removed") {
                console.log("Removed city: ", change.doc.data());
            }
        });
    });
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

db.collection("cities").whereField("state", isEqualTo: "CA")
  .addSnapshotListener { querySnapshot, error in
    guard let snapshot = querySnapshot else {
      print("Error fetching snapshots: \(error!)")
      return
    }
    snapshot.documentChanges.forEach { diff in
      if (diff.type == .added) {
        print("New city: \(diff.document.data())")
      }
      if (diff.type == .modified) {
        print("Modified city: \(diff.document.data())")
      }
      if (diff.type == .removed) {
        print("Removed city: \(diff.document.data())")
      }
    }
  }
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

[[[self.db collectionWithPath:@"cities"] queryWhereField:@"state" isEqualTo:@"CA"]
    addSnapshotListener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error fetching documents: %@", error);
        return;
      }
      for (FIRDocumentChange *diff in snapshot.documentChanges) {
        if (diff.type == FIRDocumentChangeTypeAdded) {
          NSLog(@"New city: %@", diff.document.data);
        }
        if (diff.type == FIRDocumentChangeTypeModified) {
          NSLog(@"Modified city: %@", diff.document.data);
        }
        if (diff.type == FIRDocumentChangeTypeRemoved) {
          NSLog(@"Removed city: %@", diff.document.data);
        }
      }
    }];
ViewController.m

Kotlin

db.collection("cities")
    .whereEqualTo("state", "CA")
    .addSnapshotListener { snapshots, e ->
        if (e != null) {
            Log.w(TAG, "listen:error", e)
            return@addSnapshotListener
        }

        for (dc in snapshots!!.documentChanges) {
            when (dc.type) {
                DocumentChange.Type.ADDED -> Log.d(TAG, "New city: ${dc.document.data}")
                DocumentChange.Type.MODIFIED -> Log.d(TAG, "Modified city: ${dc.document.data}")
                DocumentChange.Type.REMOVED -> Log.d(TAG, "Removed city: ${dc.document.data}")
            }
        }
    }
DocSnippets.kt

Java

db.collection("cities")
        .whereEqualTo("state", "CA")
        .addSnapshotListener(new EventListener<QuerySnapshot>() {
            @Override
            public void onEvent(@Nullable QuerySnapshot snapshots,
                                @Nullable FirebaseFirestoreException e) {
                if (e != null) {
                    Log.w(TAG, "listen:error", e);
                    return;
                }

                for (DocumentChange dc : snapshots.getDocumentChanges()) {
                    switch (dc.getType()) {
                        case ADDED:
                            Log.d(TAG, "New city: " + dc.getDocument().getData());
                            break;
                        case MODIFIED:
                            Log.d(TAG, "Modified city: " + dc.getDocument().getData());
                            break;
                        case REMOVED:
                            Log.d(TAG, "Removed city: " + dc.getDocument().getData());
                            break;
                    }
                }

            }
        });
DocSnippets.java

Dart

db
    .collection("cities")
    .where("state", isEqualTo: "CA")
    .snapshots()
    .listen((event) {
  for (var change in event.docChanges) {
    switch (change.type) {
      case DocumentChangeType.added:
        print("New City: ${change.doc.data()}");
        break;
      case DocumentChangeType.modified:
        print("Modified City: ${change.doc.data()}");
        break;
      case DocumentChangeType.removed:
        print("Removed City: ${change.doc.data()}");
        break;
    }
  }
});
firestore.dart

Java

db.collection("cities")
    .whereEqualTo("state", "CA")
    .addSnapshotListener(
        new EventListener<QuerySnapshot>() {
          @Override
          public void onEvent(
              @Nullable QuerySnapshot snapshots, @Nullable FirestoreException e) {
            if (e != null) {
              System.err.println("Listen failed: " + e);
              return;
            }

            for (DocumentChange dc : snapshots.getDocumentChanges()) {
              switch (dc.getType()) {
                case ADDED:
                  System.out.println("New city: " + dc.getDocument().getData());
                  break;
                case MODIFIED:
                  System.out.println("Modified city: " + dc.getDocument().getData());
                  break;
                case REMOVED:
                  System.out.println("Removed city: " + dc.getDocument().getData());
                  break;
                default:
                  break;
              }
            }
          }
        });
ListenDataSnippets.java

C++

db->Collection("cities")
    .WhereEqualTo("state", FieldValue::String("CA"))
    .AddSnapshotListener([](const QuerySnapshot& snapshot, Error error, const std::string& errorMsg) {
      if (error == Error::kErrorOk) {
        for (const DocumentChange& dc : snapshot.DocumentChanges()) {
          switch (dc.type()) {
            case DocumentChange::Type::kAdded:
              std::cout << "New city: "
                        << dc.document().Get("name").string_value() << std::endl;
              break;
            case DocumentChange::Type::kModified:
              std::cout << "Modified city: "
                        << dc.document().Get("name").string_value() << std::endl;
              break;
            case DocumentChange::Type::kRemoved:
              std::cout << "Removed city: "
                        << dc.document().Get("name").string_value() << std::endl;
              break;
          }
        }
      } else {
        std::cout << "Listen failed: " << error << std::endl;
      }
    });
snippets.cpp

Python

# Create an Event for notifying main thread.
delete_done = threading.Event()

# Create a callback on_snapshot function to capture changes
def on_snapshot(col_snapshot, changes, read_time):
    print("Callback received query snapshot.")
    print("Current cities in California: ")
    for change in changes:
        if change.type.name == "ADDED":
            print(f"New city: {change.document.id}")
        elif change.type.name == "MODIFIED":
            print(f"Modified city: {change.document.id}")
        elif change.type.name == "REMOVED":
            print(f"Removed city: {change.document.id}")
            delete_done.set()

col_query = db.collection("cities").where(filter=FieldFilter("state", "==", "CA"))

# Watch the collection query
query_watch = col_query.on_snapshot(on_snapshot)
snippets.py

Node.js

const observer = db.collection('cities').where('state', '==', 'CA')
  .onSnapshot(querySnapshot => {
    querySnapshot.docChanges().forEach(change => {
      if (change.type === 'added') {
        console.log('New city: ', change.doc.data());
      }
      if (change.type === 'modified') {
        console.log('Modified city: ', change.doc.data());
      }
      if (change.type === 'removed') {
        console.log('Removed city: ', change.doc.data());
      }
    });
  });
index.js

शुरू करें

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/firestore"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// listenChanges listens to a query, returning the list of document changes.
func listenChanges(ctx context.Context, w io.Writer, projectID, collection string) error {
	// projectID := "project-id"
	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()

	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("firestore.NewClient: %w", err)
	}
	defer client.Close()

	it := client.Collection(collection).Where("state", "==", "CA").Snapshots(ctx)
	for {
		snap, err := it.Next()
		// DeadlineExceeded will be returned when ctx is cancelled.
		if status.Code(err) == codes.DeadlineExceeded {
			return nil
		}
		if err != nil {
			return fmt.Errorf("Snapshots.Next: %w", err)
		}
		if snap != nil {
			for _, change := range snap.Changes {
				switch change.Kind {
				case firestore.DocumentAdded:
					fmt.Fprintf(w, "New city: %v\n", change.Doc.Data())
				case firestore.DocumentModified:
					fmt.Fprintf(w, "Modified city: %v\n", change.Doc.Data())
				case firestore.DocumentRemoved:
					fmt.Fprintf(w, "Removed city: %v\n", change.Doc.Data())
				}
			}
		}
	}
}
listen_changes.go

PHP

// Not supported in the PHP client library

Unity

Query query = db.Collection("cities").WhereEqualTo("State", "CA");

ListenerRegistration listener = query.Listen(snapshot =>
{
    foreach (DocumentChange change in snapshot.GetChanges())
    {
        if (change.ChangeType == DocumentChange.Type.Added)
        {
            Debug.Log(String.Format("New city: {0}", change.Document.Id));
        }
        else if (change.ChangeType == DocumentChange.Type.Modified)
        {
            Debug.Log(String.Format("Modified city: {0}", change.Document.Id));
        }
        else if (change.ChangeType == DocumentChange.Type.Removed)
        {
            Debug.Log(String.Format("Removed city: {0}", change.Document.Id));
        }
    }
});

C#

CollectionReference citiesRef = db.Collection("cities");
Query query = db.Collection("cities").WhereEqualTo("State", "CA");

FirestoreChangeListener listener = query.Listen(snapshot =>
{
    foreach (DocumentChange change in snapshot.Changes)
    {
        if (change.ChangeType.ToString() == "Added")
        {
            Console.WriteLine("New city: {0}", change.Document.Id);
        }
        else if (change.ChangeType.ToString() == "Modified")
        {
            Console.WriteLine("Modified city: {0}", change.Document.Id);
        }
        else if (change.ChangeType.ToString() == "Removed")
        {
            Console.WriteLine("Removed city: {0}", change.Document.Id);
        }
    }
});
Program.cs

Ruby

query = firestore.col(collection_path).where :state, :==, "CA"
added = []
modified = []
removed = []

# Watch the collection query.
listener = query.listen do |snapshot|
  puts "Callback received query snapshot."
  puts "Current cities in California:"
  snapshot.changes.each do |change|
    if change.added?
      puts "New city: #{change.doc.document_id}"
      added << snapshot
    elsif change.modified?
      puts "Modified city: #{change.doc.document_id}"
      modified << snapshot
    elsif change.removed?
      puts "Removed city: #{change.doc.document_id}"
      removed << snapshot
    end
  end
end
query_watch.rb

अहम जानकारी: क्वेरी के पहले स्नैपशॉट में, क्वेरी से मैच करने वाले सभी मौजूदा दस्तावेज़ों के लिए added इवेंट होते हैं. ऐसा इसलिए है, क्योंकि आपको बदलावों का एक सेट मिल रहा है, जो आपकी क्वेरी के स्नैपशॉट को क्वेरी की शुरुआती स्थिति के साथ मौजूदा बनाता है. उदाहरण के लिए, इससे आपको पहले क्वेरी स्नैपशॉट में मिले बदलावों से, सीधे अपने यूज़र इंटरफ़ेस (यूआई) को पॉप्युलेट करने की अनुमति मिलती है. इसके लिए, आपको शुरुआती स्थिति को मैनेज करने के लिए, कोई खास लॉजिक जोड़ने की ज़रूरत नहीं होती.

शुरुआती स्थिति, सीधे सर्वर से या किसी स्थानीय कैश मेमोरी से मिल सकती है. अगर किसी लोकल कैश मेमोरी में स्टेटस उपलब्ध है, तो क्वेरी स्नैपशॉट को शुरू में कैश मेमोरी में सेव किए गए डेटा से पॉप्युलेट किया जाएगा. इसके बाद, जब क्लाइंट को सर्वर का स्टेटस मिल जाएगा, तब उसे सर्वर के डेटा से अपडेट कर दिया जाएगा.

किसी लिसनर को हटाना

जब आपको अपने डेटा को सुनने में दिलचस्पी नहीं रहती, तो आपको अपने लिसनर को अलग करना होगा, ताकि आपके इवेंट कॉलबैक को कॉल करना बंद कर दिया जाए. इससे क्लाइंट, अपडेट पाने के लिए बैंडविड्थ का इस्तेमाल करना बंद कर सकता है. उदाहरण के लिए:

Web

import { collection, onSnapshot } from "firebase/firestore";

const unsubscribe = onSnapshot(collection(db, "cities"), () => {
  // Respond to data
  // ...
});

// Later ...

// Stop listening to changes
unsubscribe();
detach_listener.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

var unsubscribe = db.collection("cities")
    .onSnapshot(() => {
      // Respond to data
      // ...
    });

// Later ...

// Stop listening to changes
unsubscribe();
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

let listener = db.collection("cities").addSnapshotListener { querySnapshot, error in
  // ...
}

// ...

// Stop listening to changes
listener.remove()
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

id<FIRListenerRegistration> listener = [[self.db collectionWithPath:@"cities"]
    addSnapshotListener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      // ...
}];

// ...

// Stop listening to changes
[listener remove];
ViewController.m

Kotlin

val query = db.collection("cities")
val registration = query.addSnapshotListener { snapshots, e ->
    // ...
}

// ...

// Stop listening to changes
registration.remove()
DocSnippets.kt

Java

Query query = db.collection("cities");
ListenerRegistration registration = query.addSnapshotListener(
        new EventListener<QuerySnapshot>() {
            // ...
        });

// ...

// Stop listening to changes
registration.remove();
DocSnippets.java

Dart

final collection = db.collection("cities");
final listener = collection.snapshots().listen((event) {
  // ...
});
listener.cancel();
firestore.dart

Java

Query query = db.collection("cities");
ListenerRegistration registration =
    query.addSnapshotListener(
        new EventListener<QuerySnapshot>() {
          // ...
        });

// ...

// Stop listening to changes
registration.remove();
ListenDataSnippets.java

Python

# Terminate watch on a document
doc_watch.unsubscribe()
snippets.py

C++

// Add a listener
Query query = db->Collection("cities");
ListenerRegistration registration = query.AddSnapshotListener(
    [](const QuerySnapshot& snapshot, Error error, const std::string& errorMsg) { /* ... */ });
// Stop listening to changes
registration.Remove();
snippets.cpp

Node.js

const unsub = db.collection('cities').onSnapshot(() => {
});

// ...

// Stop listening for changes
unsub();
index.js

शुरू करें

// Сontext with timeout stops listening to changes.
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
listen_document.go

PHP

// Not supported in the PHP client library

Unity

listener.Stop();

C#

await listener.StopAsync();
Program.cs

Ruby

listener.stop
query_watch.rb

सुनने से जुड़ी गड़बड़ियां ठीक करना

कभी-कभी, ऑडियो सुनने में समस्या आ सकती है. जैसे, सुरक्षा से जुड़ी अनुमतियों की वजह से या अमान्य क्वेरी के लिए ऑडियो सुनने की कोशिश करने पर. (मान्य और अमान्य क्वेरी के बारे में ज़्यादा जानें.) इन गड़बड़ियों को मैनेज करने के लिए, स्नैपशॉट लिसनर को अटैच करते समय गड़बड़ी का कॉलबैक दिया जा सकता है. गड़बड़ी होने के बाद, लिसनर को कोई और इवेंट नहीं मिलेगा. साथ ही, लिसनर को अलग करने की ज़रूरत नहीं है.

Web

import { collection, onSnapshot } from "firebase/firestore";

const unsubscribe = onSnapshot(
  collection(db, "cities"), 
  (snapshot) => {
    // ...
  },
  (error) => {
    // ...
  });
handle_listen_errors.js

Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई और नेमस्पेस वाले एपीआई के मुकाबले इसके फ़ायदों के बारे में ज़्यादा जानें.

db.collection("cities")
    .onSnapshot((snapshot) => {
        // ...
    }, (error) => {
        // ...
    });
test.firestore.js

Swift

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

db.collection("cities")
  .addSnapshotListener { querySnapshot, error in
    if let error = error {
      print("Error retreiving collection: \(error)")
    }
  }
ViewController.swift

Objective-C

ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.

[[self.db collectionWithPath:@"cities"]
    addSnapshotListener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (error != nil) {
        NSLog(@"Error retreving collection: %@", error);
      }
    }];
ViewController.m

Kotlin

db.collection("cities")
    .addSnapshotListener { snapshots, e ->
        if (e != null) {
            Log.w(TAG, "listen:error", e)
            return@addSnapshotListener
        }

        for (dc in snapshots!!.documentChanges) {
            if (dc.type == DocumentChange.Type.ADDED) {
                Log.d(TAG, "New city: ${dc.document.data}")
            }
        }
    }
DocSnippets.kt

Java

db.collection("cities")
        .addSnapshotListener(new EventListener<QuerySnapshot>() {
            @Override
            public void onEvent(@Nullable QuerySnapshot snapshots,
                                @Nullable FirebaseFirestoreException e) {
                if (e != null) {
                    Log.w(TAG, "listen:error", e);
                    return;
                }

                for (DocumentChange dc : snapshots.getDocumentChanges()) {
                    if (dc.getType() == Type.ADDED) {
                        Log.d(TAG, "New city: " + dc.getDocument().getData());
                    }
                }

            }
        });
DocSnippets.java

Dart

final docRef = db.collection("cities");
docRef.snapshots().listen(
      (event) => print("listener attached"),
      onError: (error) => print("Listen failed: $error"),
    );
firestore.dart

Java

db.collection("cities")
    .addSnapshotListener(
        new EventListener<QuerySnapshot>() {
          @Override
          public void onEvent(
              @Nullable QuerySnapshot snapshots, @Nullable FirestoreException e) {
            if (e != null) {
              System.err.println("Listen failed: " + e);
              return;
            }

            for (DocumentChange dc : snapshots.getDocumentChanges()) {
              if (dc.getType() == Type.ADDED) {
                System.out.println("New city: " + dc.getDocument().getData());
              }
            }
          }
        });
ListenDataSnippets.java

Python

// Snippet coming soon

C++

// Snippet coming soon.

Node.js

db.collection('cities')
  .onSnapshot((snapshot) => {
    //...
  }, (error) => {
    //...
  });
index.js

शुरू करें

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/firestore"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// listenErrors demonstrates how to handle listening errors.
func listenErrors(ctx context.Context, w io.Writer, projectID, collection string) error {
	// projectID := "project-id"
	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()

	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("firestore.NewClient: %w", err)
	}
	defer client.Close()

	it := client.Collection(collection).Snapshots(ctx)
	for {
		snap, err := it.Next()
		// Canceled will be returned when ctx is cancelled and DeadlineExceeded will
		// be returned when ctx reaches its deadline.
		if e := status.Code(err); e == codes.Canceled || e == codes.DeadlineExceeded {
			return nil
		}
		if err != nil {
			return fmt.Errorf("Snapshots.Next: %w", err)
		}
		if snap != nil {
			for _, change := range snap.Changes {
				if change.Kind == firestore.DocumentAdded {
					fmt.Fprintf(w, "New city: %v\n", change.Doc.Data())
				}
			}
		}
	}
}
listen_errors.go

PHP

// Not supported in the PHP client library

Unity

ListenerRegistration registration =
db.Collection("cities").Listen(
  querySnapshot =>
  {
      // ...
  });

registration.ListenerTask.ContinueWithOnMainThread(
    listenerTask =>
    {
        if (listenerTask.IsFaulted)
        {
            Debug.LogError($"Listen failed: {listenerTask.Exception}");
            // ...
            // Handle the listener error.
            // ...
        }
    });

C#

// Snippet coming soon

Ruby

listener = firestore.col(collection_path).listen do |snapshot|
  snapshot.changes.each do |change|
    puts "New city: #{change.doc.document_id}" if change.added?
  end
end

# Register to be notified when unhandled errors occur.
listener.on_error do |error|
  puts "Listen failed: #{error.message}"
end
query_watch.rb

आगे क्या करना है

• साधारण और जटिल क्वेरी की मदद से, दर्शकों को इकट्ठा करना.
• ढूंढे गए दस्तावेज़ों को क्रम से लगाना और उनकी संख्या सीमित करना.
• सुनने वालों के लिए बिलिंग सिस्टम को समझना.