Android
Firebase Realtime DataBase

C# Language Cordova firebase HTML iOS Java Language JavaScript Kotlin PHP react-native
खोज…


टिप्पणियों

अन्य संबंधित विषय:

Firebase Realtime DataBase ईवेंट हैंडलर

पहले प्रारंभिक FirebaseDatabase: 

FirebaseDatabase database = FirebaseDatabase.getInstance();

अपने डेटाबेस में लिखें: 

// Write a message to the database
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference myRef = database.getReference("message");

myRef.setValue("Hello, World!");

अपने डेटाबेस से पढ़ें: 

// Read from the database
myRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        // This method is called once with the initial value and again
        // whenever data at this location is updated.
        String value = dataSnapshot.getValue(String.class);
        Log.d(TAG, "Value is: " + value);
    }

    @Override
    public void onCancelled(DatabaseError error) {
        // Failed to read value
        Log.w(TAG, "Failed to read value.", error.toException());
    }
});

Android घटनाओं पर डेटा प्राप्त करें: 

ChildEventListener childEventListener = new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String previousChildName) {
        Log.d(TAG, "onChildAdded:" + dataSnapshot.getKey());
    }

    @Override
    public void onChildChanged(DataSnapshot dataSnapshot, String previousChildName) {
        Log.d(TAG, "onChildChanged:" + dataSnapshot.getKey());
    }

    @Override
    public void onChildRemoved(DataSnapshot dataSnapshot) {
        Log.d(TAG, "onChildRemoved:" + dataSnapshot.getKey());

    }

    @Override
    public void onChildMoved(DataSnapshot dataSnapshot, String previousChildName) {
        Log.d(TAG, "onChildMoved:" + dataSnapshot.getKey());

    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        Log.w(TAG, "postComments:onCancelled", databaseError.toException());
        Toast.makeText(mContext, "Failed to load comments.",
                Toast.LENGTH_SHORT).show();
    }
};
ref.addChildEventListener(childEventListener);

तत्काल प्रबंध

  1. अपने ऐप को Firebase से कनेक्ट करने के लिए इंस्टॉलेशन और सेटअप भाग को पूरा करें।
    इससे फायरबेस में प्रोजेक्ट तैयार होगा।

  2. Firebase रीयलटाइम डेटाबेस के लिए अपने मॉड्यूल-स्तर build.gradle फ़ाइल के लिए निर्भरता जोड़ें: 

compile 'com.google.firebase:firebase-database:10.2.1'
  1. फायरबेस डेटाबेस नियम कॉन्फ़िगर करें

अब आप Android में रीयलटाइम डेटाबेस के साथ काम करने के लिए तैयार हैं।

उदाहरण के लिए आप message कुंजी के तहत डेटाबेस में एक Hello World संदेश लिखते हैं। 

// Write a message to the database
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference myRef = database.getReference("message");

myRef.setValue("Hello, World!");

फायरबेस डेटाबेस से रियलटाइम डेटा कैसे प्राप्त करें, इसे डिजाइन करना और समझना

यह उदाहरण मानता है कि आपने पहले ही एक फायरबेस रियलटाइम डेटाबेस स्थापित कर लिया है। यदि आप एक स्टार्टर हैं, तो कृपया अपने आप को यहां सूचित करें कि अपने एंड्रॉइड प्रोजेक्ट में फायरबेस कैसे जोड़ें।

सबसे पहले, Firebase डेटाबेस की निर्भरता को ऐप स्तर build.gradle फ़ाइल में जोड़ें: 

compile 'com.google.firebase:firebase-database:9.4.0'

अब, हम एक चैट एप बनाते हैं जो फायरबेस डेटाबेस में डेटा स्टोर करता है।

चरण 1: चैट नामक एक क्लास बनाएं

बस चैट के लिए आवश्यक कुछ बुनियादी चर के साथ एक वर्ग बनाएं: 

