upload feature implementation

Firestore/Source/API/FIRDocumentReference.mm

@@ -20,6 +20,7 @@
 #include <utility>
 
 #import "FIRFirestoreErrors.h"
+#import "Firestore/Source/API/converters.h"
 #import "Firestore/Source/API/FIRCollectionReference+Internal.h"
 #import "Firestore/Source/API/FIRDocumentReference+Internal.h"
 #import "Firestore/Source/API/FIRDocumentSnapshot+Internal.h"
@@ -50,6 +51,7 @@
 using firebase::firestore::api::DocumentSnapshotListener;
 using firebase::firestore::api::Firestore;
 using firebase::firestore::api::ListenerRegistration;
+using firebase::firestore::api::MakeListenSource;
 using firebase::firestore::api::MakeSource;
 using firebase::firestore::api::Source;
 using firebase::firestore::core::EventListener;
@@ -214,8 +216,8 @@ - (void)getDocumentWithSource:(FIRFirestoreSource)source
 
 - (id<FIRListenerRegistration>)addSnapshotListenerWithOptions:(FIRSnapshotListenOptions *)options
                                                      listener:(FIRDocumentSnapshotBlock)listener {
-  // Mila
-  ListenOptions listenOptions = ListenOptions::FromIncludeMetadataChanges(false);
+    ListenOptions listenOptions =
+      ListenOptions::FromOptions(options.includeMetadataChanges, MakeListenSource(options.source));
   return [self addSnapshotListenerInternalWithOptions:listenOptions listener:listener];
 }
 

Firestore/Source/API/FIRQuery.mm

@@ -23,6 +23,7 @@
 #import "FIRDocumentReference.h"
 #import "FIRFirestoreErrors.h"
 
+#import "Firestore/Source/API/converters.h"
 #import "Firestore/Source/API/FIRAggregateField+Internal.h"
 #import "Firestore/Source/API/FIRAggregateQuery+Internal.h"
 #import "Firestore/Source/API/FIRDocumentReference+Internal.h"
@@ -69,6 +70,7 @@
 using firebase::firestore::google_firestore_v1_Value;
 using firebase::firestore::google_firestore_v1_Value_fields;
 using firebase::firestore::api::Firestore;
+using firebase::firestore::api::MakeListenSource;
 using firebase::firestore::api::Query;
 using firebase::firestore::api::QueryListenerRegistration;
 using firebase::firestore::api::QuerySnapshot;
@@ -193,7 +195,8 @@ - (void)getDocumentsWithSource:(FIRFirestoreSource)publicSource
 
 - (id<FIRListenerRegistration>)addSnapshotListenerWithOptions:(FIRSnapshotListenOptions *)options
                                                      listener:(FIRQuerySnapshotBlock)listener {
-  auto listenOptions = ListenOptions::FromIncludeMetadataChanges(false);
+  ListenOptions listenOptions =
+      ListenOptions::FromOptions(options.includeMetadataChanges, MakeListenSource(options.source));
   return [self addSnapshotListenerInternalWithOptions:listenOptions listener:listener];
 }
 

Firestore/Source/API/converters.h

@@ -24,6 +24,8 @@
 #import <Foundation/Foundation.h>
 
 #include <memory>
+#import "FIRSnapshotListenOptions.h"
+#import "Firestore/core/src/api/listen_source.h"
 
 @class FIRGeoPoint;
 @class FIRTimestamp;
@@ -62,6 +64,8 @@ FIRTimestamp* MakeFIRTimestamp(const Timestamp& timestamp);
 FIRDocumentReference* MakeFIRDocumentReference(const model::DocumentKey& document_key,
                                                std::shared_ptr<Firestore> firestore);
 
+ListenSource MakeListenSource(const FIRListenSource& source);
+
 }  // namespace api
 }  // namespace firestore
 }  // namespace firebase

Firestore/Source/API/converters.mm

@@ -25,6 +25,7 @@
 #include "Firestore/core/include/firebase/firestore/geo_point.h"
 #include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/api/firestore.h"
+#import "Firestore/core/src/api/listen_source.h"
 #include "Firestore/core/src/model/document_key.h"
 
 NS_ASSUME_NONNULL_BEGIN
@@ -61,6 +62,17 @@ Timestamp MakeTimestamp(NSDate* date) {
   return [[FIRDocumentReference alloc] initWithKey:key firestore:std::move(firestore)];
 }
 
+ListenSource MakeListenSource( const FIRListenSource& source) {
+  switch (source) {
+    case FIRListenSourceDefault:
+      return ListenSource::Default;
+    case FIRListenSourceCache:
+      return ListenSource::Cache;
+    default:
+      return ListenSource::Default;
+  }
+}
+
 }  // namespace api
 }  // namespace firestore
 }  // namespace firebase

Firestore/Source/Public/FirebaseFirestore/FIRDocumentReference.h

