@file:Suppress("UNUSED_VARIABLE", "UNUSED_ANONYMOUS_PARAMETER")

package com.google.example.firestore.kotlin

import android.util.Log

import com.google.firebase.Timestamp

import com.google.firebase.firestore.AggregateField

import com.google.firebase.firestore.AggregateSource

import com.google.firebase.firestore.DocumentChange

import com.google.firebase.firestore.FieldValue

import com.google.firebase.firestore.FirebaseFirestore

import com.google.firebase.firestore.FirebaseFirestoreException

import com.google.firebase.firestore.MetadataChanges

import com.google.firebase.firestore.Query

import com.google.firebase.firestore.ServerTimestamp

import com.google.firebase.firestore.SetOptions

import com.google.firebase.firestore.Source

import com.google.firebase.firestore.firestore

import com.google.firebase.firestore.firestoreSettings

import com.google.firebase.firestore.memoryCacheSettings

import com.google.firebase.firestore.persistentCacheSettings

import com.google.firebase.firestore.toObject

import com.google.firebase.Firebase

import java.util.ArrayList

import java.util.Date

import java.util.HashMap

import java.util.concurrent.LinkedBlockingQueue

import java.util.concurrent.ThreadPoolExecutor

import java.util.concurrent.TimeUnit

/**

* Kotlin version of doc snippets.

*

*/

