1. Genel Bakış
Hedefler
Bu kod laboratuvarında, Android'de Cloud Firestore tarafından desteklenen bir restoran tavsiye uygulaması oluşturacaksınız. Şunları nasıl yapacağınızı öğreneceksiniz:
- Bir Android uygulamasından Firestore'a veri okuma ve yazma
- Firestore verilerindeki değişiklikleri gerçek zamanlı olarak dinleyin
- Firestore verilerinin güvenliğini sağlamak için Firebase Kimlik Doğrulaması ve güvenlik kurallarını kullanın
- Karmaşık Firestore sorguları yazın
Önkoşullar
Bu kod laboratuvarına başlamadan önce şunlara sahip olduğunuzdan emin olun:
- Android Studio 4.0 veya üstü
- API 19 veya üzeri bir Android öykünücüsü
- Node.js sürüm 10 veya üzeri
- Java sürüm 8 veya üzeri
2. Bir Firebase projesi oluşturun
- Google hesabınızla Firebase konsolunda oturum açın.
- Firebase konsolunda Proje ekle'yi tıklayın.
- Aşağıdaki ekran görüntüsünde gösterildiği gibi, Firebase projeniz için bir ad girin (örneğin, "Dostluk Yemekleri") ve Devam'ı tıklayın.
- Google Analytics'i etkinleştirmeniz istenebilir, bu codelab'in amaçları doğrultusunda seçiminiz önemli değildir.
- Bir dakika kadar sonra Firebase projeniz hazır olacak. Devam'ı tıklayın.
3. Örnek projeyi kurun
Kodu indirin
Bu codelab için örnek kodu klonlamak için aşağıdaki komutu çalıştırın. Bu, makinenizde friendlyeats-android
adlı bir klasör oluşturacaktır:
$ git clone https://github.com/firebase/friendlyeats-android
Makinenizde git yoksa, kodu doğrudan GitHub'dan da indirebilirsiniz.
Firebase yapılandırması ekle
- Firebase konsolunda , sol gezinme bölümünde Projeye Genel Bakış'ı seçin. Platformu seçmek için Android düğmesine tıklayın. Bir paket adı istendiğinde
com.google.firebase.example.fireeats
kullanın
- Uygulamayı Kaydet'e tıklayın ve
google-services.json
dosyasını indirmek için talimatları izleyin ve az önce indirdiğiniz kodunapp/
klasörüne taşıyın. Ardından İleri'yi tıklayın.
Projeyi içe aktar
Android Studio'yu açın. Dosya > Yeni > Projeyi İçe Aktar'a tıklayın ve friendlyeats-android klasörünü seçin.
4. Firebase Emülatörlerini kurun
Bu kod laboratuvarında, Cloud Firestore ve diğer Firebase hizmetlerini yerel olarak taklit etmek için Firebase Emulator Suite'i kullanacaksınız. Bu, uygulamanızı oluşturmak için güvenli, hızlı ve ücretsiz bir yerel geliştirme ortamı sağlar.
Firebase CLI'yi yükleyin
İlk önce Firebase CLI'yi yüklemeniz gerekecek. macOS veya Linux kullanıyorsanız aşağıdaki cURL komutunu çalıştırabilirsiniz:
curl -sL https://firebase.tools | bash
Windows kullanıyorsanız, bağımsız bir ikili dosya almak veya npm
aracılığıyla yüklemek için kurulum talimatlarını okuyun.
CLI'yi yükledikten sonra, firebase --version
çalıştırıldığında 9.0.0
veya daha yüksek bir sürüm bildirilmelidir:
$ firebase --version 9.0.0
Giriş yapmak
CLI'yi Google hesabınıza bağlamak için firebase login
çalıştırın. Bu, oturum açma işlemini tamamlamak için yeni bir tarayıcı penceresi açacaktır. Daha önce Firebase projenizi oluştururken kullandığınız hesabı seçtiğinizden emin olun.
Projenizi bağlayın
Yerel projenizi Firebase projenize bağlamak için friendlyeats-android
klasörünün firebase use --add
çalıştırın. Daha önce oluşturduğunuz projeyi seçmek için komutları izleyin ve bir takma ad seçmeniz istenirse default
girin.
5. Uygulamayı çalıştırın
Şimdi Firebase Emulator Suite ve FriendlyEats Android uygulamasını ilk kez çalıştırma zamanı.
Emülatörleri çalıştırın
Terminalinizde, friendeats friendlyeats-android
dizini firebase emulators:start
başlayın. Günlükleri şöyle görmelisiniz:
$ 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.
Artık makinenizde çalışan eksiksiz bir yerel geliştirme ortamınız var! Codelab'ın geri kalanı için bu komutu çalışır durumda bıraktığınızdan emin olun, Android uygulamanızın öykünücülere bağlanması gerekir.
Uygulamayı Emülatörlere bağlayın
FirebaseUtil.java
dosyasını Android Studio'da açın. Bu dosya, Firebase SDK'larını makinenizde çalışan yerel öykünücülere bağlama mantığını içerir.
Dosyanın üst kısmında şu satırı inceleyin:
/** Use emulators only in debug builds **/
private static final boolean sUseEmulators = BuildConfig.DEBUG;
Yalnızca uygulamamız debug
modunda çalışırken öykünücülere bağlandığımızdan emin olmak için BuildConfig
kullanıyoruz. Uygulamayı release
modunda derlediğimizde bu koşul yanlış olacaktır.
Şimdi getFirestore()
yöntemine bir göz atın:
public static FirebaseFirestore getFirestore() {
if (FIRESTORE == null) {
FIRESTORE = FirebaseFirestore.getInstance();
// Connect to the Cloud Firestore emulator when appropriate. The host '10.0.2.2' is a
// special IP address to let the Android emulator connect to 'localhost'.
if (sUseEmulators) {
FIRESTORE.useEmulator("10.0.2.2", 8080);
}
}
return FIRESTORE;
}
Firebase SDK'yı yerel Firestore öykünücüsüne bağlamak için useEmulator(host, port)
yöntemini kullandığını görebiliriz. Uygulama boyunca, bu FirebaseFirestore
örneğine erişmek için FirebaseUtil.getFirestore()
'u kullanacağız, böylece debug
modunda çalışırken her zaman Firestore öykünücüsüne bağlandığımızdan eminiz.
Uygulamayı çalıştırın
google-services.json
dosyasını düzgün bir şekilde eklediyseniz, proje şimdi derlenmelidir. Android Studio'da Oluştur > Projeyi Yeniden Oluştur'a tıklayın ve kalan hata olmadığından emin olun.
Android Studio'da Uygulamayı Android öykünücünüzde çalıştırın . İlk başta bir "Giriş" ekranı ile karşılaşacaksınız. Uygulamaya giriş yapmak için herhangi bir e-posta ve şifreyi kullanabilirsiniz. Bu oturum açma işlemi, Firebase Kimlik Doğrulama öykünücüsüne bağlanıyor, bu nedenle gerçek kimlik bilgileri iletilmiyor.
Şimdi web tarayıcınızda http://localhost:4000'e giderek Emülatörler Arayüzünü açın. Ardından Kimlik Doğrulama sekmesine tıklayın ve az önce oluşturduğunuz hesabı görmelisiniz:
Oturum açma işlemini tamamladıktan sonra uygulama ana ekranını görmelisiniz:
Yakında ana ekranı doldurmak için bazı veriler ekleyeceğiz.
6. Firestore'a veri yazın
Bu bölümde, şu anda boş olan ana ekranı doldurabilmemiz için Firestore'a bazı veriler yazacağız.
Uygulamamızdaki ana model nesnesi bir restorandır (bkz. model/Restaurant.java
). Firestore verileri belgelere, koleksiyonlara ve alt koleksiyonlara bölünür. Her restoranı bir belge olarak "restaurants"
adı verilen üst düzey bir koleksiyonda saklayacağız. Firestore veri modeli hakkında daha fazla bilgi edinmek için belgelerdeki belgeler ve koleksiyonlar hakkında bilgi edinin.
Gösteri amacıyla, taşma menüsünde "Rastgele Öğeler Ekle" düğmesini tıkladığımızda on rastgele restoran oluşturmak için uygulamaya işlevsellik ekleyeceğiz. MainActivity.java
dosyasını açın ve onAddItemsClicked()
yöntemindeki içeriği şununla değiştirin:
private void onAddItemsClicked() {
// Get a reference to the restaurants collection
CollectionReference restaurants = mFirestore.collection("restaurants");
for (int i = 0; i < 10; i++) {
// Get a random Restaurant POJO
Restaurant restaurant = RestaurantUtil.getRandom(this);
// Add a new document to the restaurants collection
restaurants.add(restaurant);
}
}
Yukarıdaki kod hakkında dikkat edilmesi gereken birkaç önemli nokta vardır:
-
"restaurants"
koleksiyonuna bir referans alarak başladık. Koleksiyonlar, belgeler eklendiğinde örtük olarak oluşturulur, bu nedenle veri yazmadan önce koleksiyonu oluşturmaya gerek yoktur. - Belgeler, her Restoran belgesini oluşturmak için kullandığımız POJO'lar (Plain Old Java Object) kullanılarak oluşturulabilir.
-
add()
yöntemi, otomatik olarak oluşturulan bir kimliğe sahip bir koleksiyona bir belge ekler, bu nedenle her Restoran için benzersiz bir kimlik belirtmemiz gerekmedi.
Şimdi uygulamayı tekrar çalıştırın ve az önce yazdığınız kodu çağırmak için taşma menüsünde (sağ üst köşede) "Rastgele Öğeler Ekle" düğmesini tıklayın:
Şimdi web tarayıcınızda http://localhost:4000'e giderek Emülatörler Arayüzünü açın. Ardından Firestore sekmesine tıklayın ve az önce eklediğiniz verileri görmelisiniz:
Bu veriler makineniz için %100 yereldir. Aslında, gerçek projeniz henüz bir Firestore veritabanı bile içermiyor! Bu, bu verileri sonuçsuz bir şekilde değiştirmeyi ve silmeyi denemenin güvenli olduğu anlamına gelir.
Tebrikler, Firestore'a az önce veri yazdınız! Bir sonraki adımda, bu verilerin uygulamada nasıl görüntüleneceğini öğreneceğiz.
7. Firestore'dan verileri görüntüleyin
Bu adımda, Firestore'dan nasıl veri alınacağını ve uygulamamızda nasıl görüntüleneceğini öğreneceğiz. Firestore'dan veri okumanın ilk adımı bir Query
oluşturmaktır. MainActivity.java
dosyasını açın ve onCreate()
yönteminin başına aşağıdaki kodu ekleyin:
mFirestore = FirebaseUtil.getFirestore();
// Get the 50 highest rated restaurants
mQuery = mFirestore.collection("restaurants")
.orderBy("avgRating", Query.Direction.DESCENDING)
.limit(LIMIT);
Şimdi, eşleşen tüm belgeleri almak ve gelecekteki güncellemelerden gerçek zamanlı olarak haberdar olmak için sorguyu dinlemek istiyoruz. Nihai hedefimiz bu verileri bir RecyclerView
bağlamak olduğundan, verileri dinlemek için bir RecyclerView.Adapter
sınıfı oluşturmamız gerekir.
Kısmen uygulanmış olan FirestoreAdapter
sınıfını açın. İlk olarak, bağdaştırıcının EventListener
uygulamasını sağlayalım ve bir Firestore sorgusunda güncellemeleri alabilmesi için onEvent
işlevini tanımlayalım:
public abstract class FirestoreAdapter<VH extends RecyclerView.ViewHolder>
extends RecyclerView.Adapter<VH>
implements EventListener<QuerySnapshot> { // Add this "implements"
// ...
// Add this method
@Override
public void onEvent(QuerySnapshot documentSnapshots,
FirebaseFirestoreException e) {
// Handle errors
if (e != null) {
Log.w(TAG, "onEvent:error", e);
return;
}
// Dispatch the event
for (DocumentChange change : documentSnapshots.getDocumentChanges()) {
// Snapshot of the changed document
DocumentSnapshot snapshot = change.getDocument();
switch (change.getType()) {
case ADDED:
// TODO: handle document added
break;
case MODIFIED:
// TODO: handle document modified
break;
case REMOVED:
// TODO: handle document removed
break;
}
}
onDataChanged();
}
// ...
}
İlk yüklemede dinleyici, her yeni belge için bir ADDED
olayı alacaktır. Sorgunun sonuç kümesi zamanla değiştikçe, dinleyici, değişiklikleri içeren daha fazla olay alacaktır. Şimdi dinleyiciyi uygulamayı bitirelim. Önce üç yeni yöntem ekleyin: onDocumentAdded
, onDocumentModified
ve onDocumentRemoved
:
protected void onDocumentAdded(DocumentChange change) {
mSnapshots.add(change.getNewIndex(), change.getDocument());
notifyItemInserted(change.getNewIndex());
}
protected void onDocumentModified(DocumentChange change) {
if (change.getOldIndex() == change.getNewIndex()) {
// Item changed but remained in same position
mSnapshots.set(change.getOldIndex(), change.getDocument());
notifyItemChanged(change.getOldIndex());
} else {
// Item changed and changed position
mSnapshots.remove(change.getOldIndex());
mSnapshots.add(change.getNewIndex(), change.getDocument());
notifyItemMoved(change.getOldIndex(), change.getNewIndex());
}
}
protected void onDocumentRemoved(DocumentChange change) {
mSnapshots.remove(change.getOldIndex());
notifyItemRemoved(change.getOldIndex());
}
Ardından onEvent
şu yeni yöntemleri çağırın:
@Override
public void onEvent(QuerySnapshot documentSnapshots,
FirebaseFirestoreException e) {
// ...
// Dispatch the event
for (DocumentChange change : documentSnapshots.getDocumentChanges()) {
// Snapshot of the changed document
DocumentSnapshot snapshot = change.getDocument();
switch (change.getType()) {
case ADDED:
onDocumentAdded(change); // Add this line
break;
case MODIFIED:
onDocumentModified(change); // Add this line
break;
case REMOVED:
onDocumentRemoved(change); // Add this line
break;
}
}
onDataChanged();
}
Son olarak, dinleyiciyi eklemek için startListening()
yöntemini uygulayın:
public void startListening() {
if (mQuery != null && mRegistration == null) {
mRegistration = mQuery.addSnapshotListener(this);
}
}
Artık uygulama, Firestore'dan veri okumak için tamamen yapılandırılmıştır. Uygulamayı tekrar çalıştırın ve önceki adımda eklediğiniz restoranları görmelisiniz:
Şimdi tarayıcınızdaki Emulator kullanıcı arayüzüne geri dönün ve restoran adlarından birini düzenleyin. Uygulamada neredeyse anında değiştiğini görmelisiniz!
8. Verileri sıralayın ve filtreleyin
Uygulama şu anda tüm koleksiyondaki en yüksek puanlı restoranları gösteriyor, ancak gerçek bir restoran uygulamasında kullanıcı verileri sıralamak ve filtrelemek isteyecektir. Örneğin, uygulama "Philadelphia'daki en iyi deniz ürünleri restoranları" veya "En ucuz pizza"yı gösterebilmelidir.
Uygulamanın üst kısmındaki beyaz çubuğa tıklamak, bir filtreler iletişim kutusu açar. Bu bölümde, bu iletişim kutusunun çalışması için Firestore sorgularını kullanacağız:
onFilter()
yöntemini MainActivity.java
. Bu yöntem, filtreler iletişim kutusunun çıktısını yakalamak için oluşturduğumuz bir yardımcı nesne olan Filters
nesnesini kabul eder. Filtrelerden bir sorgu oluşturmak için bu yöntemi değiştireceğiz:
@Override
public void onFilter(Filters filters) {
// Construct basic query
Query query = mFirestore.collection("restaurants");
// Category (equality filter)
if (filters.hasCategory()) {
query = query.whereEqualTo("category", filters.getCategory());
}
// City (equality filter)
if (filters.hasCity()) {
query = query.whereEqualTo("city", filters.getCity());
}
// Price (equality filter)
if (filters.hasPrice()) {
query = query.whereEqualTo("price", filters.getPrice());
}
// Sort by (orderBy with direction)
if (filters.hasSortBy()) {
query = query.orderBy(filters.getSortBy(), filters.getSortDirection());
}
// Limit items
query = query.limit(LIMIT);
// Update the query
mQuery = query;
mAdapter.setQuery(query);
// Set header
mCurrentSearchView.setText(Html.fromHtml(filters.getSearchDescription(this)));
mCurrentSortByView.setText(filters.getOrderDescription(this));
// Save filters
mViewModel.setFilters(filters);
}
Yukarıdaki snippet'te, verilen filtrelerle eşleşmesi için where
ve orderBy
yan tümcelerini ekleyerek bir Query
nesnesi oluşturuyoruz.
Uygulamayı tekrar çalıştırın ve en popüler düşük fiyatlı restoranları göstermek için aşağıdaki filtreyi seçin:
Artık yalnızca düşük fiyatlı seçenekler içeren filtrelenmiş bir restoran listesi görmelisiniz:
Buraya kadar geldiyseniz, artık Firestore'da tam işlevli bir restoran tavsiyesi görüntüleme uygulaması oluşturmuşsunuzdur! Artık restoranları gerçek zamanlı olarak sıralayabilir ve filtreleyebilirsiniz. Sonraki birkaç bölümde restoranlara incelemeler ekleyeceğiz ve uygulamaya güvenlik kuralları ekleyeceğiz.
9. Verileri alt koleksiyonlarda düzenleyin
Bu bölümde, kullanıcıların favori (veya en az favori) restoranlarını gözden geçirebilmeleri için uygulamaya derecelendirmeler ekleyeceğiz.
Koleksiyonlar ve alt koleksiyonlar
Şimdiye kadar tüm restoran verilerini "restoranlar" adı verilen üst düzey bir koleksiyonda sakladık. Bir kullanıcı bir restoranı derecelendirdiğinde, restoranlara yeni bir Rating
nesnesi eklemek istiyoruz. Bu görev için bir alt koleksiyon kullanacağız. Bir alt koleksiyonu, bir belgeye eklenmiş bir koleksiyon olarak düşünebilirsiniz. Böylece her restoran belgesi, derecelendirme belgeleriyle dolu bir derecelendirme alt koleksiyonuna sahip olacaktır. Alt koleksiyonlar, belgelerimizi şişirmeden veya karmaşık sorgular gerektirmeden verileri düzenlemeye yardımcı olur.
Bir alt koleksiyona erişmek için ana belgede .collection()
çağırın:
CollectionReference subRef = mFirestore.collection("restaurants")
.document("abc123")
.collection("ratings");
Bir üst düzey koleksiyonda olduğu gibi bir alt koleksiyona erişebilir ve sorgulayabilirsiniz, boyut sınırlaması veya performans değişikliği yoktur. Firestore veri modeli hakkında daha fazla bilgiyi buradan edinebilirsiniz .
Bir işlemde veri yazma
Uygun alt koleksiyona bir Rating
eklemek yalnızca .add()
çağrılmasını gerektirir, ancak yeni verileri yansıtmak için Restaurant
nesnesinin ortalama derecelendirmesini ve derecelendirme sayısını da güncellememiz gerekir. Bu iki değişikliği yapmak için ayrı işlemler kullanırsak, eski veya yanlış verilerle sonuçlanabilecek bir dizi yarış koşulu vardır.
Puanların doğru şekilde eklendiğinden emin olmak için bir restorana puan eklemek için bir işlem kullanacağız. Bu işlem birkaç işlem gerçekleştirecektir:
- Restoranın mevcut puanını okuyun ve yenisini hesaplayın
- Derecelendirmeyi alt koleksiyona ekleyin
- Restoranın ortalama puanını ve puan sayısını güncelleyin
RestaurantDetailActivity.java
açın ve addRating
işlevini uygulayın:
private Task<Void> addRating(final DocumentReference restaurantRef,
final Rating rating) {
// Create reference for new rating, for use inside the transaction
final DocumentReference ratingRef = restaurantRef.collection("ratings")
.document();
// In a transaction, add the new rating and update the aggregate totals
return mFirestore.runTransaction(new Transaction.Function<Void>() {
@Override
public Void apply(Transaction transaction)
throws FirebaseFirestoreException {
Restaurant restaurant = transaction.get(restaurantRef)
.toObject(Restaurant.class);
// Compute new number of ratings
int newNumRatings = restaurant.getNumRatings() + 1;
// Compute new average rating
double oldRatingTotal = restaurant.getAvgRating() *
restaurant.getNumRatings();
double newAvgRating = (oldRatingTotal + rating.getRating()) /
newNumRatings;
// Set new restaurant info
restaurant.setNumRatings(newNumRatings);
restaurant.setAvgRating(newAvgRating);
// Commit to Firestore
transaction.set(restaurantRef, restaurant);
transaction.set(ratingRef, rating);
return null;
}
});
}
addRating()
işlevi, tüm işlemi temsil eden bir Task
döndürür. onRating()
işlevinde, işlemin sonucuna yanıt vermek için göreve dinleyiciler eklenir.
Şimdi uygulamayı tekrar çalıştırın ve restoran detay ekranını açması gereken restoranlardan birine tıklayın. Bir inceleme eklemeye başlamak için + düğmesini tıklayın. Birkaç yıldız seçip bir metin girerek bir inceleme ekleyin.
Gönder'e basmak işlemi başlatır. İşlem tamamlandığında, yorumunuzun aşağıda görüntülendiğini ve restoranın yorum sayısında bir güncelleme göreceksiniz:
Tebrikler! Artık Cloud Firestore üzerine kurulu sosyal, yerel, mobil bir restoran inceleme uygulamanız var. Bu aralar çok popüler olduğunu duydum.
10. Verilerinizi güvence altına alın
Şimdiye kadar bu uygulamanın güvenliğini dikkate almadık. Kullanıcıların yalnızca kendi doğru verilerini okuyup yazabildiklerini nereden biliyoruz? Firestore veritabanlarının güvenliği, Güvenlik Kuralları adlı bir yapılandırma dosyasıyla sağlanır.
firestore.rules
dosyasını açın, aşağıdakileri görmelisiniz:
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;
}
}
}
İstenmeyen veri erişimlerini veya değişikliklerini önlemek için bu kuralları değiştirelim, firestore.rules
dosyasını açıp içeriği aşağıdaki ile değiştirelim:
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;
}
}
}
}
Bu kurallar, istemcilerin yalnızca güvenli değişiklikler yapmasını sağlamak için erişimi kısıtlar. Örneğin, bir restoran belgesindeki güncellemeler, adı veya diğer değişmez verileri değil, yalnızca derecelendirmeleri değiştirebilir. Derecelendirmeler, yalnızca kullanıcı kimliği, oturum açmış olan kullanıcıyla eşleşirse oluşturulabilir, bu da sahtekarlığı önler.
Güvenlik Kuralları hakkında daha fazla bilgi edinmek için belgeleri ziyaret edin.
11. Sonuç
Artık Firestore'un üzerinde tam özellikli bir uygulama oluşturdunuz. Aşağıdakiler dahil en önemli Firestore özelliklerini öğrendiniz:
- Belgeler ve koleksiyonlar
- Veri okuma ve yazma
- Sorgularla sıralama ve filtreleme
- alt koleksiyonlar
- işlemler
Daha fazla bilgi edin
Firestore hakkında bilgi edinmeye devam etmek için, başlamak için bazı iyi yerler şunlardır:
Bu codelab'deki restoran uygulaması, "Friendly Eats" örnek uygulamasını temel almıştır. Bu uygulamanın kaynak koduna buradan göz atabilirsiniz.
İsteğe bağlı: Üretime dağıtın
Şimdiye kadar bu uygulama yalnızca Firebase Emulator Suite'i kullandı. Bu uygulamayı gerçek bir Firebase projesine nasıl dağıtacağınızı öğrenmek istiyorsanız bir sonraki adıma geçin.
12. (İsteğe bağlı) Uygulamanızı dağıtın
Şimdiye kadar bu uygulama tamamen yereldi, tüm veriler Firebase Emulator Suite'te bulunuyor. Bu bölümde, bu uygulamanın üretimde çalışması için Firebase projenizi nasıl yapılandıracağınızı öğreneceksiniz.
Firebase Kimlik Doğrulaması
Firebase konsolunda Kimlik Doğrulama bölümüne gidin ve Başlayın 'ı tıklayın. Oturum açma yöntemi sekmesine gidin ve Yerel sağlayıcılardan E-posta/Parola seçeneğini belirleyin.
E- posta/Parola oturum açma yöntemini etkinleştirin ve Kaydet'i tıklayın .
itfaiye
Veritabanı yarat
Konsolun Firestore Veritabanı bölümüne gidin ve Veritabanı Oluştur'a tıklayın:
- Güvenlik Kuralları'nın Üretim Modunda başlamayı seçmesi istendiğinde, bu kuralları yakında güncelleyeceğiz.
- Uygulamanız için kullanmak istediğiniz veritabanı konumunu seçin. Bir veritabanı konumu seçmenin kalıcı bir karar olduğunu ve bunu değiştirmek için yeni bir proje oluşturmanız gerekeceğini unutmayın. Bir proje konumu seçme hakkında daha fazla bilgi için belgelere bakın.
Dağıtım Kuralları
Daha önce yazdığınız Güvenlik Kurallarını dağıtmak için codelab dizininde aşağıdaki komutu çalıştırın:
$ firebase deploy --only firestore:rules
Bu, konsoldaki Kurallar sekmesine giderek onaylayabileceğiniz firestore.rules
içeriğini projenize dağıtacaktır.
Dizinleri Dağıt
FriendlyEats uygulaması, bir dizi özel bileşik dizin gerektiren karmaşık sıralama ve filtrelemeye sahiptir. Bunlar Firebase konsolunda elle oluşturulabilir, ancak tanımlarını firestore.indexes.json
dosyasına yazmak ve Firebase CLI'yi kullanarak dağıtmak daha kolaydır.
firestore.indexes.json
dosyasını açarsanız, gerekli dizinlerin zaten sağlandığını göreceksiniz:
{
"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": []
}
Bu dizinleri dağıtmak için aşağıdaki komutu çalıştırın:
$ firebase deploy --only firestore:indexes
Dizin oluşturmanın anlık olmadığını unutmayın, ilerlemeyi Firebase konsolunda izleyebilirsiniz.
Uygulamayı yapılandır
FirebaseUtil
sınıfında, hata ayıklama modundayken öykünücülere bağlanmak için Firebase SDK'sını yapılandırdık:
public class FirebaseUtil {
/** Use emulators only in debug builds **/
private static final boolean sUseEmulators = BuildConfig.DEBUG;
// ...
}
Uygulamanızı gerçek Firebase projenizle test etmek isterseniz, şunları yapabilirsiniz:
- Uygulamayı yayın modunda oluşturun ve bir cihazda çalıştırın.
-
sUseEmulators
geçici olarakfalse
olarak değiştirin ve uygulamayı yeniden çalıştırın.
Üretime doğru şekilde bağlanmak için uygulamadan Çıkış yapmanız ve tekrar oturum açmanız gerekebileceğini unutmayın.