Merge pull request #488 from firebase/@invertase/swift-client

feat(firestore-counter): ios swift client

Author: jhuleatt

firestore-counter/POSTINSTALL.md

@@ -20,7 +20,10 @@ match /databases/{database}/documents/pages/{page} {
 ```
 
 
-#### Specify a document path and increment value in your web app
+#### Client samples for incrementing counter and retrieving its value
+
+##### Web Client
+
 
 1.  Download and copy the [compiled client sample](https://github.com/firebase/extensions/blob/master/firestore-counter/clients/web/dist/sharded-counter.js) into your application project.
 
@@ -60,6 +63,55 @@ match /databases/{database}/documents/pages/{page} {
   </html>
   ```
 
+##### iOS Client
+
+1. Ensure your Swift app already has Firebase [initialized](https://firebase.google.com/docs/ios/setup).
+2. Copy and paste the sample [code](https://github.com/firebase/extensions/blob/next/firestore-counter/clients/ios/Sources/FirestoreCounter/FirestoreCounter.swift) and create this file  `FirestoreShardedCounter.swift` in the relevant directory you wish to use the `FirestoreShardedCounter` instance.
+
+```swift
+import UIKit
+import FirestoreCounter
+import FirebaseFirestore
+
+class ViewController: UIViewController {
+  // somewhere in your app code initialize Firestore instance
+  var db = Firestore.firestore()
+  // create reference to the collection and the document you wish to use 
+  var doc = db.collection("pages").document("hello-world")
+  // initialize FirestoreShardedCounter with the document and the property which will hold the counter value
+  var controller = FirestoreShardCounter(docRef: doc, field: "visits")
+
+  override func viewDidLoad() {
+    super.viewDidLoad()
+    // event listener which returns total amount
+    controller.onSnapshot { (value, error) in
+      if let error = error {
+        // handle error
+      } else if let value = value {
+        // 'value' param is total amount of pages visits
+      }
+    }
+  }
+
+  @IBAction func getLatest(_ sender: Any) {
+    // get current total
+    controller.get() { (value, error) in
+      if let error = error {
+        // handle error
+      } else if let value = value {
+        // 'value' param is total amount of pages visits
+      }
+    }
+  }
+
+  @IBAction func incrementer(_ sender: Any) {
+    // to increment counter
+    controller.incrementBy(val: Double(1))
+  }
+}
+
+```
+
 
 #### Upgrading from v0.1.3 and earlier
 

firestore-counter/clients/ios/Package.swift

@@ -0,0 +1,33 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+  name: "FirestoreCounter",
+  platforms: [
+    .iOS(.v10)
+  ],
+  products: [
+    // Products define the executables and libraries a package produces, and make them visible to other packages.
+    .library(
+      name: "FirestoreCounter",
+      targets: ["FirestoreCounter"]),
+  ],
+  dependencies: [
+    // Dependencies declare other packages that this package depends on.
+    // .package(url: /* package url */, from: "1.0.0"),
+    .package(name: "Firebase",
+      url: "https://github.com/firebase/firebase-ios-sdk.git",
+      .branch("7.0.0"))
+  ],
+  targets: [
+    // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+    // Targets can depend on other targets in this package, and on products in packages this package depends on.
+    .target(
+      name: "FirestoreCounter",
+      dependencies: [
+        .product(name: "FirebaseFirestore", package: "Firebase")
+      ]),
+  ]
+)

firestore-counter/clients/ios/Sources/FirestoreCounter/FirestoreCounter.swift

@@ -0,0 +1,93 @@
+import FirebaseFirestore
+import Firebase
+
+public class FirebaseDistributedCounter {
+  private let db: Firestore
+  private let shardId = UUID().uuidString
+  private var shards = [String: Double]()
+  private let collectionId = "_counter_shards_"
+  private let shardRef: CollectionReference
+  private var docRef: DocumentReference
+  private var field: String
+
+  public init(docRef: DocumentReference, field: String) {
+    self.docRef = docRef
+    self.field = field
+    db = Firestore.firestore()
+    shardRef = docRef.collection(collectionId)
+    shards[self.docRef.path] = 0
+    shards[shardRef.document(String(shardId)).path] = 0
+    shards[shardRef.document("\t" + String(shardId.prefix(4))).path] = 0
+    shards[shardRef.document("\t\t" + String(shardId.prefix(3))).path] = 0
+    shards[shardRef.document("\t\t\t" + String(shardId.prefix(2))).path] = 0
+    shards[shardRef.document("\t\t\t\t" + String(shardId.prefix(1))).path] = 0
+  }
+
+  public func get(result: @escaping (Double?, Error?) -> Void) {
+    var documentIds = [String]()
+
+    for key in shards.keys {
+      documentIds.append((key as NSString).lastPathComponent)
+    }
+
+    shardRef.whereField(FieldPath.documentID(), in: documentIds).getDocuments() { snapshot, error in
+      if let error = error {
+        print("FirestoreCounter: Error getting documents: \(error)")
+        result(nil, error)
+      } else {
+        if let documents = snapshot?.documents {
+          let values = documents.map { (documentSnap) -> Double in
+            let document = documentSnap.data()
+            if let amount = document[self.field] as? Double {
+              return amount
+            } else {
+              return 0.0
+            }
+          }
+
+          let sum = values.reduce(0.0) { $0 + $1 }
+          result(sum, nil)
+        }
+      }
+    }
+  }
+
+  public func increment(by delta: Double) {
+    let increment = FieldValue.increment(delta)
+    var array = field.components(separatedBy: ".")
+    var update = [String: Any]()
+
+    array = array.reversed()
+
+    for component in array {
+      if (update.isEmpty) {
+        update = [component: increment]
+      } else {
+        update = [component: update]
+      }
+    }
+
+    shardRef.document(shardId).setData(update, merge: true)
+  }
+
+  public func onSnapshot(_ listener: @escaping (Double?, Error?) -> Void) {
+    shards.keys.forEach { path in
+      db.document(path).addSnapshotListener { snapshot, error in
+        if let error = error {
+          print("FirestoreCounter: Error listening to document changes: \(error)")
+          listener(nil, error)
+        } else {
+          guard let snapshot = snapshot,
+            let snapshotValue = snapshot.get(self.field),
+            let doubleVal = snapshotValue as? Double else {
+              listener(nil, error)
+              return
+          }
+          self.shards[path] = doubleVal
+          let sum = self.shards.reduce(0.0) { $0 + $1.value }
+          listener(sum, nil)
+        }
+      }
+    }
+  }
+}