abstract class DocSnippets(val db: FirebaseFirestore) {

companion object {

private val TAG = "DocSnippets"

private val EXECUTOR = ThreadPoolExecutor(

2,

4,

60,

TimeUnit.SECONDS,

LinkedBlockingQueue(),

)

}

internal fun runAll() {

Log.d(TAG, "================= BEGIN RUN ALL ===============")

// Write example data

exampleData()

exampleDataCollectionGroup()

// Run all other methods

addAdaLovelace()

addAlanTuring()

getAllUsers()

listenForUsers()

docReference()

collectionReference()

subcollectionReference()

setDocument()

dataTypes()

addDocument()

newDocument()

updateDocument()

updateDocumentNested()

setFieldWithMerge()

deleteDocument()

transactions()

transactionPromise()

getDocument()

getDocumentWithOptions()

listenToDocument()

listenToDocumentLocal()

getMultipleDocs()

getAllDocs()

listenToMultiple()

listenToDiffs()

listenState()

detachListener()

handleListenErrors()

simpleQueries()

compoundQueries()

orderAndLimit()

queryStartAtEndAt()

collectionGroupQuery()

// Run methods that should fail

try {

compoundQueriesInvalid()

} catch (e: Exception) {

Log.d(TAG, "compoundQueriesInvalid", e)

}

try {

orderAndLimitInvalid()

} catch (e: Exception) {

Log.d(TAG, "orderAndLimitInvalid", e)

}

}

private fun setup() {

// [START get_firestore_instance]

val db = Firebase.firestore

// [END get_firestore_instance]

// [START set_firestore_settings]

val settings = firestoreSettings {

// Use memory cache

setLocalCacheSettings(memoryCacheSettings {})

// Use persistent disk cache (default)

setLocalCacheSettings(persistentCacheSettings {})

}

db.firestoreSettings = settings

// [END set_firestore_settings]

}

private fun setupCacheSize() {

// [START fs_setup_cache]

val settings = firestoreSettings {

setLocalCacheSettings(persistentCacheSettings {

// Set size to 100 MB

setSizeBytes(1024 * 1024 * 100)

})

}

db.firestoreSettings = settings

// [END fs_setup_cache]

}

private fun addAdaLovelace() {

// [START add_ada_lovelace]

// Create a new user with a first and last name

val user = hashMapOf(

"first" to "Ada",

"last" to "Lovelace",

"born" to 1815,

)

// Add a new document with a generated ID

db.collection("users")

.add(user)

.addOnSuccessListener { documentReference ->

Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")

}

.addOnFailureListener { e ->

Log.w(TAG, "Error adding document", e)

}

// [END add_ada_lovelace]

}

private fun addAlanTuring() {

// [START add_alan_turing]

// Create a new user with a first, middle, and last name

val user = hashMapOf(

"first" to "Alan",

"middle" to "Mathison",

"last" to "Turing",

"born" to 1912,

)

// Add a new document with a generated ID

db.collection("users")

.add(user)

.addOnSuccessListener { documentReference ->

Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")

}

.addOnFailureListener { e ->

Log.w(TAG, "Error adding document", e)

}

// [END add_alan_turing]

}

private fun getAllUsers() {

// [START get_all_users]

db.collection("users")

.get()

.addOnSuccessListener { result ->

for (document in result) {

Log.d(TAG, "${document.id} => ${document.data}")

}

}

.addOnFailureListener { exception ->

Log.w(TAG, "Error getting documents.", exception)

}

// [END get_all_users]

}

private fun listenForUsers() {

// [START listen_for_users]

// Listen for users born before 1900.

//

// You will get a first snapshot with the initial results and a new

// snapshot each time there is a change in the results.

db.collection("users")

.whereLessThan("born", 1900)

.addSnapshotListener { snapshots, e ->

if (e != null) {

Log.w(TAG, "Listen failed.", e)

return@addSnapshotListener

}

Log.d(TAG, "Current users born before 1900: $snapshots")

}

// [END listen_for_users]

}

private fun docReference() {

// [START doc_reference]

val alovelaceDocumentRef = db.collection("users").document("alovelace")

// [END doc_reference]

}

private fun collectionReference() {

// [START collection_reference]

val usersCollectionRef = db.collection("users")

// [END collection_reference]

}

private fun subcollectionReference() {

// [START subcollection_reference]

val messageRef = db

.collection("rooms").document("roomA")

.collection("messages").document("message1")

// [END subcollection_reference]

}

fun docReferenceAlternate() {

// [START doc_reference_alternate]

val alovelaceDocumentRef = db.document("users/alovelace")

// [END doc_reference_alternate]

}

// [START city_class]

data class City(

val name: String? = null,

val state: String? = null,

val country: String? = null,

@field:JvmField // use this annotation if your Boolean field is prefixed with 'is'

val isCapital: Boolean? = null,

val population: Long? = null,

val regions: List<String>? = null,

)

// [END city_class]

private fun setDocument() {

// [START set_document]

val city = hashMapOf(

"name" to "Los Angeles",

"state" to "CA",

"country" to "USA",

)

db.collection("cities").document("LA")

.set(city)

.addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") }

.addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }

// [END set_document]

val data = HashMap<String, Any>()

// [START set_with_id]

db.collection("cities").document("new-city-id").set(data)

// [END set_with_id]

}

private fun dataTypes() {

// [START data_types]

val docData = hashMapOf(

"stringExample" to "Hello world!",

"booleanExample" to true,

"numberExample" to 3.14159265,

"dateExample" to Timestamp(Date()),

"listExample" to arrayListOf(1, 2, 3),

"nullExample" to null,

)

val nestedData = hashMapOf(

"a" to 5,

"b" to true,

)

docData["objectExample"] = nestedData

db.collection("data").document("one")

.set(docData)

.addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") }

.addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }

// [END data_types]

}

fun addCustomClass() {

// [START add_custom_class]

val city = City(

"Los Angeles",

"CA",

"USA",

false,

5000000L,

listOf("west_coast", "socal"),

)

db.collection("cities").document("LA").set(city)

// [END add_custom_class]

}

private fun addDocument() {

// [START add_document]

// Add a new document with a generated id.

val data = hashMapOf(

"name" to "Tokyo",

"country" to "Japan",

)

db.collection("cities")

.add(data)

.addOnSuccessListener { documentReference ->

Log.d(TAG, "DocumentSnapshot written with ID: ${documentReference.id}")

}

.addOnFailureListener { e ->

Log.w(TAG, "Error adding document", e)

}

// [END add_document]

}