public class Chat{
    public String name, message;
}

चरण 2: कुछ JSON डेटा बनाएँ

फायरबेस डेटाबेस से / के लिए डेटा भेजने / प्राप्त करने के लिए, आपको JSON का उपयोग करने की आवश्यकता है। आइए हम मान लें कि कुछ चैट पहले से ही डेटाबेस में रूट स्तर पर संग्रहीत हैं। इन चैट का डेटा निम्नानुसार दिखाई दे सकता है: 

[
    {
        "name":"John Doe",
        "message":"My first Message"
    },
    {
        "name":"John Doe",
        "message":"Second Message"
    },
    {
        "name":"John Doe",
        "message":"Third Message"
    }
]

चरण 3: श्रोताओं को जोड़ना

श्रोता तीन प्रकार के होते हैं। निम्नलिखित उदाहरण में हम childEventListener का उपयोग करने जा रहे हैं: 

DatabaseReference chatDb = FirebaseDatabase.getInstance().getReference() // Referencing the root of the database.
        .child("chats"); // Referencing the "chats" node under the root.

chatDb.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String s) {
        // This function is called for every child id chat in this case, so using the above
        // example, this function is going to be called 3 times.
        
        // Retrieving the Chat object from this function is simple.
        Chat chat; // Create a null chat object.

        // Use the getValue function in the dataSnapshot and pass the object's class name to
        // which you want to convert and get data. In this case it is Chat.class.
        chat = dataSnapshot.getValue(Chat.class);

        // Now you can use this chat object and add it into an ArrayList or something like
        // that and show it in the recycler view.
    }

    @Override
    public void onChildChanged(DataSnapshot dataSnapshot, String s) {
        // This function is called when any of the node value is changed, dataSnapshot will
        // get the data with the key of the child, so you can swap the new value with the
        // old one in the ArrayList or something like that.

        // To get the key, use the .getKey() function.
        // To get the value, use code similar to the above one.
    }

    @Override
    public void onChildRemoved(DataSnapshot dataSnapshot) {
        // This function is called when any of the child node is removed. dataSnapshot will
        // get the data with the key of the child.

        // To get the key, use the s String parameter .
    }

    @Override
    public void onChildMoved(DataSnapshot dataSnapshot, String s) {
        // This function is called when any of the child nodes is moved to a different position.

        // To get the key, use the s String parameter.
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        // If anything goes wrong, this function is going to be called.

        // You can get the exception by using databaseError.toException();
    }
});

चरण 4: डेटाबेस में डेटा जोड़ें

बस एक चैट क्लास ऑब्जेक्ट बनाएं और निम्न मान जोड़ें: 

Chat chat=new Chat();
chat.name="John Doe";
chat.message="First message from android";

अब चैटिंग नोड का संदर्भ लें जैसा कि पुनर्प्राप्ति सत्र में किया गया है: 

DatabaseReference chatDb = FirebaseDatabase.getInstance().getReference().child("chats");

इससे पहले कि आप डेटा जोड़ना शुरू करें, ध्यान रखें कि आपको एक और गहन संदर्भ की आवश्यकता है क्योंकि चैट नोड में कई और नोड हैं और एक नया चैट जोड़ने का मतलब है कि चैट विवरण वाले नए नोड को जोड़ना। हम DatabaseReference ऑब्जेक्ट पर push() फ़ंक्शन का उपयोग करके नोड का एक नया और अनूठा नाम उत्पन्न कर सकते हैं, जो एक और DatabaseReference को लौटाएगा, जो चैट डेटा सम्मिलित करने के लिए एक नवगठित नोड की ओर इशारा करता है।

उदाहरण 

// The parameter is the chat object that was newly created a few lines above.
chatDb.push().setValue(chat);

setValue() फ़ंक्शन यह सुनिश्चित करेगा कि एप्लिकेशन के सभी onDataChanged फ़ंक्शन को कॉल किया जा रहा है (एक ही डिवाइस सहित), जो "चैट" नोड के संलग्न श्रोता होने के लिए होता है।

