Merge branch develop into issue/2171-refactor-order-starter-vm

Author: shiki

RELEASE-NOTES.txt

@@ -4,7 +4,8 @@
 - Products: now the keyboard pop up automatically in Edit Description
 - The Processing orders list will now show upcoming (future) orders.
 - Improved stats: fixed the incorrect time range on "This Week" tab when loading improved stats on a day when daily saving time changes.
-- The Orders list are now automatically refreshed when reopening the app. 
+- The Orders list is now automatically refreshed when reopening the app. 
+- The Orders list is automatically refreshed if a new order (push notification) comes in.
 
 
 4.1

WooCommerce/Classes/Notifications/PushNotificationsManager.swift

@@ -13,6 +13,16 @@ final class PushNotificationsManager: PushNotesManager {
     ///
     let configuration: PushNotificationsConfiguration
 
+    /// Mutable reference to `foregroundNotifications`.
+    private let foregroundNotificationsSubject = PublishSubject<ForegroundNotification>()
+
+    /// An observable that emits values when the Remote Notifications are received while the app is
+    /// in the foreground.
+    ///
+    var foregroundNotifications: Observable<ForegroundNotification> {
+        foregroundNotificationsSubject
+    }
+
     /// Returns the current Application's State
     ///
     private var applicationState: UIApplication.State {
@@ -251,8 +261,10 @@ private extension PushNotificationsManager {
             return false
         }
 
-        if let message = userInfo.dictionary(forKey: APNSKey.aps)?.string(forKey: APNSKey.alert) {
-            configuration.application.presentInAppNotification(message: message)
+        if let foregroundNotification = ForegroundNotification.from(userInfo: userInfo) {
+            configuration.application.presentInAppNotification(message: foregroundNotification.message)
+
+            foregroundNotificationsSubject.send(foregroundNotification)
         }
 
         synchronizeNotifications(completionHandler: completionHandler)
@@ -401,6 +413,20 @@ private extension PushNotificationsManager {
     }
 }
 
+// MARK: - ForegroundNotification Extension
+
+private extension ForegroundNotification {
+    static func from(userInfo: [AnyHashable: Any]) -> ForegroundNotification? {
+        guard let noteID = userInfo.integer(forKey: APNSKey.identifier),
+              let message = userInfo.dictionary(forKey: APNSKey.aps)?.string(forKey: APNSKey.alert),
+              let type = userInfo.string(forKey: APNSKey.type),
+              let noteKind = Note.Kind(rawValue: type) else {
+            return nil
+        }
+
+        return ForegroundNotification(noteID: noteID, kind: noteKind, message: message)
+    }
+}
 
 // MARK: - Private Types
 //

WooCommerce/Classes/ServiceLocator/ForegroundNotification.swift

@@ -0,0 +1,18 @@
+
+import Foundation
+import struct Yosemite.Note
+
+/// Emitted by `PushNotificationsManager` when a remote notification is received while
+/// the app is active.
+///
+struct ForegroundNotification {
+    /// The `note_id` value received from the Remote Notification's `userInfo`.
+    ///
+    let noteID: Int
+    /// The `type` value received from the Remote Notification's `userInfo`.
+    ///
+    let kind: Note.Kind
+    /// The `alert` value received from the Remote Notification's `userInfo`.
+    ///
+    let message: String
+}

WooCommerce/Classes/ServiceLocator/PushNotesManager.swift

@@ -3,6 +3,11 @@ import UIKit
 
 protocol PushNotesManager {
 
+    /// An observable that emits values when the Remote Notifications are received while the app is
+    /// in the foreground.
+    ///
+    var foregroundNotifications: Observable<ForegroundNotification> { get }
+
     /// Resets the Badge Count.
     ///
     func resetBadgeCount()

WooCommerce/Classes/Tools/Observables/Observable.swift

@@ -0,0 +1,43 @@
+
+import Foundation
+
+/// Signature of a block called for every emitted Observable value.
+///
+typealias OnNext<Element> = (Element) -> ()
+
+/// Emits values over time.
+///
+/// Acts like `Publisher` in Combine and `Observable` in ReactiveX.
+///
+/// This class is a pseudo-abstract class. It does not do anything on its own. Use the
+/// subclasses like `PublishSubject` instead.
+///
+/// See here for more info about Observables:
+///
+/// - https://developer.apple.com/documentation/combine/publisher
+/// - http://reactivex.io/documentation/observable.html
+///
+class Observable<Element> {
+    /// Subscribe to values emitted by this `Observable`.
+    ///
+    /// The given `onNext` is called a "Observer" or "Subscriber".
+    ///
+    /// Example:
+    ///
+    /// ```
+    /// class ViewModel {
+    ///     let onDataLoaded: Observable<[Item]>
+    /// }
+    ///
+    /// func viewDidLoad() {
+    ///     viewModel.onDataLoaded.subscribe { items in
+    ///         // do something with `items`
+    ///         tableView.reloadData()
+    ///     }
+    /// }
+    /// ```
+    ///
+    func subscribe(_ onNext: @escaping OnNext<Element>) -> ObservationToken {
+        fatalError("Abstract method. This must be implemented by subclasses.")
+    }
+}

…rce/Classes/Tools/ObservationToken.swift …Tools/Observables/ObservationToken.swiftWooCommerce/Classes/Tools/ObservationToken.swift renamed to WooCommerce/Classes/Tools/Observables/ObservationToken.swift WooCommerce/Classes/Tools/ObservationToken.swift renamed to WooCommerce/Classes/Tools/Observables/ObservationToken.swift

@@ -1,6 +1,13 @@
 /// An observation token that contains a closure when the observation is cancelled.
+///
+/// This acts like `AnyCancellable` in Combine and `IDisposable` in ReactiveX.
+///
 /// Example usage can be found in `ProductImageActionHandler`.
 ///
+/// See:
+///
+///   - https://developer.apple.com/documentation/combine/anycancellable
+///
 final class ObservationToken {
     private let onCancel: () -> Void
 

WooCommerce/Classes/Tools/Observables/Observer.swift

@@ -0,0 +1,38 @@
+
+import Foundation
+
+/// A subscription to an `Observable`.
+///
+/// Acts like `Subscriber` in Combine and `IObserver` in ReactiveX.
+///
+/// Observers are simply the callbacks when you subscribe to an `Observable`. Consider this:
+///
+/// ```
+/// viewModel.onDataLoaded.subscribe { items in
+///     /// do something
+/// }
+/// ```
+///
+/// The block passed to the `subscribe` method with the "do something" comment is the `Observer`.
+///
+/// Currently, this `struct` is simply a container to clarify these concepts. In other frameworks,
+/// an `Observer` can have more callbacks like `onCompleted`.
+///
+/// See these for more info about Observers:
+///
+///  - https://developer.apple.com/documentation/combine/subscriber
+///  - http://introtorx.com/Content/v1.0.10621.0/02_KeyTypes.html#IObserver
+///
+struct Observer<Element> {
+    private let onNext: (Element) -> ()
+
+    init(onNext: @escaping OnNext<Element>) {
+        self.onNext = onNext
+    }
+
+    /// Send the given value to the observer.
+    ///
+    func send(_ element: Element) {
+        onNext(element)
+    }
+}

WooCommerce/Classes/Tools/Observables/PublishSubject.swift

@@ -0,0 +1,96 @@
+
+import Foundation
+
+/// Emits values to observers as soon as the values arrive. Only the values emitted after the
+/// subscription will be emitted.
+///
+/// Acts like `PassthroughSubject` in Combine and `PublishSubject` in ReactiveX.
+///
+/// This observable is a bridge between the imperative and reactive programming paradigms. It
+/// allows consumers to _manually_ emit values using the `send()` method.
+///
+/// Multiple observers are allowed which makes this a possible replacement for
+/// `NSNotificationCenter` observations.
+///
+/// ## Example Usage
+///
+/// In a class that you would like to emit values (or events), add the `PublishSubject` defining
+/// the value type:
+///
+/// ```
+/// class PostListViewModel {
+///     /// Calls observers/subscribers whenever the list of Post changes.
+///     private let postsSubject = PublishSubject<[Post]>()
+/// }
+/// ```
+///
+/// Since `PublishSubject` exposes `send()` which makes this a **mutable** Observable, we recommend
+/// exposing only the `Observable<[Post]>` interface:
+///
+/// ```
+/// class PostListViewModel {
+///     private let postsSubject = PublishSubject<[Post]>()
+///
+///     /// The public Observable that the ViewController will subscribe to
+///     var posts: Observable<[Post]> {
+///         postsSubject
+///     }
+/// }
+/// ```
+///
+/// The `ViewController` can then subscribe to the `posts` Observable:
+///
+/// ```
+/// func viewDidLoad() {
+///     viewModel.posts.subscribe { posts in
+///         // do something with posts
+///         tableView.reloadData()
+///     }
+/// }
+/// ```
+///
+/// Whenever the list of post changes, like after fetching from the API, the `ViewModel` can
+/// _notify_ the `ViewController` by updating `postsSubject`:
+///
+/// ```
+/// fetchFromAPI { fetchedPosts
+///     // Notify the observers (e.g. ViewController) that the list of posts have changed
+///     postsSubject.send(fetchedPosts)
+/// }
+/// ```
+///
+/// ## References
+///
+/// See here for info about similar observables in other frameworks:
+///
+/// - https://developer.apple.com/documentation/combine/passthroughsubject
+/// - http://reactivex.io/documentation/subject.html
+///
+final class PublishSubject<Element>: Observable<Element> {
+
+    private typealias OnCancel = () -> ()
+
+    /// The list of Observers that will be notified when a new value is sent.
+    ///
+    private var observers = [UUID: Observer<Element>]()
+
+    override func subscribe(_ onNext: @escaping OnNext<Element>) -> ObservationToken {
+        let uuid = UUID()
+
+        observers[uuid] = Observer(onNext: onNext)
+
+        let onCancel: OnCancel = { [weak self] in
+            self?.observers.removeValue(forKey: uuid)
+        }
+
+        return ObservationToken(onCancel: onCancel)
+    }
+
+    /// Emit a new value. All observers are immediately called with the given value.
+    ///
+    func send(_ element: Element) {
+        observers.values.forEach { observer in
+            observer.send(element)
+        }
+    }
+}

WooCommerce/Classes/ViewRelated/Orders/OrdersViewController.swift

@@ -137,7 +137,7 @@ private extension OrdersViewController {
     /// Initialize ViewModel operations
     ///
     func configureViewModel() {
-        viewModel.onShouldResynchronizeAfterAppActivation = { [weak self] in
+        viewModel.onShouldResynchronizeIfViewIsVisible = { [weak self] in
             guard let self = self,
                   // Avoid synchronizing if the view is not visible. The refresh will be handled in
                   // `viewWillAppear` instead.

WooCommerce/Classes/ViewRelated/Orders/OrdersViewModel.swift

@@ -24,11 +24,17 @@ final class OrdersViewModel {
     }
 
     private let storageManager: StorageManagerType
+    private let pushNotificationsManager: PushNotesManager
     private let notificationCenter: NotificationCenter
 
-    /// The block called if self requests a resynchronization of the first page.
+    /// Used for cancelling the observer for Remote Notifications when `self` is deallocated.
     ///
-    var onShouldResynchronizeAfterAppActivation: (() -> ())?
+    private var cancellable: ObservationToken?
+
+    /// The block called if self requests a resynchronization of the first page. The
+    /// resynchronization should only be done if the view is visible.
+    ///
+    var onShouldResynchronizeIfViewIsVisible: (() -> ())?
 
     /// OrderStatus that must be matched by retrieved orders.
     ///
@@ -84,15 +90,21 @@ final class OrdersViewModel {
     }
 
     init(storageManager: StorageManagerType = ServiceLocator.storageManager,
+         pushNotificationsManager: PushNotesManager = ServiceLocator.pushNotesManager,
          notificationCenter: NotificationCenter = .default,
          statusFilter: OrderStatus?,
          includesFutureOrders: Bool = true) {
         self.storageManager = storageManager
+        self.pushNotificationsManager = pushNotificationsManager
         self.notificationCenter = notificationCenter
         self.statusFilter = statusFilter
         self.includesFutureOrders = includesFutureOrders
     }
 
+    deinit {
+        stopObservingForegroundRemoteNotifications()
+    }
+
     /// Start fetching DB results and forward new changes to the given `tableView`.
     ///
     /// This is the main activation method for this ViewModel. This should only be called once.
@@ -106,6 +118,8 @@ final class OrdersViewModel {
                                        name: UIApplication.willResignActiveNotification, object: nil)
         notificationCenter.addObserver(self, selector: #selector(handleAppActivation),
                                        name: UIApplication.didBecomeActiveNotification, object: nil)
+
+        observeForegroundRemoteNotifications()
     }
 
     /// Execute the `resultsController` query, logging the error if there's any.
@@ -130,7 +144,7 @@ final class OrdersViewModel {
         }
 
         isAppActive = true
-        onShouldResynchronizeAfterAppActivation?()
+        onShouldResynchronizeIfViewIsVisible?()
     }
 
     /// Returns what `OrderAction` should be used when synchronizing.
@@ -230,6 +244,29 @@ final class OrdersViewModel {
     }
 }
 
+// MARK: - Remote Notifications Observation
+
+private extension OrdersViewModel {
+    /// Watch for "new order" Remote Notifications that are received while the app is in the
+    /// foreground.
+    ///
+    /// A refresh will be requested when receiving them.
+    ///
+    func observeForegroundRemoteNotifications() {
+        cancellable = pushNotificationsManager.foregroundNotifications.subscribe { [weak self] notification in
+            guard notification.kind == .storeOrder else {
+                return
+            }
+
+            self?.onShouldResynchronizeIfViewIsVisible?()
+        }
+    }
+
+    func stopObservingForegroundRemoteNotifications() {
+        cancellable?.cancel()
+    }
+}
+
 // MARK: - TableView Support
 
 extension OrdersViewModel {