private fun newDocument() {

// [START new_document]

val data = HashMap<String, Any>()

val newCityRef = db.collection("cities").document()

// Later...

newCityRef.set(data)

// [END new_document]

}

private fun updateDocument() {

// [START update_document]

val washingtonRef = db.collection("cities").document("DC")

// Set the "isCapital" field of the city 'DC'

washingtonRef

.update("capital", true)

.addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully updated!") }

.addOnFailureListener { e -> Log.w(TAG, "Error updating document", e) }

// [END update_document]

}

fun updateDocumentArray() {

// [START update_document_array]

val washingtonRef = db.collection("cities").document("DC")

// Atomically add a new region to the "regions" array field.

washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"))

// Atomically remove a region from the "regions" array field.

washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"))

// [END update_document_array]

}

fun updateDocumentIncrement() {

// [START update_document_increment]

val washingtonRef = db.collection("cities").document("DC")

// Atomically increment the population of the city by 50.

washingtonRef.update("population", FieldValue.increment(50))

// [END update_document_increment]

}

private fun updateDocumentNested() {

// [START update_document_nested]

// Assume the document contains:

// {

// name: "Frank",

// favorites: { food: "Pizza", color: "Blue", subject: "recess" }

// age: 12

// }

//

// To update age and favorite color:

db.collection("users").document("frank")

.update(

mapOf(

"age" to 13,

"favorites.color" to "Red",

),

)

// [END update_document_nested]

}

private fun setFieldWithMerge() {

// [START set_field_with_merge]

// Update one field, creating the document if it does not already exist.

val data = hashMapOf("capital" to true)

db.collection("cities").document("BJ")

.set(data, SetOptions.merge())

// [END set_field_with_merge]

}

private fun deleteDocument() {

// [START delete_document]

db.collection("cities").document("DC")

.delete()

.addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully deleted!") }

.addOnFailureListener { e -> Log.w(TAG, "Error deleting document", e) }

// [END delete_document]

}

private fun transactions() {

// [START transactions]

val sfDocRef = db.collection("cities").document("SF")

db.runTransaction { transaction ->

val snapshot = transaction.get(sfDocRef)

// Note: this could be done without a transaction

// by updating the population using FieldValue.increment()

val newPopulation = snapshot.getDouble("population")!! + 1

transaction.update(sfDocRef, "population", newPopulation)

// Success

null

}.addOnSuccessListener { Log.d(TAG, "Transaction success!") }

.addOnFailureListener { e -> Log.w(TAG, "Transaction failure.", e) }

// [END transactions]

}

private fun transactionPromise() {

// [START transaction_with_result]

val sfDocRef = db.collection("cities").document("SF")

db.runTransaction { transaction ->

val snapshot = transaction.get(sfDocRef)

val newPopulation = snapshot.getDouble("population")!! + 1

if (newPopulation <= 1000000) {

transaction.update(sfDocRef, "population", newPopulation)

newPopulation

} else {

throw FirebaseFirestoreException(

"Population too high",

FirebaseFirestoreException.Code.ABORTED,

)

}

}.addOnSuccessListener { result ->

Log.d(TAG, "Transaction success: $result")

}.addOnFailureListener { e ->

Log.w(TAG, "Transaction failure.", e)

}

// [END transaction_with_result]

}

fun writeBatch() {

// [START write_batch]

val nycRef = db.collection("cities").document("NYC")

val sfRef = db.collection("cities").document("SF")

val laRef = db.collection("cities").document("LA")

// Get a new write batch and commit all write operations

db.runBatch { batch ->

// Set the value of 'NYC'

batch.set(nycRef, City())

// Update the population of 'SF'

batch.update(sfRef, "population", 1000000L)

// Delete the city 'LA'

batch.delete(laRef)

}.addOnCompleteListener {

// ...

}

// [END write_batch]

}