अपभ्रंश: फ्लैट डेटाबेस संरचना

अलग-अलग कॉल को कुशलतापूर्वक डाउनलोड करने के लिए अपसरण और एक फ्लैट डेटाबेस संरचना neccessary है। निम्नलिखित संरचना के साथ, दो-तरफ़ा रिश्तों को बनाए रखना भी संभव है। इस दृष्टिकोण का नुकसान यह है, कि आपको हमेशा कई स्थानों पर डेटा को अपडेट करने की आवश्यकता होती है।

एक उदाहरण के लिए, एक ऐसे ऐप की कल्पना करें जो उपयोगकर्ता को खुद को संदेश (मेमो) स्टोर करने की अनुमति देता है।

वांछित फ्लैट डेटाबेस संरचना: 

|--database
  |-- memos
     |-- memokey1
       |-- title: "Title"
       |-- content: "Message"
     |-- memokey2
       |-- title: "Important Title"
       |-- content: "Important Message"
  |-- users
     |-- userKey1
       |-- name: "John Doe"
       |-- memos
         |-- memokey1 : true //The values here don't matter, we only need the keys.
         |-- memokey2 : true
     |-- userKey2
       |-- name: "Max Doe"

प्रयुक्त ज्ञापन वर्ग 

public class Memo {
    private String title, content;
    //getters and setters ... 

    //toMap() is necessary for the push process
    private Map<String, Object> toMap() {
        HashMap<String, Object> result = new HashMap<>();
        result.put("title", title);
        result.put("content", content);
        return result;
    }
}

उपयोगकर्ता के मेमो को पुनः प्राप्त करना 

//We need to store the keys and the memos seperately
private ArrayList<String> mKeys = new ArrayList<>();
private ArrayList<Memo> mMemos = new ArrayList<>();

//The user needs to be logged in to retrieve the uid
String currentUserId = FirebaseAuth.getInstance().getCurrentUser().getUid();

//This is the reference to the list of memos a user has 
DatabaseReference currentUserMemoReference = FirebaseDatabase.getInstance().getReference()
    .child("users").child(currentUserId).child("memos");

//This is a reference to the list of all memos
DatabaseReference memoReference = FirebaseDatabase.getInstance().getReference()
    .child("memos");

