Merge pull request #271 from IFTTT/feature/background_process_hook

Adding hooks that can be used to execute code when the system runs a background process

Author: ssathy2

Examples/GroceryExpress/AppDelegate.swift

@@ -24,6 +24,12 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         ConnectButtonController.analyticsEnabled = true
         ConnectButtonController.initialize(options: .init(enableSDKBackgroundProcess: true, showPermissionsPrompts: true))
         ConnectButtonController.activate(connections: [DisplayInformation.locationConnection.connectionId])
+        ConnectButtonController.setBackgroundProcessClosures {
+            print("Background process started!")
+        } expirationHandler: {
+            print("Background process expired!")
+        }
+
         return true
     }
 

IFTTT SDK/ConnectButton+Constants.swift

@@ -7,7 +7,7 @@
 
 import Foundation
 
-typealias VoidClosure = () -> Void
+public typealias VoidClosure = () -> Void
 
 extension ConnectButton {
 

IFTTT SDK/ConnectButtonController+Public.swift

@@ -153,4 +153,16 @@ extension ConnectButtonController {
     public static func geofencesEnabled(for connectionId: String) -> Bool {
         return ConnectionsSynchronizer.shared.geofencesEnabled(for: connectionId)
     }
+    
+    /// Allows for a closure to be executed when the OS starts a background process set up by the SDK.
+    ///
+    /// The `launchHandler` parameter will get run on a background thread. `expirationHandler` gets called by the system right before the amount of allotted time for the background process is zero. Use the `expirationHandler` to perform any cleanup of resources used or allocated in `launchHandler`. `expirationHandler` will be executed on the same background thread as `launchHandler`.
+    ///
+    /// - Parameters:
+    ///     - launchHandler: A closure to execute when the OS starts a background process set up by the SDK.
+    ///     - expirationHandler: A closure to execute when the allotted time for the background process is zero.
+    public static func setBackgroundProcessClosures(launchHandler: VoidClosure?, expirationHandler: VoidClosure?) {
+        ConnectionsSynchronizer.shared.setDeveloperBackgroundProcessClosures(launchHandler: launchHandler,
+                                                                               expirationHandler: expirationHandler)
+    }
 }

IFTTT SDK/ConnectionsSynchronizer.swift

@@ -278,6 +278,11 @@ final class ConnectionsSynchronizer {
     func geofencesEnabled(for connectionId: String) -> Bool {
         return registry.geofencesEnabled(connectionId: connectionId)
     }
+    
+    func setDeveloperBackgroundProcessClosures(launchHandler: VoidClosure?, expirationHandler: VoidClosure?) {
+        scheduler.developerBackgroundProcessLaunchClosure = launchHandler
+        scheduler.developerBackgroundProcessExpirationClosure = expirationHandler
+    }
 }
 
 /// Handles coordination of native services with a set of connections

IFTTT SDK/SynchronizationScheduler.swift

@@ -35,6 +35,15 @@ final class SynchronizationScheduler {
     /// A closure that gets invoked after an authentication failure in a sync task
     var onAuthenticationFailure: VoidClosure?
 
+    /// A `DispatchQueue` to use in executing `developerBackgroundProcessClosure`.
+    private let developerBackgroundProcessDispatchQueue = DispatchQueue(label: "com.ifttt.backgroundprocess.developer_closure")
+    
+    /// A closure that's passed in by the developer to execute when a background process handler gets called.
+    var developerBackgroundProcessLaunchClosure: VoidClosure?
+    
+    /// A closure that's called when expiration of the background process occurs. This is supplied by the developer.
+    var developerBackgroundProcessExpirationClosure: VoidClosure?
+
     /// Creates a `SyncScheduler`
     ///
     /// - Parameters:
@@ -236,12 +245,20 @@ extension SynchronizationScheduler {
     private func registerBackgroundProcess() {
         BGTaskScheduler.shared.register(forTaskWithIdentifier: SynchronizationScheduler.BackgroundProcessIdentifier, using: nil) { [weak self] (task) in
             guard let appProcessTask = task as? BGProcessingTask else { return }
-
-            self?.scheduleBackgroundProcess()
 
+            self?.scheduleBackgroundProcess()
             appProcessTask.expirationHandler = {
-               ConnectButtonController.synchronizationLog("Synchronization took too long, expiration handler invoked")
-               self?.manager.currentTask?.cancel()
+                self?.developerBackgroundProcessDispatchQueue.async {
+                    self?.developerBackgroundProcessExpirationClosure?()
+                }
+                
+                ConnectButtonController.synchronizationLog("Synchronization took too long, expiration handler invoked")
+                self?.manager.currentTask?.cancel()
+                appProcessTask.setTaskCompleted(success: true)
+            }
+            
+            self?.developerBackgroundProcessDispatchQueue.async {
+                self?.developerBackgroundProcessLaunchClosure?()
             }
 
             self?.manager.sync(source: .internalBackgroundProcess) { (result, authenticationFailure) in

Location.md

@@ -82,6 +82,9 @@ The SDK doesn't directly invoke any background fetch methods. To use background
 ### Geofence Toggling
 The SDK supports toggling geofences on and off for a given connection. To toggle geofences for a connection, call `ConnectButtonController.setGeofencesEnabled(enabled:for:)`.
 
+### Background process execution
+To set closures to run when a SDK-defined background process runs, call `ConnectButtonController.setBackgroundProcessClosures(launchHandler:expirationHandler)`. The `launchHandler` parameter is the closure that's executed when a background process starts. The `expirationHandler` parameter is the closure that's executed when the background process is about to be ended by the system.
+
 ### Notes
 - Automatic synchronization for a given connection will only be run if the connection has location triggers. Similarly, location region monitoring will only be started if the connection has location triggers setup.
 - The SDK runs a synchronization by default for the following events:

SDKHostApp/AppDelegate.swift

@@ -10,9 +10,6 @@ import UIKit
 
 @main
 class AppDelegate: UIResponder, UIApplicationDelegate {
-
-
-
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
         // Override point for customization after application launch.
         return true