private fun getDocument() {

// [START get_document]

val docRef = db.collection("cities").document("SF")

docRef.get()

.addOnSuccessListener { document ->

if (document != null) {

Log.d(TAG, "DocumentSnapshot data: ${document.data}")

} else {

Log.d(TAG, "No such document")

}

}

.addOnFailureListener { exception ->

Log.d(TAG, "get failed with ", exception)

}

// [END get_document]

}

private fun getDocumentWithOptions() {

// [START get_document_options]

val docRef = db.collection("cities").document("SF")

// Source can be CACHE, SERVER, or DEFAULT.

val source = Source.CACHE

// Get the document, forcing the SDK to use the offline cache

docRef.get(source).addOnCompleteListener { task ->

if (task.isSuccessful) {

// Document found in the offline cache

val document = task.result

Log.d(TAG, "Cached document data: ${document?.data}")

} else {

Log.d(TAG, "Cached get failed: ", task.exception)

}

}

// [END get_document_options]

}

fun customObjects() {

// [START custom_objects]

val docRef = db.collection("cities").document("BJ")

docRef.get().addOnSuccessListener { documentSnapshot ->

val city = documentSnapshot.toObject<City>()

}

// [END custom_objects]

}

private fun listenToDocument() {

// [START listen_document]

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")

}

}

// [END listen_document]

}

private fun listenToDocumentLocal() {

// [START listen_document_local]

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")

}

}

// [END listen_document_local]

}

fun listenWithMetadata() {

// [START listen_with_metadata]

// Listen for metadata changes to the document.

val docRef = db.collection("cities").document("SF")

docRef.addSnapshotListener(MetadataChanges.INCLUDE) { snapshot, e ->

// ...

}

// [END listen_with_metadata]

}

private fun getMultipleDocs() {

// [START get_multiple]

db.collection("cities")

.whereEqualTo("capital", true)

.get()

.addOnSuccessListener { documents ->

for (document in documents) {

Log.d(TAG, "${document.id} => ${document.data}")

}

}

.addOnFailureListener { exception ->

Log.w(TAG, "Error getting documents: ", exception)

}

// [END get_multiple]

}

private fun getAllDocs() {

// [START get_multiple_all]

db.collection("cities")

.get()

.addOnSuccessListener { result ->

for (document in result) {

Log.d(TAG, "${document.id} => ${document.data}")

}

}

.addOnFailureListener { exception ->

Log.d(TAG, "Error getting documents: ", exception)

}

// [END get_multiple_all]

}

private fun getAllDocsSubcollection() {

// [START firestore_query_subcollection]

db.collection("cities")

.document("SF")

.collection("landmarks")

.get()

.addOnSuccessListener { result ->

for (document in result) {

Log.d(TAG, "${document.id} => ${document.data}")

}

}

.addOnFailureListener { exception ->

Log.d(TAG, "Error getting documents: ", exception)

}

// [END firestore_query_subcollection]

}

private fun listenToMultiple() {

// [START listen_multiple]

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")

}

// [END listen_multiple]

}

private fun listenToDiffs() {

// [START listen_diffs]

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}")

}

}

}

// [END listen_diffs]

}

private fun listenState() {

// [START listen_state]

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) {

if (dc.type == DocumentChange.Type.ADDED) {

Log.d(TAG, "New city: ${dc.document.data}")

}

}

if (!snapshots.metadata.isFromCache) {

Log.d(TAG, "Got initial state.")

}

}

// [END listen_state]

}

private fun detachListener() {

// [START detach_listener]

val query = db.collection("cities")

val registration = query.addSnapshotListener { snapshots, e ->

// ...

}

// ...

// Stop listening to changes

registration.remove()

// [END detach_listener]

}

private fun handleListenErrors() {

// [START handle_listen_errors]

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}")

}

}

}