//We start to listen to the users memos, 
//this will also retrieve the memos initially
currentUserMemoReference.addChildEventListener(new ChildEventListener() {
        @Override
        public void onChildAdded(DataSnapshot dataSnapshot, String s) {
            //Here we retrieve the key of the memo the user has.
            String key = dataSnapshot.getKey(); //for example memokey1
            //For later manipulations of the lists, we need to store the key in a list
            mKeys.add(key);
            //Now that we know which message belongs to the user, 
            //we request it from our memos:
            memoReference.child(key).addValueEventListener(new ValueEventListener() {
                @Override
                    public void onDataChange(DataSnapshot dataSnapshot) {
                         //Here we retrieve our memo:
                         Memo memo = dataSnapshot.getValue(Memo.class);
                         mMemos.add(memo);
                    }

                @Override
                public void onCancelled(DatabaseError databaseError) { }
            });                           
        }

        @Override
        public void onChildChanged(DataSnapshot dataSnapshot, String s) { }

        @Override
        public void onChildRemoved(DataSnapshot dataSnapshot) { }

        @Override
        public void onChildMoved(DataSnapshot dataSnapshot, String s) { }

        @Override
        public void onCancelled(DatabaseError databaseError) { }
    }

मेमो बनाना 

//The user needs to be logged in to retrieve the uid
String currentUserUid = FirebaseAuth.getInstance().getCurrentUser().getUid();

//This is the path to the list of memos a user has 
String userMemoPath = "users/" + currentUserUid + "/memos/";

//This is the path to the list of all memos
String memoPath = "memos/";

//We need to retrieve an unused key from the memos reference
DatabaseReference memoReference = FirebaseDatabase.getInstance().getReference().child("memos");
String key = memoReference.push().getKey();
Memo newMemo = new Memo("Important numbers", "1337, 42, 3.14159265359");

Map<String, Object> childUpdates = new HashMap<>(); 
//The second parameter **here** (the value) does not matter, it's just that the key exists
childUpdates.put(userMemoPath + key, true);
childUpdates.put(memoPath + key, newMemo.toMap());

FirebaseDatabase.getInstance().getReference().updateChildren(childUpdates);

पुश के बाद, या डेटाबेस इस तरह दिखता है: 

|--database
  |-- memos
     |-- memokey1
       |-- title: "Title"
       |-- content: "Message"
     |-- memokey2
       |-- title: "Important Title"
       |-- content: "Important Message"
     |-- generatedMemokey3 
       |-- title: "Important numbers"
       |-- content: "1337, 42, 3.14159265359"
  |-- users
     |-- userKey1
       |-- name: "John Doe"
       |-- memos
         |-- memokey1 : true //The values here don't matter, we only need the keys.
         |-- memokey2 : true
         |-- generatedMemokey3 : true
     |-- userKey2
       |-- name: "Max Doe"

Firebase JSON डेटाबेस को समझना

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

यहाँ एक नमूना JSON दिखाया गया है कि कैसे डेटा को फायरबेस में संग्रहीत किया जाता है: 

   {
    "user_base" : {
      "342343" : {
        "email" : "[email protected]",
        "authToken" : "some string",
        "name" : "Kaushal",
        "phone" : "+919916xxxxxx",
        "serviceProviderId" : "firebase",
        "signInServiceType" : "google",
      },
      "354895" : {
        "email" : "[email protected]",
        "authToken" : "some string",
        "name" : "devil",
        "phone" : "+919685xxxxxx",
        "serviceProviderId" : "firebase",
        "signInServiceType" : "github"
      },
      "371298" : {
        "email" : "[email protected]",
        "authToken" : "I am batman",
        "name" : "Bruce Wayne",
        "phone" : "+14085xxxxxx",
        "serviceProviderId" : "firebase",
        "signInServiceType" : "shield"
      }
    },
    "user_prefs": {
      "key1":{
        "data": "for key one"
      },
      "key2":{
        "data": "for key two"
      },
      "key3":{
        "data": "for key three"
      }
    },
    //other structures
  }

यह स्पष्ट रूप से दिखाता है कि रिलेशनल डेटाबेस में हमने जो डेटा स्टोर किया था, उसे JSON फॉर्मेट में कैसे स्टोर किया जा सकता है। आगे आइए देखें कि एंड्रॉइड डिवाइसों में इस डेटा को कैसे पढ़ें।

फायरबेस से डेटा पुनर्प्राप्त करना

मैं मान रहा हूँ कि आप पहले से ही एंड्रॉयड स्टूडियो में ग्रेडेड डिपेंडेंसी फायरबेस को जोड़ने के बारे में जानते हैं। यदि आप यहाँ से गाइड का अनुसरण नहीं करते हैं । फायरबेस कंसोल में अपना ऐप जोड़ें, निर्भरता जोड़ने के बाद एंड्रॉइड स्टूडियो को सिंक करें। सभी आश्रितों को सिर्फ फायरबेस डेटाबेस और फायरबेसase की आवश्यकता नहीं है।

अब जब हम जानते हैं कि डेटा को कैसे संग्रहीत किया जाता है और ग्रेडल निर्भरता को कैसे जोड़ा जाए तो आइए देखें कि डेटा प्राप्त करने के लिए आयातित फायरबेस एंड्रॉइड एसडीके का उपयोग कैसे करें।

एक फायरबेस डेटाबेस संदर्भ बनाएँ 

DatabaseReference userDBRef = FirebaseDatabase.getInstance().getReference();
// above statement point to base tree
userDBRef = DatabaseReference.getInstance().getReference().child("user_base")
// points to user_base table JSON (see previous section)

यहाँ से आप एकाधिक बच्चों () मेथड कॉल्स को उस डेटा को इंगित करने के लिए चेन कर सकते हैं जिसमें आप रुचि रखते हैं। उदाहरण के लिए यदि डेटा पिछले सेक्शन में दर्शाया गया है और आप ब्रूस वेन उपयोगकर्ता को इंगित करना चाहते हैं जिसका आप उपयोग कर सकते हैं: 

DatabaseReference bruceWayneRef = userDBRef.child("371298");
// 371298 is key of bruce wayne user in JSON structure (previous section)

या केवल JSON ऑब्जेक्ट के लिए संपूर्ण संदर्भ पास करें: 

DatabaseReference bruceWayneRef = DatabaseReference.getInstance().getReference()
     .child("user_base/371298");
// deeply nested data can also be referenced this way, just put the fully
// qualified path in pattern shown in above code "blah/blah1/blah1-2/blah1-2-3..."

अब हमारे पास उस डेटा का संदर्भ है जिसे हम प्राप्त करना चाहते हैं, हम श्रोताओं का उपयोग एंड्रॉइड ऐप में डेटा लाने के लिए कर सकते हैं। पारंपरिक कॉल के विपरीत, जहां आप रेट्रोस्टिट या वॉली का उपयोग करके REST API कॉल करते हैं, यहां डेटा प्राप्त करने के लिए एक साधारण कॉलबैक श्रोता की आवश्यकता होती है। Firebase sdk कॉलबैक विधियों को कॉल करता है और आपको किया जाता है।

मूल रूप से दो प्रकार के श्रोता हैं जो आप संलग्न कर सकते हैं, एक है वैल्यूवेंट्रिस्टनर और दूसरा है चाइल्डइवेंटलिस्ट (अगले भाग में वर्णित)। नोड के तहत डेटा में किसी भी बदलाव के लिए हमारे पास संदर्भ हैं और श्रोताओं को जोड़ा है, मान घटना श्रोताओं को पूरे JSON संरचना को वापस करते हैं और बच्चे के घटना श्रोता विशिष्ट बच्चे को वापस कर देते हैं जहां परिवर्तन हुआ है। ये दोनों अपने तरीके से उपयोगी हैं। फायरबेस से डेटा प्राप्त करने के लिए हम एक या एक से अधिक श्रोताओं को फायरबेस डेटाबेस संदर्भ में सूचीबद्ध कर सकते हैं (उपयोगकर्ता द्वारा पहले बनाए गए उपयोगकर्ता सूची)।

यहाँ कुछ नमूना कोड (कोड के बाद कोड स्पष्टीकरण) है: 

userDBRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        User bruceWayne = dataSnapshot.child("371298").getValue(User.class);
        // Do something with the retrieved data or Bruce Wayne
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        Log.e("UserListActivity", "Error occured");
        // Do something about the error
    });

