import com.google.firebase.firestore.Query; //导入依赖的package包/类
private void detachListener() {
    // [START detach_listener]
    Query query = db.collection("cities");
    ListenerRegistration registration = query.addSnapshotListener(
            new EventListener<QuerySnapshot>() {
                // [START_EXCLUDE]
                @Override
                public void onEvent(@Nullable QuerySnapshot snapshots,
                                    @Nullable FirebaseFirestoreException e) {
                    // ...
                }
                // [END_EXCLUDE]
            });

    // ...

    // Stop listening to changes
    registration.remove();
    // [END detach_listener]
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
private void simpleQueries() {
    // [START simple_queries]
    // Create a reference to the cities collection
    CollectionReference citiesRef = db.collection("cities");

    // Create a query against the collection.
    Query query = citiesRef.whereEqualTo("state", "CA");
    // [END simple_queries]

    // [START simple_query_capital]
    Query capitalCities = db.collection("cities").whereEqualTo("capital", true);
    // [END simple_query_capital]

    // [START example_filters]
    citiesRef.whereEqualTo("state", "CA");
    citiesRef.whereLessThan("population", 100000);
    citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco");
    // [END example_filters]
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
private Query toQuery(final Filters filters) {
    // Construct query basic query
    Query query = firestore.collection("restaurants");

    if (filters == null) {
        query.orderBy("avgRating", Query.Direction.ASCENDING);
    } else {
        // Category (equality filter)
        if (filters.hasCategory()) {
            query = query.whereEqualTo(Restaurant.FIELD_CATEGORY, filters.getCategory());
        }

        // City (equality filter)
        if (filters.hasCity()) {
            query = query.whereEqualTo(Restaurant.FIELD_CITY, filters.getCity());
        }

        // Price (equality filter)
        if (filters.hasPrice()) {
            query = query.whereEqualTo(Restaurant.FIELD_PRICE, filters.getPrice());
        }

        // Sort by (orderBy with direction)
        if (filters.hasSortBy()) {
            query = query.orderBy(filters.getSortBy(), filters.getSortDirection());
        }
    }

    /* query could be limited like: query.limit(5) */
    return query;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
public static Filters getDefault() {
    Filters filters = new Filters();
    filters.setSortBy(Restaurant.FIELD_AVG_RATING);
    filters.setSortDirection(Query.Direction.DESCENDING);

    return filters;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
@Nullable
private Query.Direction getSortDirection() {
    String selected = (String) binding.spinnerSort.getSelectedItem();
    if (getString(R.string.sort_by_rating).equals(selected)) {
        return Query.Direction.DESCENDING;
    }
    if (getString(R.string.sort_by_price).equals(selected)) {
        return Query.Direction.ASCENDING;
    }
    if (getString(R.string.sort_by_popularity).equals(selected)) {
        return Query.Direction.DESCENDING;
    }

    return null;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Delete all documents in a collection. Uses an Executor to perform work on a background
 * thread. This does *not* automatically discover and delete subcollections.
 */
private static Task<Void> deleteCollection(final CollectionReference collection,
                                           final int batchSize,
                                           Executor executor) {

    // Perform the delete operation on the provided Executor, which allows us to use
    // simpler synchronous logic without blocking the main thread.
    return Tasks.call(executor, () -> {
        // Get the first batch of documents in the collection
        Query query = collection.orderBy("__name__").limit(batchSize);

        // Get a list of deleted documents
        List<DocumentSnapshot> deleted = deleteQueryBatch(query);

        // While the deleted documents in the last batch indicate that there
        // may still be more documents in the collection, page down to the
        // next batch and delete again
        while (deleted.size() >= batchSize) {
            // Move the query cursor to start after the last doc in the batch
            DocumentSnapshot last = deleted.get(deleted.size() - 1);
            query = collection.orderBy("__name__")
                    .startAfter(last.getId())
                    .limit(batchSize);

            deleted = deleteQueryBatch(query);
        }

        return null;
    });

}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Delete all results from a query in a single WriteBatch. Must be run on a worker thread
 * to avoid blocking/crashing the main thread.
 */
@WorkerThread
private static List<DocumentSnapshot> deleteQueryBatch(final Query query) throws Exception {
    QuerySnapshot querySnapshot = Tasks.await(query.get());

    WriteBatch batch = query.getFirestore().batch();
    for (DocumentSnapshot snapshot : querySnapshot) {
        batch.delete(snapshot.getReference());
    }
    Tasks.await(batch.commit());

    return querySnapshot.getDocuments();
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
private void initFirestore() {
    mFirestore = FirebaseFirestore.getInstance();
    // Get the 50 highest rated restaurants
    mQuery = mFirestore.collection("restaurants")
            .orderBy("avgRating", Query.Direction.DESCENDING)
            .limit(LIMIT);

    /**
     * Now we want to listen to the query,
     * so that we get all matching documents and are notified of future updates in real time.
     * Because our eventual goal is to bind this data to a RecyclerView,
     * we need to create a RecyclerView.Adapter class to listen to the data.
     */

}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
@Override
public void onFilter(Filters filters) {
    // Construct query 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);
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
public void setQuery(Query query) {
    // Stop listening
    stopListening();

    // Clear existinkodig data
    mSnapshots.clear();
    notifyDataSetChanged();

    // Listen to new query
    mQuery = query;
    startListening();
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
@Nullable
private Query.Direction getSortDirection() {
    String selected = (String) mSortSpinner.getSelectedItem();
    if (getString(R.string.sort_by_rating).equals(selected)) {
        return Query.Direction.DESCENDING;
    } if (getString(R.string.sort_by_price).equals(selected)) {
        return Query.Direction.ASCENDING;
    } if (getString(R.string.sort_by_popularity).equals(selected)) {
        return Query.Direction.DESCENDING;
    }

    return null;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Delete all results from a query in a single WriteBatch. Must be run on a worker thread
 * to avoid blocking/crashing the main thread.
 */
@WorkerThread
private List<DocumentSnapshot> deleteQueryBatch(final Query query) throws Exception {
    QuerySnapshot querySnapshot = Tasks.await(query.get());

    WriteBatch batch = query.getFirestore().batch();
    for (DocumentSnapshot snapshot : querySnapshot) {
        batch.delete(snapshot.getReference());
    }
    Tasks.await(batch.commit());

    return querySnapshot.getDocuments();
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Delete all documents in a collection. Uses an Executor to perform work on a background
 * thread. This does *not* automatically discover and delete subcollections.
 */
private Task<Void> deleteCollection(final CollectionReference collection,
                                    final int batchSize,
                                    Executor executor) {

    // Perform the delete operation on the provided Executor, which allows us to use
    // simpler synchronous logic without blocking the main thread.
    return Tasks.call(executor, new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            // Get the first batch of documents in the collection
            Query query = collection.orderBy(FieldPath.documentId()).limit(batchSize);

            // Get a list of deleted documents
            List<DocumentSnapshot> deleted = deleteQueryBatch(query);

            // While the deleted documents in the last batch indicate that there
            // may still be more documents in the collection, page down to the
            // next batch and delete again
            while (deleted.size() >= batchSize) {
                // Move the query cursor to start after the last doc in the batch
                DocumentSnapshot last = deleted.get(deleted.size() - 1);
                query = collection.orderBy(FieldPath.documentId())
                        .startAfter(last.getId())
                        .limit(batchSize);

                deleted = deleteQueryBatch(query);
            }

            return null;
        }
    });

}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
@Override
public void onFilter(Filters filters) {
    // Construct query basic query
    Query query = mFirestore.collection("restaurants");

    // Category (equality filter)
    if (filters.hasCategory()) {
        query = query.whereEqualTo(Restaurant.FIELD_CATEGORY, filters.getCategory());
    }

    // City (equality filter)
    if (filters.hasCity()) {
        query = query.whereEqualTo(Restaurant.FIELD_CITY, filters.getCity());
    }

    // Price (equality filter)
    if (filters.hasPrice()) {
        query = query.whereEqualTo(Restaurant.FIELD_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
    mAdapter.setQuery(query);

    // Set header
    mCurrentSearchView.setText(Html.fromHtml(filters.getSearchDescription(this)));
    mCurrentSortByView.setText(filters.getOrderDescription(this));

    // Save filters
    mViewModel.setFilters(filters);
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
public void setQuery(Query query) {
    // Stop listening
    stopListening();

    // Clear existing data
    mSnapshots.clear();
    notifyDataSetChanged();

    // Listen to new query
    mQuery = query;
    startListening();
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Delete all documents in a collection. Uses an Executor to perform work on a background
 * thread. This does *not* automatically discover and delete subcollections.
 */
private static Task<Void> deleteCollection(final CollectionReference collection,
                                           final int batchSize,
                                           Executor executor) {

    // Perform the delete operation on the provided Executor, which allows us to use
    // simpler synchronous logic without blocking the main thread.
    return Tasks.call(executor, new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            // Get the first batch of documents in the collection
            Query query = collection.orderBy("__name__").limit(batchSize);

            // Get a list of deleted documents
            List<DocumentSnapshot> deleted = deleteQueryBatch(query);

            // While the deleted documents in the last batch indicate that there
            // may still be more documents in the collection, page down to the
            // next batch and delete again
            while (deleted.size() >= batchSize) {
                // Move the query cursor to start after the last doc in the batch
                DocumentSnapshot last = deleted.get(deleted.size() - 1);
                query = collection.orderBy("__name__")
                        .startAfter(last.getId())
                        .limit(batchSize);

                deleted = deleteQueryBatch(query);
            }

            return null;
        }
    });

}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Creates a new FirebaseSpinnerAdapter with the given options and dropdown layout.
 *
 * @param query The location to monitor for data changes
 * @param layout The layout to inflate for the normally displayed view
 * @param dropdownLayout The layout to inflate for the spinner dropdown menu
 */
@SuppressWarnings("WeakerAccess")
public FirestoreSpinnerAdapter(@NonNull Query query, Class<T> modelClass, @LayoutRes int layout,
                               @LayoutRes int dropdownLayout) {
    super();
    mSnapshots = new FirestoreArray<>(query, new ClassSnapshotParser<>(modelClass));
    mLayout = layout;
    mDropdownLayout = dropdownLayout;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * @param options options for the query listen.
 * @see #FirestoreArray(Query, SnapshotParser)
 */
public FirestoreArray(@NonNull Query query,
                      @NonNull QueryListenOptions options,
                      @NonNull SnapshotParser<T> parser) {
    super(parser);
    mQuery = query;
    mOptions = options;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
/**
 * Set the query to use (with options) and provide a custom {@link SnapshotParser}.
 * <p>
 * Do not call this method after calling {@link #setSnapshotArray(ObservableSnapshotArray)}.
 */
@NonNull
public Builder<T> setQuery(@NonNull Query query,
                           @NonNull QueryListenOptions options,
                           @NonNull SnapshotParser<T> parser) {
    assertNull(mSnapshots, ERR_SNAPSHOTS_SET);

    mSnapshots = new FirestoreArray<>(query, options, parser);
    return this;
}
 

import com.google.firebase.firestore.Query; //导入依赖的package包/类
private Query query(final String id) {
    return restaurants.document(id)
            .collection("ratings")
            .orderBy("timestamp", Query.Direction.DESCENDING)
            .limit(50);
}