// [END handle_listen_errors]

}

private fun exampleData() {

// [START example_data]

val cities = db.collection("cities")

val data1 = hashMapOf(

"name" to "San Francisco",

"state" to "CA",

"country" to "USA",

"capital" to false,

"population" to 860000,

"regions" to listOf("west_coast", "norcal"),

)

cities.document("SF").set(data1)

val data2 = hashMapOf(

"name" to "Los Angeles",

"state" to "CA",

"country" to "USA",

"capital" to false,

"population" to 3900000,

"regions" to listOf("west_coast", "socal"),

)

cities.document("LA").set(data2)

val data3 = hashMapOf(

"name" to "Washington D.C.",

"state" to null,

"country" to "USA",

"capital" to true,

"population" to 680000,

"regions" to listOf("east_coast"),

)

cities.document("DC").set(data3)

val data4 = hashMapOf(

"name" to "Tokyo",

"state" to null,

"country" to "Japan",

"capital" to true,

"population" to 9000000,

"regions" to listOf("kanto", "honshu"),

)

cities.document("TOK").set(data4)

val data5 = hashMapOf(

"name" to "Beijing",

"state" to null,

"country" to "China",

"capital" to true,

"population" to 21500000,

"regions" to listOf("jingjinji", "hebei"),

)

cities.document("BJ").set(data5)

// [END example_data]

}

fun exampleDataCollectionGroup() {

// [START fs_collection_group_query_data_setup]

val citiesRef = db.collection("cities")

val ggbData = mapOf(

"name" to "Golden Gate Bridge",

"type" to "bridge",

)

citiesRef.document("SF").collection("landmarks").add(ggbData)

val lohData = mapOf(

"name" to "Legion of Honor",

"type" to "museum",

)

citiesRef.document("SF").collection("landmarks").add(lohData)

val gpData = mapOf(

"name" to "Griffth Park",

"type" to "park",

)

citiesRef.document("LA").collection("landmarks").add(gpData)

val tgData = mapOf(

"name" to "The Getty",

"type" to "museum",

)

citiesRef.document("LA").collection("landmarks").add(tgData)

val lmData = mapOf(

"name" to "Lincoln Memorial",

"type" to "memorial",

)

citiesRef.document("DC").collection("landmarks").add(lmData)

val nasaData = mapOf(

"name" to "National Air and Space Museum",

"type" to "museum",

)

citiesRef.document("DC").collection("landmarks").add(nasaData)

val upData = mapOf(

"name" to "Ueno Park",

"type" to "park",

)

citiesRef.document("TOK").collection("landmarks").add(upData)

val nmData = mapOf(

"name" to "National Musuem of Nature and Science",

"type" to "museum",

)

citiesRef.document("TOK").collection("landmarks").add(nmData)

val jpData = mapOf(

"name" to "Jingshan Park",

"type" to "park",

)

citiesRef.document("BJ").collection("landmarks").add(jpData)

val baoData = mapOf(

"name" to "Beijing Ancient Observatory",

"type" to "musuem",

)

citiesRef.document("BJ").collection("landmarks").add(baoData)

// [END fs_collection_group_query_data_setup]

}

private fun simpleQueries() {

// [START simple_queries]

// Create a reference to the cities collection

val citiesRef = db.collection("cities")

// Create a query against the collection.

val query = citiesRef.whereEqualTo("state", "CA")

// [END simple_queries]

// [START simple_query_capital]

val capitalCities = db.collection("cities").whereEqualTo("capital", true)

// [END simple_query_capital]

// [START example_filters]

val stateQuery = citiesRef.whereEqualTo("state", "CA")

val populationQuery = citiesRef.whereLessThan("population", 100000)

val nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco")

// [END example_filters]

// [START simple_query_not_equal]

val notCapitalQuery = citiesRef.whereNotEqualTo("capital", false)

// [END simple_query_not_equal]

}