क्या आपने नोटिस किया कि कक्षा का प्रकार उत्तीर्ण है। DataSnapshot JSON डेटा को हमारे परिभाषित POJOs में परिवर्तित कर सकता है, सरल सही प्रकार का पास दे सकता है।

यदि आपके उपयोग के मामले में पूरे डेटा (हमारे मामले में user_base तालिका में) की आवश्यकता नहीं होती है, तो हर बार कुछ छोटा परिवर्तन होता है या कहें कि आप केवल एक बार डेटा प्राप्त करना चाहते हैं, आप डेटाबेस संदर्भ के addListenerForSingleValueEvent () विधि का उपयोग कर सकते हैं। यह केवल एक बार कॉलबैक फायर करता है। 

userDBRef.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        // Do something
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        // Do something about the error
    });

ऊपर के नमूने आपको JSON नोड का मान देंगे। कुंजी प्राप्त करने के लिए बस कॉल करें: 

String myKey = dataSnapshot.getKey();

बाल अपडेट के लिए सुन रहा है

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

इस मामले में हम चाइल्ड एवेनिस्टनर का उपयोग कर सकते हैं। किसी भी आगे के विज्ञापन के बिना, यहाँ कोड नमूना है (नमूना JSON डेटा के लिए प्रचलित अनुभाग देखें): 

