add notification polling

Author: HHK1

Example/WeLoop/AppDelegate.swift

@@ -22,6 +22,9 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
 
+        // Set the refresh interval to display a notification badge. Do this before initializing the SDK
+        WeLoop.set(notificationRefreshInterval: 5.0)
+        
         // Set the invocation preferences. You can always change them after invoking the SDK
         WeLoop.set(preferredButtonPosition: .bottomRight)
         WeLoop.set(invocationMethod: .fab)

WeLoop/Classes/FloatingButtonController.swift

@@ -82,6 +82,10 @@ class FloatingButtonController: UIViewController {
         view.setNeedsLayout()
     }
 
+    func setNotificationBadge(hidden: Bool) {
+        self.button.setBadge(hidden: hidden)
+    }
+    
     @objc func keyboardDidShow(notification: NSNotification) {
         window.windowLevel = UIWindow.Level(rawValue: 0)
     }

WeLoop/Classes/WeLoop+Authentication.swift

@@ -38,7 +38,7 @@ public class WeLoop: NSObject {
     private var project: Project?
 
     /// The current app user. Must be set before the widget can be loaded
-    private var user: User?
+    internal var user: User?
 
     /// A ref to an error that occurred during the authentication. Will be passed down to the delegate the next time `invoke` is called
     private var authenticationError: Error?
@@ -53,6 +53,9 @@ public class WeLoop: NSObject {
 
     /// The preferred invocation method for the SDK. Must be set using `setInvocationMethod`
     var invocationMethod: WeLoopInvocation = .manual
+    
+    /// The time interval between each notification refresh call. Must be set using `setNotificationRefreshInterval`
+    var refreshInterval: TimeInterval = 30.0
 
     // MARK: Object references
 
@@ -66,6 +69,9 @@ public class WeLoop: NSObject {
     /// A reference to the controller containing the floating action button
     private var fabController: FloatingButtonController?
 
+    /// A reference to the polling timer to refresh notifications
+    private var notificationRefreshTimer: Timer?
+    
     /// A screenshot of the window is taken right before invoking the SDK. This is a ref to this screenshot
     var screenshot: UIImage?
 
@@ -125,18 +131,26 @@ public class WeLoop: NSObject {
         shared.fabController?.updatePosition(position)
     }
 
+    /// Set the preferred time interval between two calls to refresh the notifications on the weloop project.
+    /// You **must** call this before calling `initialize` if you wish to customize this parameter.
+    ///
+    /// - Parameter position: the desired time elapsed between each notification refresh
+    @objc public static func set(notificationRefreshInterval interval: TimeInterval) {
+        shared.refreshInterval = interval
+    }
 
     // MARK: - Internal API
 
-    
     /// Initializer is made private to prevent clients from creating any other instances
     private override init() {
         super.init()
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(startNotificationPolling), name: UIApplication.willEnterForegroundNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(stopNotificationPolling), name: UIApplication.willResignActiveNotification, object: nil)
     }
 
-    var isShowingWidget: Bool {
-        guard let widgetVC = weLoopViewController else { return false }
-        return widgetVC.window.isKeyWindow && previousWindow == nil
+    deinit {
+        NotificationCenter.default.removeObserver(self)
     }
 
     func initialize(apiKey: String, autoAuthentication: Bool = true, subdomain: String? = nil) {
@@ -152,6 +166,7 @@ public class WeLoop: NSObject {
                 self.project = project
                 self.setupInvocation(settings: project.settings)
                 try self.initializeWidget()
+                self.startNotificationPolling()
                 self.delegate?.initializationSuccessful?()
             } catch (let error) {
                 self.authenticationError = error
@@ -162,6 +177,8 @@ public class WeLoop: NSObject {
         dataTask?.resume()
     }
 
+    // MARK: Invocation
+    
     func set(invocationMethod method: WeLoopInvocation) {
         let oldInvocation = invocationMethod
         invocationMethod = method
@@ -178,7 +195,6 @@ public class WeLoop: NSObject {
             guard !isShowingWidget else { return }
             try showWidget()
         } catch (let error) {
-            print(error)
             delegate?.failedToLaunch?(with: error)
         }
     }
@@ -207,6 +223,13 @@ public class WeLoop: NSObject {
         }
     }
 
+    // MARK: Widget
+    
+    var isShowingWidget: Bool {
+        guard let widgetVC = weLoopViewController else { return false }
+        return widgetVC.window.isKeyWindow && previousWindow == nil
+    }
+    
     private func initializeWidget() throws {
         let url = try widgetURL()
         let widgetVC = WeLoopViewController()
@@ -241,8 +264,7 @@ public class WeLoop: NSObject {
 
         let settingsParams = try project.settings.queryParams()
 
-        var urlString = "\(appURL())/\(apiKey)/project/conversations?params=\(settingsParams)"
-
+        var urlString = "\(appURL)/\(apiKey)/project/conversations?params=\(settingsParams)"
         if autoAuthentication, let user = user {
             let userParams = try user.queryParams()
             urlString.append("&auto=\(userParams)")
@@ -251,6 +273,30 @@ public class WeLoop: NSObject {
         }
         return URL(string: urlString)!
     }
+    
+    // MARK: Notification Badge
+    
+    @objc private func startNotificationPolling() {
+        notificationRefreshTimer?.invalidate()
+        notificationRefreshTimer = Timer(timeInterval: refreshInterval, target: self, selector: #selector(refreshNotificationBadge), userInfo: nil, repeats: true)
+        RunLoop.main.add(notificationRefreshTimer!, forMode: .default)
+    }
+    
+    @objc private func stopNotificationPolling() {
+        notificationRefreshTimer?.invalidate()
+        notificationRefreshTimer = nil
+    }
+    
+    @objc func refreshNotificationBadge() {
+        refreshNotificationCount { [weak self] (response) in
+            do {
+                let notification = try response()
+                self?.fabController?.setNotificationBadge(hidden: !notification.isNotif)
+            } catch let (error) {
+                print(error)
+            }
+        }
+    }
 }
 
 extension WeLoop: ShakeGestureDelegate {

WeLoop/Classes/WeLoop.swift

@@ -0,0 +1,142 @@
+//
+//  Authentication.swift
+//  WeLoop
+//
+//  Created by Henry Huck on 04/04/2019.
+//
+
+import Foundation
+
+struct AuthenticationResponse: Decodable {
+    let access: Bool
+    let project: Project
+}
+
+struct NotificationResponse: Decodable {
+    let success: Bool
+    let isNotif: Bool
+    
+    private enum CodingKeys: String, CodingKey {
+        case isNotif = "IsNotif"
+        case success = "success"
+    }
+}
+
+typealias AuthenticationCallback = (_ project:() throws -> Project) -> Void
+typealias NotificationCallback = (_ notification:() throws -> NotificationResponse) -> Void
+
+// API Methods to communicate with the weLoop API. This is part of the weloop object since their number are limited,
+// but should be splitted into a dedicated object if it were to become bigger
+extension WeLoop {
+    
+    // Authentication
+    
+    func authenticate(completionHandler: @escaping AuthenticationCallback) -> URLSessionDataTask? {
+        
+        guard let request = authenticationRequest() else {
+            return nil
+        }
+        let autoAuthentication = self.autoAuthentication
+        
+        return URLSession(configuration: .default).dataTask(with: request, completionHandler: { (data, response, error) in
+            do {
+                if let error = error { throw error }
+                guard let data = data else { throw WeLoopError.authenticationDataMissing }
+                
+                let response = try JSONDecoder().decode(AuthenticationResponse.self, from: data)
+                if response.access || !autoAuthentication {
+                    DispatchQueue.main.async(execute: { () -> Void in
+                        completionHandler({response.project})
+                    })
+                } else {
+                    throw WeLoopError.accessDenied
+                }
+            } catch (let error) {
+                DispatchQueue.main.async(execute: { () -> Void in
+                    completionHandler({ throw error})
+                })
+            }
+        })
+    }
+    
+    private func authenticationRequest() -> URLRequest? {
+        
+        guard let apiKey = apiKey else { return nil }
+        
+        var urlRequest = URLRequest(url: authenticationURL)
+        urlRequest.httpMethod = "POST";
+        urlRequest.setValue("Application/json", forHTTPHeaderField: "Content-Type")
+        
+        guard let httpBody = try? JSONSerialization.data(withJSONObject: ["AutoAuthentication": autoAuthentication, "ProjectGuid": apiKey]) else {
+            return nil
+        }
+        urlRequest.httpBody = httpBody
+        return urlRequest
+    }
+    
+    // Notification Refresh
+    
+    func refreshNotificationCount(completionHandler: @escaping NotificationCallback) {
+        guard let request = refreshNotificationCountRequest() else {
+            return
+        }
+        
+        let task = URLSession(configuration: .default).dataTask(with: request, completionHandler: { (data, response, error) in
+            do {
+                if let error = error { throw error }
+                guard let data = data else { throw WeLoopError.notificationDataMissing }
+                let response = try JSONDecoder().decode(NotificationResponse.self, from: data)
+                DispatchQueue.main.async(execute: { () -> Void in
+                    completionHandler({ response })
+                })
+            } catch (let error) {
+                DispatchQueue.main.async(execute: { () -> Void in
+                    completionHandler({ throw error})
+                })
+            }
+        })
+        task.resume()
+    }
+    
+    private func refreshNotificationCountRequest() -> URLRequest? {
+        guard let notificationURL = notificationURL else { return nil }
+        var urlRequest = URLRequest(url: notificationURL)
+        urlRequest.httpMethod = "GET";
+        urlRequest.setValue("Application/json", forHTTPHeaderField: "Content-Type")
+        return urlRequest
+    }
+    
+    // Router
+    
+    private var authenticationURL: URL {
+        return URL(string: "\(apiURL)/UnauthorizedData/checkProjectIsVisible")!
+    }
+    
+    private var notificationURL: URL? {
+        get {
+            guard let email = user?.email,  let apiKey = apiKey else { return nil }
+            return URL(string: "\(apiURL)/UnauthorizedData/Notif?email=\(email)&projectGuid=\(apiKey)")!
+        }
+    }
+    
+    private var apiURL: String {
+        get {
+            if let subdomain = subdomain {
+                return "https://\(subdomain)-api.getweloop.io/api"
+            } else {
+                return "https://api.getweloop.io/api"
+            }
+        }
+    }
+    
+    var appURL: String {
+        get {
+            if let subdomain = subdomain {
+                return "https://\(subdomain).getweloop.io/app/plugin/index/#"
+            } else {
+                return "https://app.getweloop.io/app/plugin/index/#"
+            }
+            
+        }
+    }
+}