fun arrayContainsQueries() {

// [START array_contains_filter]

val citiesRef = db.collection("cities")

citiesRef.whereArrayContains("regions", "west_coast")

// [END array_contains_filter]

}

fun arrayContainsAnyQueries() {

// [START array_contains_any_filter]

val citiesRef = db.collection("cities")

citiesRef.whereArrayContainsAny("regions", listOf("west_coast", "east_coast"))

// [END array_contains_any_filter]

}

fun inQueries() {

// [START in_filter]

val citiesRef = db.collection("cities")

citiesRef.whereIn("country", listOf("USA", "Japan"))

// [END in_filter]

// [START not_in_filter]

citiesRef.whereNotIn("country", listOf("USA", "Japan"))

// [END not_in_filter]

// [START in_filter_with_array]

citiesRef.whereIn("regions", listOf(arrayOf("west_coast"), arrayOf("east_coast")))

// [END in_filter_with_array]

}

private fun compoundQueries() {

val citiesRef = db.collection("cities")

// [START chain_filters]

citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver")

citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000)

// [END chain_filters]

// [START valid_range_filters]

citiesRef.whereGreaterThanOrEqualTo("state", "CA")

.whereLessThanOrEqualTo("state", "IN")

citiesRef.whereEqualTo("state", "CA")

.whereGreaterThan("population", 1000000)

// [END valid_range_filters]

}

private fun compoundQueriesInvalid() {

val citiesRef = db.collection("cities")

// [START invalid_range_filters]

citiesRef.whereGreaterThanOrEqualTo("state", "CA")

.whereGreaterThan("population", 100000)

// [END invalid_range_filters]

}

private fun orderAndLimit() {

val citiesRef = db.collection("cities")

// [START order_and_limit]

citiesRef.orderBy("name").limit(3)

// [END order_and_limit]

// [START order_and_limit_desc]

citiesRef.orderBy("name", Query.Direction.DESCENDING).limit(3)

// [END order_and_limit_desc]

// [START order_by_multiple]

citiesRef.orderBy("state").orderBy("population", Query.Direction.DESCENDING)

// [END order_by_multiple]

// [START filter_and_order]

citiesRef.whereGreaterThan("population", 100000).orderBy("population").limit(2)

// [END filter_and_order]

// [START valid_filter_and_order]

citiesRef.whereGreaterThan("population", 100000).orderBy("population")

// [END valid_filter_and_order]

}

private fun orderAndLimitInvalid() {

val citiesRef = db.collection("cities")

// [START invalid_filter_and_order]

citiesRef.whereGreaterThan("population", 100000).orderBy("country")

// [END invalid_filter_and_order]

}

private fun queryStartAtEndAt() {

// [START query_start_at_single]

// Get all cities with a population >= 1,000,000, ordered by population,

db.collection("cities")

.orderBy("population")

.startAt(1000000)

// [END query_start_at_single]

// [START query_end_at_single]

// Get all cities with a population <= 1,000,000, ordered by population,

db.collection("cities")

.orderBy("population")

.endAt(1000000)

// [END query_end_at_single]

// [START query_start_at_doc_snapshot]

// Get the data for "San Francisco"

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

.get()

.addOnSuccessListener { documentSnapshot ->

// Get all cities with a population bigger than San Francisco.

val biggerThanSf = db.collection("cities")

.orderBy("population")

.startAt(documentSnapshot)

// ...

}

// [END query_start_at_doc_snapshot]

// [START query_pagination]

// Construct query for first 25 cities, ordered by population

val first = db.collection("cities")

.orderBy("population")

.limit(25)

first.get()

.addOnSuccessListener { documentSnapshots ->

// ...

// Get the last visible document

val lastVisible = documentSnapshots.documents[documentSnapshots.size() - 1]

// Construct a new query starting at this document,

// get the next 25 cities.

val next = db.collection("cities")

.orderBy("population")

.startAfter(lastVisible)