@@ -281,12 +281,11 @@ addSnapshotListenerWithIncludeMetadataChanges:(BOOL)includeMetadataChanges
  *
  * @return A `ListenerRegistration` that can be used to remove this listener.
  */
-// clang-format off
-- (id<FIRListenerRegistration>)addSnapshotListenerWithOptions:
-                                   (FIRSnapshotListenOptions *)options
-                                                     listener:(void (^)(FIRDocumentSnapshot *_Nullable snapshot,NSError *_Nullable error))listener
+- (id<FIRListenerRegistration>)
+    addSnapshotListenerWithOptions:(FIRSnapshotListenOptions *)options
+                          listener:(void (^)(FIRDocumentSnapshot *_Nullable snapshot,
+                                             NSError *_Nullable error))listener
     NS_SWIFT_NAME(addSnapshotListener(options:listener:));
-// clang-format on
 
 @end
 

Firestore/core/src/api/listen_source.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2019 Google
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FIRESTORE_CORE_SRC_API_LISTEN_SOURCE_H_
+#define FIRESTORE_CORE_SRC_API_LISTEN_SOURCE_H_
+
+namespace firebase {
+namespace firestore {
+namespace api {
+
+/**
+ * An enum that configures the source of snapshot listeners listening to. By
+ * providing a source enum, listener raises snapshot from local cache changes
+ * only, or from both local cache and watch changes(which is the default).
+ *
+ * See `FIRFirestoreListenSource` for more details.
+ */
+enum class ListenSource { Default, Cache };
+
+}  // namespace api
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_API_LISTEN_SOURCE_H_

Firestore/core/src/core/event_manager.cc

@@ -41,6 +41,7 @@ model::TargetId EventManager::AddQueryListener(
   auto inserted = queries_.emplace(query, QueryListenersInfo{});
   bool first_listen = inserted.second;
   QueryListenersInfo& query_info = inserted.first->second;
+  bool first_listen_to_remote_store = !query_info.has_remote_listeners() && listener->listens_to_remote_store();
 
   query_info.listeners.push_back(listener);
 
@@ -58,6 +59,8 @@ model::TargetId EventManager::AddQueryListener(
 
   if (first_listen) {
     query_info.target_id = query_event_source_->Listen(query);
+  } else if(first_listen_to_remote_store){
+    query_event_source_->ListenToRemoteStore(query);
   }
   return query_info.target_id;
 }
@@ -66,17 +69,23 @@ void EventManager::RemoveQueryListener(
     std::shared_ptr<core::QueryListener> listener) {
   const Query& query = listener->query();
   bool last_listen = false;
+  bool last_listen_to_remote_store = false;
 
   auto found_iter = queries_.find(query);
   if (found_iter != queries_.end()) {
     QueryListenersInfo& query_info = found_iter->second;
     query_info.Erase(listener);
     last_listen = query_info.listeners.empty();
+    last_listen_to_remote_store = !query_info.has_remote_listeners() && listener->listens_to_remote_store();
+
   }
 
   if (last_listen) {
     queries_.erase(found_iter);
     query_event_source_->StopListening(query);
+  } else if(last_listen_to_remote_store){
+    query_event_source_->StopListeningToRemoteStore(query);
+
   }
 }
 

Firestore/core/src/core/event_manager.h

@@ -29,13 +29,13 @@
 #include "Firestore/core/src/util/empty.h"
 #include "Firestore/core/src/util/status_fwd.h"
 #include "absl/types/optional.h"
+#include "Firestore/core/src/core/query_listener.h"
 
 namespace firebase {
 namespace firestore {
 namespace core {
 
 class QueryEventSource;
-class QueryListener;
 
 /**
  * EventManager is responsible for mapping queries to query event listeners.
@@ -97,6 +97,15 @@ class EventManager : public SyncEngineCallback {
       snapshot_ = snapshot;
     }
 
+    bool has_remote_listeners() {
+      for (const auto& listener : listeners) {
+        if (listener->listens_to_remote_store()) {
+          return true;
+        }
+      }
+      return false;
+    }
+
    private:
     // Other members are public in this struct, ensure that any reads are
     // copies by requiring reads to go through a const getter.

Firestore/core/src/core/listen_options.h

@@ -17,10 +17,13 @@
 #ifndef FIRESTORE_CORE_SRC_CORE_LISTEN_OPTIONS_H_
 #define FIRESTORE_CORE_SRC_CORE_LISTEN_OPTIONS_H_
 
+#include "Firestore/core/src/api/listen_source.h"
 namespace firebase {
 namespace firestore {
 namespace core {
 
+using api::ListenSource;
+
 class ListenOptions {
  public:
   ListenOptions() = default;
@@ -44,14 +47,36 @@ class ListenOptions {
   }
 
   /**
-   * Creates a default ListenOptions, with metadata changes and
-   * wait_for_sync_when_online disabled.
+   * Creates a new ListenOptions.
+   *
+   * @param include_query_metadata_changes Raise events when only metadata of
+   *     the query changes.
+   * @param include_document_metadata_changes Raise events when only metadata of
+   *     documents changes.
+   * @param wait_for_sync_when_online Wait for a sync with the server when
+   *     online, but still raise events while offline.
+   * @param source sets the source snapshot listeners listen to.
+   */
+  ListenOptions(bool include_query_metadata_changes,
+                bool include_document_metadata_changes,
+                bool wait_for_sync_when_online,
+                ListenSource source)
+      : include_query_metadata_changes_(include_query_metadata_changes),
+        include_document_metadata_changes_(include_document_metadata_changes),
+        wait_for_sync_when_online_(wait_for_sync_when_online),
+        source_(std::move(source)) {
+  }
+
+  /**
+   * Creates a default ListenOptions, with metadata changes,
+   * wait_for_sync_when_online disabled, and listen source set to default.
    */
   static ListenOptions DefaultOptions() {
     return ListenOptions(
         /*include_query_metadata_changes=*/false,
         /*include_document_metadata_changes=*/false,
-        /*wait_for_sync_when_online=*/false);
+        /*wait_for_sync_when_online=*/false,
+        /*source=*/ListenSource::Default);
   }
 
   /**
@@ -63,7 +88,19 @@ class ListenOptions {
     return ListenOptions(
         /*include_query_metadata_changes=*/include_metadata_changes,
         /*include_document_metadata_changes=*/include_metadata_changes,
-        /*wait_for_sync_when_online=*/false);
+        /*wait_for_sync_when_online=*/false,
+        /*source=*/ListenSource::Default);
+  }
+
+  /**
+   * Creates a ListenOptions which sets the source snapshot listeners listen to.
+   */
+  static ListenOptions FromOptions(bool include_metadata_changes,
+                                   ListenSource source) {
+    return ListenOptions(
+        /*include_query_metadata_changes=*/include_metadata_changes,
+        /*include_document_metadata_changes=*/include_metadata_changes,
+        /*wait_for_sync_when_online=*/false, std::move(source));
   }
 
   bool include_query_metadata_changes() const {
@@ -78,10 +115,15 @@ class ListenOptions {
     return wait_for_sync_when_online_;
   }
 
+  ListenSource source() const {
+    return source_;
+  }
+
  private:
   bool include_query_metadata_changes_ = false;
   bool include_document_metadata_changes_ = false;
   bool wait_for_sync_when_online_ = false;
+  ListenSource source_ = ListenSource::Default;
 };
 
 }  // namespace core

Firestore/core/src/core/query_listener.cc

@@ -136,6 +136,11 @@ bool QueryListener::ShouldRaiseInitialEvent(const ViewSnapshot& snapshot,
     return true;
   }
 
+  // Always raise first event if listening to cache
+  if (!listens_to_remote_store()) {
+    return true;
+  }
+
   // NOTE: We consider OnlineState::Unknown as online (it should become Offline
   // or Online if we wait long enough).
   bool maybe_online = online_state != OnlineState::Offline;

Firestore/core/src/core/query_listener.h

@@ -63,6 +63,10 @@ class QueryListener {
     return query_;
   }
 
+  bool listens_to_remote_store() const {
+    return options_.source() != ListenSource::Cache;
+  }
+
   /** The last received view snapshot. */
   const absl::optional<ViewSnapshot>& snapshot() const {
     return snapshot_;

Firestore/core/src/core/sync_engine.cc

@@ -161,6 +161,12 @@ ViewSnapshot SyncEngine::InitializeViewAndComputeSnapshot(
   return view_change.snapshot().value();
 }
 
+void SyncEngine::ListenToRemoteStore(Query query) {
+  AssertCallbackExists("ListenToRemoteStore");
+  TargetData target_data = local_store_->AllocateTarget(query.ToTarget());
+  remote_store_->Listen(std::move(target_data));;
+}
+
 void SyncEngine::StopListening(const Query& query) {
   AssertCallbackExists("StopListening");
 
@@ -181,6 +187,22 @@ void SyncEngine::StopListening(const Query& query) {
   }
 }
 
+void SyncEngine::StopListeningToRemoteStore(const Query& query) {
+  AssertCallbackExists("stopListeningToRemoteStore");
+
+  auto query_view = query_views_by_query_[query];
+  HARD_ASSERT(query_view, "Trying to stop listening to a query not found");
+
+  TargetId target_id = query_view->target_id();
+  auto& queries = queries_by_target_[target_id];
+  queries.erase(std::remove(queries.begin(), queries.end(), query),
+                queries.end());
+
+  if (queries.empty()) {
+    remote_store_->StopListening(target_id);
+  }
+}
+
 void SyncEngine::RemoveAndCleanupTarget(TargetId target_id, Status status) {
   for (const Query& query : queries_by_target_.at(target_id)) {
     query_views_by_query_.erase(query);