1. Ringkasan
Sasaran
Dalam codelab ini, Anda akan membangun aplikasi rekomendasi restoran di Android yang didukung oleh Cloud Firestore. Anda akan mempelajari cara:
- Membaca dan menulis data ke Firestore dari aplikasi Android
- Memproses perubahan pada data Firestore secara real time
- Menggunakan Firebase Authentication dan aturan keamanan untuk mengamankan data Firestore
- Menulis kueri Firestore yang kompleks
Prasyarat
Sebelum memulai codelab ini, pastikan Anda memiliki:
- Android Studio Flamingo atau yang lebih baru
- Emulator Android dengan API 19 atau yang lebih tinggi
- Node.js versi 16 atau yang lebih baru
- Java versi 17 atau yang lebih baru
2. Membuat project Firebase
- Login ke Firebase console dengan akun Google Anda.
- Di Firebase console, klik Add project.
- Seperti yang ditunjukkan pada screenshot di bawah ini, masukkan nama untuk project Firebase Anda (misalnya, "Friendly Eats"), dan klik Continue.
- Anda mungkin akan diminta untuk mengaktifkan Google Analytics karena tujuan codelab ini tidak menjadi masalah.
- Setelah sekitar satu menit, project Firebase Anda akan siap. Klik Lanjutkan.
3. Menyiapkan project contoh
Mendownload kode
Jalankan perintah berikut untuk meng-clone kode contoh untuk codelab ini. Tindakan ini akan membuat folder bernama friendlyeats-android di komputer Anda:
$ git clone https://github.com/firebase/friendlyeats-android
Jika tidak memiliki git di komputer, Anda juga dapat mendownload kode langsung dari GitHub.
Menambahkan konfigurasi Firebase
- Di Firebase console, pilih Project Overview di panel navigasi sebelah kiri. Klik tombol Android untuk memilih platform. Saat diminta untuk memasukkan nama paket, gunakan
com.google.firebase.example.fireeats
- Klik Register App dan ikuti petunjuk untuk mendownload file
google-services.json, lalu pindahkan ke folderapp/dari kode yang baru saja Anda download. Kemudian klik Berikutnya.
Mengimpor project
Buka Android Studio. Klik File > Baru > Import Project dan pilih folder friendlyeats-android.
4. Menyiapkan Emulator Firebase
Dalam codelab ini, Anda akan menggunakan Firebase Emulator Suite untuk mengemulasi Cloud Firestore dan layanan Firebase lainnya secara lokal. Ini menyediakan lingkungan pengembangan lokal yang aman, cepat, dan tanpa biaya untuk membangun aplikasi Anda.
Menginstal Firebase CLI
Pertama-tama, Anda harus menginstal Firebase CLI. Jika menggunakan macOS atau Linux, Anda dapat menjalankan perintah cURL berikut:
curl -sL https://firebase.tools | bash
Jika Anda menggunakan Windows, baca petunjuk penginstalan untuk mendapatkan biner mandiri atau menginstal melalui npm.
Setelah menginstal CLI, menjalankan firebase --version akan melaporkan versi 9.0.0 atau yang lebih tinggi:
$ firebase --version 9.0.0
Masuk
Jalankan firebase login untuk menghubungkan CLI ke Akun Google Anda. Tindakan ini akan membuka jendela browser baru untuk menyelesaikan proses login. Pastikan untuk memilih akun yang sama dengan yang Anda gunakan saat membuat project Firebase sebelumnya.
Tautkan project Anda
Dari dalam folder friendlyeats-android, jalankan firebase use --add untuk menghubungkan project lokal ke project Firebase. Ikuti petunjuk untuk memilih project yang Anda buat sebelumnya dan jika diminta untuk memilih alias, masukkan default.
5. Menjalankan aplikasi
Sekarang saatnya menjalankan Firebase Emulator Suite dan aplikasi Android FriendlyEats untuk pertama kalinya.
Menjalankan emulator
Di terminal dari dalam direktori friendlyeats-android, jalankan firebase emulators:start untuk memulai Emulator Firebase. Anda akan melihat log seperti ini:
$ 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.
Sekarang Anda memiliki lingkungan pengembangan lokal lengkap yang berjalan di komputer. Pastikan perintah ini tetap berjalan selama codelab. Aplikasi Android Anda harus terhubung ke emulator.
Menghubungkan aplikasi ke Emulator
Buka file util/FirestoreInitializer.kt dan util/AuthInitializer.kt di Android Studio. File ini berisi logika untuk menghubungkan Firebase SDK ke emulator lokal yang berjalan di komputer Anda, saat aplikasi dimulai.
Pada metode create() di class FirestoreInitializer, periksa bagian kode ini:
// Use emulators only in debug builds
if (BuildConfig.DEBUG) {
firestore.useEmulator(FIRESTORE_EMULATOR_HOST, FIRESTORE_EMULATOR_PORT)
}
Kita menggunakan BuildConfig untuk memastikan kita hanya terhubung ke emulator saat aplikasi berjalan dalam mode debug. Saat kita mengompilasi aplikasi dalam mode release, kondisi ini akan bernilai salah.
Kita dapat melihat bahwa kode ini menggunakan metode useEmulator(host, port) untuk menghubungkan Firebase SDK ke emulator Firestore lokal. Di seluruh aplikasi, kita akan menggunakan FirebaseUtil.getFirestore() untuk mengakses instance FirebaseFirestore ini sehingga kita yakin bahwa kita selalu terhubung ke emulator Firestore saat berjalan dalam mode debug.
Menjalankan aplikasi
Jika Anda telah menambahkan file google-services.json dengan benar, project kini seharusnya dapat dikompilasi. Di Android Studio, klik Build > Rebuild Project dan pastikan tidak ada error yang tersisa.
Di Android Studio, Run aplikasi di emulator Android. Pertama-tama, Anda akan melihat "Login" layar. Anda dapat menggunakan email dan sandi apa pun untuk login ke aplikasi. Proses login ini terhubung ke emulator Firebase Authentication, jadi tidak ada kredensial sungguhan yang dikirim.
Sekarang buka UI Emulator dengan membuka http://localhost:4000 di browser web Anda. Kemudian, klik tab Authentication dan Anda akan melihat akun yang baru saja dibuat:
Setelah menyelesaikan proses login, Anda akan melihat layar utama aplikasi:
Kita akan segera menambahkan beberapa data untuk mengisi layar utama.
6. Menulis data ke Firestore
Di bagian ini, kita akan menulis beberapa data ke Firestore sehingga kita dapat mengisi layar utama yang saat ini kosong.
Objek model utama di aplikasi kita adalah restoran (lihat model/Restaurant.kt). Data Firestore dibagi menjadi dokumen, koleksi, dan subkoleksi. Kita akan menyimpan setiap restoran sebagai dokumen di koleksi level teratas yang bernama "restaurants". Untuk mempelajari model data Firestore lebih lanjut, baca dokumen dan koleksi di dokumentasi.
Untuk tujuan demonstrasi, kita akan menambahkan fungsi di aplikasi untuk membuat sepuluh restoran acak saat kita mengklik tombol "Tambahkan Item Acak" di menu tambahan. Buka file MainFragment.kt dan ganti konten dalam metode onAddItemsClicked() dengan:
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)
}
}
Ada beberapa hal penting yang perlu diperhatikan tentang kode di atas:
- Kita memulai dengan mendapatkan referensi ke koleksi
"restaurants". Koleksi dibuat secara implisit saat dokumen ditambahkan, sehingga tidak perlu membuat koleksi sebelum menulis data. - Dokumen dapat dibuat menggunakan class data Kotlin, yang kita gunakan untuk membuat setiap dokumen Restoran.
- Metode
add()menambahkan dokumen ke koleksi dengan ID yang dibuat secara otomatis, sehingga kita tidak perlu menentukan ID unik untuk setiap Restoran.
Sekarang jalankan kembali aplikasi dan klik "Add Random Items" di menu tambahan (di sudut kanan atas) untuk memanggil kode yang baru saja Anda tulis:
Sekarang buka UI Emulator dengan membuka http://localhost:4000 di browser web Anda. Kemudian klik tab Firestore dan Anda akan melihat data yang baru saja Anda tambahkan:
Data ini 100% bersifat lokal untuk komputer Anda. Bahkan, project Anda yang sebenarnya belum berisi database Firestore. Artinya, Anda dapat bereksperimen dengan memodifikasi dan menghapus data ini tanpa konsekuensi.
Selamat, Anda baru saja menulis data ke Firestore. Pada langkah berikutnya, kita akan mempelajari cara menampilkan data ini di aplikasi.
7. Menampilkan data dari Firestore
Pada langkah ini, kita akan mempelajari cara mengambil data dari Firestore dan menampilkannya di aplikasi. Langkah pertama untuk membaca data dari Firestore adalah membuat Query. Buka file MainFragment.kt dan tambahkan kode berikut ke awal metode onViewCreated():
// Firestore
firestore = Firebase.firestore
// Get the 50 highest rated restaurants
query = firestore.collection("restaurants")
.orderBy("avgRating", Query.Direction.DESCENDING)
.limit(LIMIT.toLong())
Sekarang kita ingin memproses kueri, sehingga kita mendapatkan semua dokumen yang cocok dan mendapatkan notifikasi tentang pembaruan mendatang secara real time. Karena tujuan akhir kita adalah mengikat data ini ke RecyclerView, kita perlu membuat class RecyclerView.Adapter untuk memproses data.
Buka class FirestoreAdapter, yang telah diimplementasikan sebagian. Pertama, mari kita buat adaptor menerapkan EventListener dan menentukan fungsi onEvent agar dapat menerima pembaruan pada kueri Firestore:
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()
}
// ...
}
Saat pemuatan awal, pemroses akan menerima satu peristiwa ADDED untuk setiap dokumen baru. Seiring perubahan set hasil kueri dari waktu ke waktu, pemroses akan menerima lebih banyak peristiwa yang berisi perubahan tersebut. Sekarang, mari kita selesaikan penerapan pemroses. Pertama, tambahkan tiga metode baru: onDocumentAdded, onDocumentModified, dan onDocumentRemoved:
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)
}
Kemudian, panggil metode baru ini dari onEvent:
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()
}
Terakhir, terapkan metode startListening() untuk melampirkan pemroses:
fun startListening() {
if (registration == null) {
registration = query.addSnapshotListener(this)
}
}
Sekarang aplikasi sepenuhnya dikonfigurasi untuk membaca data dari Firestore. Jalankan aplikasi lagi dan Anda akan melihat restoran yang ditambahkan di langkah sebelumnya:
Sekarang, kembali ke UI Emulator di browser Anda dan edit salah satu nama restoran. Anda akan melihat perubahannya di aplikasi hampir seketika.
8. Mengurutkan dan memfilter data
Saat ini aplikasi menampilkan restoran berperingkat teratas di seluruh koleksi, tetapi di aplikasi restoran nyata, pengguna ingin mengurutkan dan memfilter data. Misalnya, aplikasi harus dapat menampilkan "Restoran seafood terpopuler di Palembang" atau "Pizza paling murah".
Mengklik panel putih di bagian atas aplikasi akan memunculkan dialog filter. Di bagian ini, kita akan menggunakan kueri Firestore untuk membuat dialog ini berfungsi:
Mari kita edit metode onFilter() dari MainFragment.kt. Metode ini menerima objek Filters yang merupakan objek helper yang kita buat untuk merekam output dialog filter. Kita akan mengubah metode ini untuk membuat kueri dari filter:
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
}
Dalam cuplikan di atas, kita mem-build objek Query dengan melampirkan klausa where dan orderBy agar cocok dengan filter yang diberikan.
Jalankan aplikasi lagi dan pilih filter berikut untuk menampilkan restoran murah yang paling populer:
Sekarang Anda akan melihat daftar restoran yang difilter yang hanya berisi opsi harga rendah:
Jika Anda telah sampai sejauh ini, berarti Anda telah membuat aplikasi tampilan rekomendasi restoran yang berfungsi penuh di Firestore. Anda kini dapat mengurutkan dan memfilter restoran secara real time. Di beberapa bagian berikutnya, kita akan menambahkan ulasan ke restoran dan menambahkan aturan keamanan ke aplikasi.
9. Mengatur data dalam subkoleksi
Di bagian ini, kita akan menambahkan rating ke aplikasi sehingga pengguna dapat mengulas restoran favorit (atau kurang favorit mereka).
Koleksi dan subkoleksi
Sejauh ini, kita telah menyimpan semua data restoran dalam koleksi tingkat teratas yang disebut "restaurants". Saat pengguna memberi rating pada restoran, kita ingin menambahkan objek Rating baru ke restoran tersebut. Untuk tugas ini, kita akan menggunakan subkoleksi. Anda dapat menganggap subkoleksi sebagai koleksi yang dilampirkan ke dokumen. Jadi, setiap dokumen restoran akan memiliki subkoleksi rating yang penuh dengan dokumen rating. Subkoleksi membantu mengatur data tanpa membebani dokumen atau memerlukan kueri yang rumit.
Untuk mengakses subkoleksi, panggil .collection() pada dokumen induk:
val subRef = firestore.collection("restaurants")
.document("abc123")
.collection("ratings")
Sama seperti koleksi tingkat teratas, Anda dapat mengakses dan membuat kueri subkoleksi. Tidak ada batasan ukuran atau perubahan performa. Anda dapat membaca lebih lanjut tentang model data Firestore di sini.
Menulis data dalam transaksi
Menambahkan Rating ke subkoleksi yang tepat hanya perlu memanggil .add(), tetapi kita juga perlu memperbarui rating rata-rata dan jumlah rating objek Restaurant untuk mencerminkan data baru. Jika kita menggunakan operasi terpisah untuk melakukan dua perubahan ini, ada sejumlah kondisi perlombaan yang dapat menyebabkan data usang atau salah.
Untuk memastikan rating ditambahkan dengan benar, kami akan menggunakan transaksi untuk menambahkan rating ke restoran. Transaksi ini akan melakukan beberapa tindakan:
- Membaca rating restoran saat ini dan menghitung yang baru
- Menambahkan rating ke subkoleksi
- Memperbarui rating rata-rata dan jumlah rating restoran
Buka RestaurantDetailFragment.kt dan terapkan fungsi addRating:
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
}
}
Fungsi addRating() menampilkan Task yang mewakili seluruh transaksi. Di fungsi onRating(), pemroses ditambahkan ke tugas untuk merespons hasil transaksi.
Sekarang Run aplikasi lagi dan klik salah satu restoran, yang akan memunculkan layar detail restoran. Klik tombol + untuk mulai menambahkan ulasan. Tambahkan ulasan dengan memilih jumlah bintang dan memasukkan beberapa teks.
Menekan Kirim akan memulai transaksi. Setelah transaksi selesai, Anda akan melihat ulasan ditampilkan di bawah ini dan pembaruan untuk jumlah ulasan restoran:
Selamat! Anda sekarang memiliki aplikasi ulasan restoran seluler lokal sosial yang dibangun di Cloud Firestore. Saya dengar kata-kata itu sangat populer akhir-akhir ini.
10. Melindungi data
Sejauh ini, kita belum mempertimbangkan keamanan aplikasi ini. Bagaimana kita tahu bahwa pengguna hanya dapat membaca dan menulis data yang benar sendiri? Database Firestore diamankan oleh file konfigurasi yang disebut Aturan Keamanan.
Buka file firestore.rules, Anda akan melihat seperti berikut:
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
//
// WARNING: These rules are insecure! We will replace them with
// more secure rules later in the codelab
//
allow read, write: if request.auth != null;
}
}
}
Mari kita ubah aturan ini untuk mencegah akses atau perubahan data yang tidak diinginkan. Buka file firestore.rules dan ganti kontennya dengan kode berikut:
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;
}
}
}
}
Aturan ini membatasi akses untuk memastikan bahwa klien hanya membuat perubahan yang aman. Misalnya, pembaruan pada dokumen restoran hanya dapat mengubah rating, bukan nama atau data lain yang sifatnya tidak dapat diubah. Rating hanya dapat dibuat jika ID pengguna cocok dengan pengguna yang login, guna mencegah spoofing.
Untuk membaca lebih lanjut tentang Aturan Keamanan, buka dokumentasinya.
11. Kesimpulan
Sekarang Anda telah membuat aplikasi berfitur lengkap di atas Firestore. Anda telah mempelajari fitur Firestore yang paling penting, termasuk:
- Dokumen dan koleksi
- Membaca dan menulis data
- Mengurutkan dan memfilter dengan kueri
- Subkoleksi
- Transaksi
Pelajari Lebih Lanjut
Untuk terus mempelajari Firestore, berikut beberapa tempat yang bagus untuk memulai:
Aplikasi restoran dalam codelab ini didasarkan pada "Friendly Eats" aplikasi contoh. Anda dapat menjelajahi kode sumber untuk aplikasi tersebut di sini.
Opsional: Men-deploy ke produksi
Sejauh ini, aplikasi ini hanya menggunakan Firebase Emulator Suite. Jika Anda ingin mempelajari cara men-deploy aplikasi ini ke project Firebase sungguhan, lanjutkan ke langkah berikutnya.
12. (Opsional) Men-deploy aplikasi
Sejauh ini aplikasi ini sepenuhnya lokal, semua data dimuat di Firebase Emulator Suite. Di bagian ini, Anda akan mempelajari cara mengonfigurasi project Firebase agar aplikasi ini berfungsi di produksi.
Firebase Authentication
Di Firebase console, buka bagian Authentication, lalu klik Get started. Buka tab Sign-in method dan pilih opsi Email/Password dari Native providers.
Aktifkan metode login Email/Sandi, lalu klik Simpan.
Firestore
Buat database
Buka bagian Firestore Database di konsol, lalu klik Create Database:
- Saat diminta tentang Aturan Keamanan, pilih untuk memulai dalam Mode Produksi, kami akan segera memperbarui aturan tersebut.
- Pilih lokasi database yang ingin Anda gunakan untuk aplikasi. Perhatikan bahwa memilih lokasi database adalah keputusan permanen dan untuk mengubahnya, Anda harus membuat project baru. Untuk informasi selengkapnya tentang memilih lokasi project, lihat dokumentasi.
Men-deploy Aturan
Untuk men-deploy Aturan Keamanan yang Anda tulis sebelumnya, jalankan perintah berikut di direktori codelab:
$ firebase deploy --only firestore:rules
Tindakan ini akan men-deploy konten firestore.rules ke project Anda, yang dapat Anda konfirmasi dengan membuka tab Rules di konsol.
Men-deploy Indeks
Aplikasi FriendlyEats memiliki pengurutan dan pemfilteran kompleks yang memerlukan sejumlah indeks gabungan kustom. Ini dapat dibuat secara manual di Firebase console, tetapi lebih mudah untuk menulis definisinya dalam file firestore.indexes.json dan men-deploynya menggunakan Firebase CLI.
Jika membuka file firestore.indexes.json, Anda akan melihat bahwa indeks yang diperlukan telah disediakan:
{
"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": []
}
Untuk men-deploy indeks ini, jalankan perintah berikut:
$ firebase deploy --only firestore:indexes
Perhatikan bahwa pembuatan indeks tidak instan, Anda dapat memantau progresnya di Firebase console.
Mengonfigurasi aplikasi
Dalam file util/FirestoreInitializer.kt dan util/AuthInitializer.kt, kami mengonfigurasi Firebase SDK untuk terhubung ke emulator saat dalam mode debug:
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
}
Jika ingin menguji aplikasi dengan project Firebase sungguhan, Anda dapat:
- Bangun aplikasi dalam mode rilis dan jalankan di perangkat.
- Ganti
BuildConfig.DEBUGdenganfalseuntuk sementara dan jalankan kembali aplikasi.
Perhatikan bahwa Anda mungkin perlu Logout dari aplikasi dan login lagi agar dapat terhubung dengan benar ke produksi.