मैं स्पंदन के साथ एक चैट स्थापित करने के लिए काम कर रहा हूँ और मैं firestore का उपयोग करने की योजना बना रहा हूँ। मेरे पास एक स्ट्रीमबिल्डर है और मैं पढ़ने वाले दस्तावेज़ों की संख्या को 20 तक सीमित कर रहा हूं। चैट ठीक काम करती है और मुझे पिछले 20 संदेश दिखाती है। अब मैं शीर्ष पर स्क्रॉल करते ही अगले 20 पुराने संदेशों को जोड़ना चाहूंगा।

मेरे पास एक कामकाजी समाधान है लेकिन मुझे यकीन नहीं है कि यह सबसे अच्छा है। मेरी सबसे बड़ी चिंता इस बात से संबंधित है कि हर बार जब मैं सीमा का मान बदलता हूं तो मैं कितने पढ़ता हूं। क्या मैं २० नए पठन पढ़ रहा हूँ या क्या मैं ४० नए दस्तावेज़ पढ़ रहा हूँ? और अगर मैं अधिक स्क्रॉल करता हूं तो क्या मैं 60 रीड्स का उपयोग कर रहा हूं?

मेरे कोड के नीचे देखें

void initState() {
    maxMessageToDisplay = 20;
    _scrollController = ScrollController();
    _scrollController.addListener(() {
      if (_scrollController.position.pixels == _scrollController.position.maxScrollExtent) {
        setState(() {
          maxMessageToDisplay += 20;
        });
      }
    });
    super.initState();
}

Widget build(BuildContext context) {
    return StreamBuilder<QuerySnapshot>(
      stream: _firestore.collection('chat').limit(maxMessageToDisplay).orderBy('timestamp', descending: true).snapshots(),
      builder: (context, snapshot) {
     
        final messages = snapshot.data.documents;

        messages.sort((a, b) => b.data['timestamp'].compareTo(a.data['timestamp']));
        var format = new DateFormat("Hm");

        List<MessageBubble> messageBubbles = [];
        for (var message in messages) {
          final messageText = message.data['text'];
          final messageSender = message.data['sender'];
          final messagePhoto = message.data['photo'];
          final messageUserId = message.data['uid'];

          final messageTime = format.format(DateTime.fromMillisecondsSinceEpoch(message.data['timestamp'], isUtc: false));    

          final messageBubble = MessageBubble(
            sender: messageSender,
            text: messageText,
            photo: messagePhoto,
            time: messageTime,
            userId: messageUserId,
          );
          messageBubbles.add(messageBubble);
        }
        return Expanded(
          child: ListView(
            controller: _scrollController,
            reverse: true,
            padding: EdgeInsets.symmetric(vertical: 10.0, horizontal: 10.0),
            children: messageBubbles,
          ),
        );
      },
    );
  }
}
4
mactrix 20 अगस्त 2020, 19:04

3 जवाब

सबसे बढ़िया उत्तर

यदि श्रोता 30 मिनट से अधिक समय तक डिस्कनेक्ट नहीं करता है, तो आपको इसके बारे में चिंता नहीं करनी चाहिए, क्योंकि फायरबेस केवल नए रीड की गणना करता है यदि दस्तावेज़ बदल गया है। तो आपके मामले में यदि आपने 20 दस्तावेज़ पढ़े हैं, तो उपयोगकर्ता स्क्रॉल करता है और 20 और प्राप्त करता है, आपके पास केवल 40 होंगे और 60 नहीं होंगे। आप फायरबेस बिलिंग के बारे में अधिक पढ़ सकते हैं यहां

2
i6x86 21 अगस्त 2020, 03:10

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

0
goku pc 21 अगस्त 2020, 12:22

आप अपने स्ट्रीम बिल्डर में उपयोग की जा रही स्ट्रीम को संशोधित करके ऐसा करने में सक्षम होना चाहिए।

आपको दो स्रोतों के बीच एक संयुक्त स्ट्रीम बनानी चाहिए और हर बार जब कोई स्रोत नया डेटा लाता है तो नए मूल्यों को आगे बढ़ाना चाहिए। इसके लिए, आप rxDart प्लगइन से BehaviorSubjects का उपयोग कर सकते हैं (यह आसान है, और मानक स्ट्रीम से थोड़ा बेहतर है, हालांकि आप मानक डार्ट स्ट्रीम के साथ सब कुछ कर सकते हैं)।

यह एक नमूना कोड है:

List<FireStoreItem> fireStoreItems = [];

BehaviorSubject<List<FireStoreItem>> OlderItemsStream = new BehaviorSubject<List<FireStoreItem>>():

BehaviorSubject<List<FireStoreItem>> finalItemsStream = Rx.combileLatest2(
_firestore.collection('chat').limit(maxMessageToDisplay).orderBy('timestamp', descending: true).snapshots(),
OlderItemsStream, (a,b)=>a.addAll(b))

अंतिम स्ट्रीम मूल स्ट्रीम और पुराने संदेश स्ट्रीम का संयोजन है। और हर बार किसी एक स्ट्रीम को नया मान मिलने पर एक नया स्नैपशॉट जेनरेट करेगा।

Rx.combineLatest2 में अंतिम तर्क धाराओं का मानचित्रण है जहां हम मूल रूप से पुराने संदेशों स्नैपशॉट डेटा को पहली स्ट्रीम के स्नैपशॉट डेटा में जोड़ते हैं और इस प्रकार नवीनतम संदेशों और पुराने संदेशों के साथ एक सूची बनाते हैं और इसे एक साथ धक्का देते हैं नया मूल्य और तदनुसार स्ट्रीम बिल्डर को अपडेट करना।

आपके स्ट्रीम निर्माता को केवल finalItemsStream को स्रोत स्ट्रीम के रूप में लेना चाहिए।

स्क्रॉलिंग ट्रिगर के लिए, जहां आपको पुराने संदेशों को फायरस्टोर से खींचने के लिए ट्रिगर करने के लिए अंत तक स्क्रॉल करने की आवश्यकता होती है, आप स्क्रॉल नियंत्रक पर एक श्रोता सेट कर सकते हैं और atEdge बूल की जांच कर सकते हैं जो आपको बताएगा कि क्या आप पहुंच गए स्क्रॉलिंग एज या नहीं।

यहाँ एक नमूना कोड है:

scrollController.addListener(() {
      if(scrollController.position.atEdge){
        //create a fireStore call and add the resulting data to the olderItems stream
        FireStoreCall().then((data){
          OlderItemsStream.add(oldMessages);
        });
      }
    });

नोट: scrollController वही होना चाहिए जिसका उपयोग listView में किया गया हो

1
Kaki Master Of Time 20 अगस्त 2020, 21:30