userDBRef.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String s) {
    }

    @Override
    public void onChildChanged(DataSnapshot dataSnapshot, String s) {
    }

    @Override
    public void onChildRemoved(DataSnapshot dataSnapshot) {
    }

    @Override
    public void onChildMoved(DataSnapshot dataSnapshot, String s) {
        //If not dealing with ordered data forget about this
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
    });

विधि के नाम स्वयं व्याख्यात्मक हैं। जैसा कि आप देख सकते हैं कि जब भी कोई नया उपयोगकर्ता जोड़ा जाता है या मौजूदा उपयोगकर्ता की कुछ संपत्ति को संशोधित किया जाता है या उपयोगकर्ता को हटा दिया जाता है या बाल घटना श्रोता की उपयुक्त कॉलबैक विधि को प्रासंगिक डेटा के साथ बुलाया जाता है। यदि आप यूआई को चैट ऐप के लिए रिफ्रेश रख रहे हैं, तो JSON को onChildAdded () पार्स से POJO में प्राप्त करें और इसे अपने UI में फिट करें। उपयोगकर्ता द्वारा स्क्रीन छोड़ने पर अपने श्रोता को निकालना न भूलें।

onChildChanged () परिवर्तित गुणों (नए वाले) के साथ पूरे बच्चे का मूल्य देता है।

onChiledRemoved () हटाए गए बाल नोड लौटाता है।

पृष्ठ पर अंक लगाना के साथ डेटा पुनर्प्राप्त करना

जब आपके पास एक बहुत बड़ा JSON डेटाबेस होता है, तो मान इवेंट श्रोता को जोड़ने का कोई मतलब नहीं होता है। यह बहुत बड़ा JSON लौटाएगा और इसे पार्स करने में समय लगेगा। ऐसे मामलों में हम डेटा के पेजिंग और प्राप्त हिस्से का उपयोग कर सकते हैं और इसे प्रदर्शित या प्रोसेस कर सकते हैं। जब उपयोगकर्ता पुरानी चैट पर क्लिक करता है, तो आलसी लोडिंग की तरह या पुरानी चैट प्राप्त करना पसंद करता है। इस मामले में क्वेरी का उपयोग किया जा सकता है।

आइए पिछले खंडों में हमारे पुराने उदाहरण को लें। उपयोगकर्ता आधार में 3 उपयोगकर्ता शामिल हैं, अगर यह 3 सौ हजार उपयोगकर्ता कहने के लिए बढ़ता है और आप उपयोगकर्ता सूची को 50 के बैच में लाना चाहते हैं: 

// class level
final int limit = 50;
int start = 0;

// event level
Query userListQuery = userDBRef.orderByChild("email").limitToFirst(limit)
        .startAt(start)
userListQuery.addValueEventListener(new ValueEventListener() {
    @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
        // Do something
        start += (limit+1);
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        // Do something about the error
    });

यहां मूल्य या बच्चे की घटनाओं को जोड़ा जा सकता है और सुनी जा सकती है। अगले 50 को लाने के लिए फिर से कॉल करें। सुनिश्चित करें कि आर्डरबाइल्ड () विधि को जोड़ना सुनिश्चित करें , यह उसके बिना काम नहीं करेगा। फायरबेस को उस आदेश को जानना होगा जिसके द्वारा आप पृष्ठांकित कर रहे हैं।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow