Cloud Firestore Android Codelab

$ git clone https://github.com/firebase/friendlyeats-android 

curl -sL https://firebase.tools | bash 

$ firebase --version 9.0.0 

$ firebase emulators:start i  emulators: Starting emulators: auth, firestore i  firestore: Firestore Emulator logging to firestore-debug.log i  ui: Emulator UI logging to ui-debug.log  ┌─────────────────────────────────────────────────────────────┐ │ ✔  All emulators ready! It is now safe to connect your app. │ │ i  View Emulator UI at http://localhost:4000                │ └─────────────────────────────────────────────────────────────┘  ┌────────────────┬────────────────┬─────────────────────────────────┐ │ Emulator       │ Host:Port      │ View in Emulator UI             │ ├────────────────┼────────────────┼─────────────────────────────────┤ │ Authentication │ localhost:9099 │ http://localhost:4000/auth      │ ├────────────────┼────────────────┼─────────────────────────────────┤ │ Firestore      │ localhost:8080 │ http://localhost:4000/firestore │ └────────────────┴────────────────┴─────────────────────────────────┘   Emulator Hub running at localhost:4400   Other reserved ports: 4500  Issues? Report them at https://github.com/firebase/firebase-tools/issues and attach the *-debug.log files. 

    // Use emulators only in debug builds     if (BuildConfig.DEBUG) {         firestore.useEmulator(FIRESTORE_EMULATOR_HOST, FIRESTORE_EMULATOR_PORT)     } 

    private fun onAddItemsClicked() {         val restaurantsRef = firestore.collection("restaurants")         for (i in 0..9) {             // Create random restaurant / ratings             val randomRestaurant = RestaurantUtil.getRandom(requireContext())              // Add restaurant             restaurantsRef.add(randomRestaurant)         }     } 

        // Firestore         firestore = Firebase.firestore          // Get the 50 highest rated restaurants         query = firestore.collection("restaurants")             .orderBy("avgRating", Query.Direction.DESCENDING)             .limit(LIMIT.toLong()) 

abstract class FirestoreAdapter<VH : RecyclerView.ViewHolder>(private var query: Query?) :         RecyclerView.Adapter<VH>(),         EventListener<QuerySnapshot> { // Add this implements          // ...      // Add this method     override fun onEvent(documentSnapshots: QuerySnapshot?, e: FirebaseFirestoreException?) {                  // Handle errors         if (e != null) {             Log.w(TAG, "onEvent:error", e)             return         }          // Dispatch the event         if (documentSnapshots != null) {             for (change in documentSnapshots.documentChanges) {                 // snapshot of the changed document                 when (change.type) {                     DocumentChange.Type.ADDED -> {                         // TODO: handle document added                     }                     DocumentChange.Type.MODIFIED -> {                         // TODO: handle document changed                     }                     DocumentChange.Type.REMOVED -> {                         // TODO: handle document removed                     }                 }             }         }          onDataChanged()     }          // ... } 

    private fun onDocumentAdded(change: DocumentChange) {         snapshots.add(change.newIndex, change.document)         notifyItemInserted(change.newIndex)     }      private fun onDocumentModified(change: DocumentChange) {         if (change.oldIndex == change.newIndex) {             // Item changed but remained in same position             snapshots[change.oldIndex] = change.document             notifyItemChanged(change.oldIndex)         } else {             // Item changed and changed position             snapshots.removeAt(change.oldIndex)             snapshots.add(change.newIndex, change.document)             notifyItemMoved(change.oldIndex, change.newIndex)         }     }      private fun onDocumentRemoved(change: DocumentChange) {         snapshots.removeAt(change.oldIndex)         notifyItemRemoved(change.oldIndex)     } 

    override fun onEvent(documentSnapshots: QuerySnapshot?, e: FirebaseFirestoreException?) {          // Handle errors         if (e != null) {             Log.w(TAG, "onEvent:error", e)             return         }          // Dispatch the event         if (documentSnapshots != null) {             for (change in documentSnapshots.documentChanges) {                 // snapshot of the changed document                 when (change.type) {                     DocumentChange.Type.ADDED -> {                         onDocumentAdded(change) // Add this line                     }                     DocumentChange.Type.MODIFIED -> {                         onDocumentModified(change) // Add this line                     }                     DocumentChange.Type.REMOVED -> {                         onDocumentRemoved(change) // Add this line                     }                 }             }         }          onDataChanged()     } 

    fun startListening() {         if (registration == null) {             registration = query.addSnapshotListener(this)         }     } 

    override fun onFilter(filters: Filters) {         // Construct query basic query         var query: Query = firestore.collection("restaurants")          // Category (equality filter)         if (filters.hasCategory()) {             query = query.whereEqualTo(Restaurant.FIELD_CATEGORY, filters.category)         }          // City (equality filter)         if (filters.hasCity()) {             query = query.whereEqualTo(Restaurant.FIELD_CITY, filters.city)         }          // Price (equality filter)         if (filters.hasPrice()) {             query = query.whereEqualTo(Restaurant.FIELD_PRICE, filters.price)         }          // Sort by (orderBy with direction)         if (filters.hasSortBy()) {             query = query.orderBy(filters.sortBy.toString(), filters.sortDirection)         }          // Limit items         query = query.limit(LIMIT.toLong())          // Update the query         adapter.setQuery(query)          // Set header         binding.textCurrentSearch.text = HtmlCompat.fromHtml(             filters.getSearchDescription(requireContext()),             HtmlCompat.FROM_HTML_MODE_LEGACY         )         binding.textCurrentSortBy.text = filters.getOrderDescription(requireContext())          // Save filters         viewModel.filters = filters     } 

val subRef = firestore.collection("restaurants")         .document("abc123")         .collection("ratings") 

    private fun addRating(restaurantRef: DocumentReference, rating: Rating): Task<Void> {         // Create reference for new rating, for use inside the transaction         val ratingRef = restaurantRef.collection("ratings").document()          // In a transaction, add the new rating and update the aggregate totals         return firestore.runTransaction { transaction ->             val restaurant = transaction.get(restaurantRef).toObject<Restaurant>()                 ?: throw Exception("Restaurant not found at ${restaurantRef.path}")              // Compute new number of ratings             val newNumRatings = restaurant.numRatings + 1              // Compute new average rating             val oldRatingTotal = restaurant.avgRating * restaurant.numRatings             val newAvgRating = (oldRatingTotal + rating.rating) / newNumRatings              // Set new restaurant info             restaurant.numRatings = newNumRatings             restaurant.avgRating = newAvgRating              // Commit to Firestore             transaction.set(restaurantRef, restaurant)             transaction.set(ratingRef, rating)              null         }     } 

rules_version = '2'; service cloud.firestore {   match /databases/{database}/documents {     // Determine if the value of the field "key" is the same     // before and after the request.     function isUnchanged(key) {       return (key in resource.data)         && (key in request.resource.data)         && (resource.data[key] == request.resource.data[key]);     }      // Restaurants     match /restaurants/{restaurantId} {       // Any signed-in user can read       allow read: if request.auth != null;        // Any signed-in user can create       // WARNING: this rule is for demo purposes only!       allow create: if request.auth != null;        // Updates are allowed if no fields are added and name is unchanged       allow update: if request.auth != null                     && (request.resource.data.keys() == resource.data.keys())                     && isUnchanged("name");        // Deletes are not allowed.       // Note: this is the default, there is no need to explicitly state this.       allow delete: if false;        // Ratings       match /ratings/{ratingId} {         // Any signed-in user can read         allow read: if request.auth != null;          // Any signed-in user can create if their uid matches the document         allow create: if request.auth != null                       && request.resource.data.userId == request.auth.uid;          // Deletes and updates are not allowed (default)         allow update, delete: if false;       }     }   } } 

$ firebase deploy --only firestore:rules 

{   "indexes": [     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "city", "mode": "ASCENDING" },         { "fieldPath": "avgRating", "mode": "DESCENDING" }       ]     },     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "category", "mode": "ASCENDING" },         { "fieldPath": "avgRating", "mode": "DESCENDING" }       ]     },     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "price", "mode": "ASCENDING" },         { "fieldPath": "avgRating", "mode": "DESCENDING" }       ]     },     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "city", "mode": "ASCENDING" },         { "fieldPath": "numRatings", "mode": "DESCENDING" }       ]     },     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "category", "mode": "ASCENDING" },         { "fieldPath": "numRatings", "mode": "DESCENDING" }       ]     },     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "price", "mode": "ASCENDING" },         { "fieldPath": "numRatings", "mode": "DESCENDING" }       ]     },     {       "collectionId": "restaurants",       "queryScope": "COLLECTION",       "fields": [         { "fieldPath": "city", "mode": "ASCENDING" },         { "fieldPath": "price", "mode": "ASCENDING" }       ]     },     {       "collectionId": "restaurants",       "fields": [         { "fieldPath": "category", "mode": "ASCENDING" },         { "fieldPath": "price", "mode": "ASCENDING" }       ]     }   ],   "fieldOverrides": [] } 

$ firebase deploy --only firestore:indexes 

    override fun create(context: Context): FirebaseFirestore {         val firestore = Firebase.firestore         // Use emulators only in debug builds         if (BuildConfig.DEBUG) {             firestore.useEmulator(FIRESTORE_EMULATOR_HOST, FIRESTORE_EMULATOR_PORT)         }         return firestore     }