Reorganize Sessions settings (#10599)

Author: visumickey

FirebaseSessions/Sources/FirebaseSessions.swift

@@ -40,7 +40,7 @@ protocol SessionsProvider {
   private let initiator: SessionInitiator
   private let identifiers: Identifiers
   private let appInfo: ApplicationInfo
-  private let settings: SettingsProtocol
+  private let settings: SessionsSettings
 
   // MARK: - Initializers
 
@@ -63,13 +63,9 @@ protocol SessionsProvider {
     )
     let initiator = SessionInitiator()
     let appInfo = ApplicationInfo(appID: appID)
-    let settings = Settings(
+    let settings = SessionsSettings(
       appInfo: appInfo,
-      downloader: SettingsDownloader(
-        appInfo: appInfo,
-        identifiers: identifiers,
-        installations: installations
-      )
+      installations: installations
     )
 
     self.init(appID: appID,
@@ -82,7 +78,7 @@ protocol SessionsProvider {
 
   // Initializes the SDK and begines the process of listening for lifecycle events and logging events
   init(appID: String, identifiers: Identifiers, coordinator: SessionCoordinator,
-       initiator: SessionInitiator, appInfo: ApplicationInfo, settings: SettingsProtocol) {
+       initiator: SessionInitiator, appInfo: ApplicationInfo, settings: SessionsSettings) {
     self.appID = appID
 
     self.identifiers = identifiers
@@ -95,7 +91,7 @@ protocol SessionsProvider {
 
     self.initiator.beginListening {
       // On each session start, first update Settings if expired
-      self.settings.fetchAndCacheSettings()
+      self.settings.updateSettings()
       self.identifiers.generateNewSessionID()
       let event = SessionStartEvent(identifiers: self.identifiers, appInfo: self.appInfo)
       DispatchQueue.global().async {

FirebaseSessions/Sources/SessionLocalConfig.swift renamed to FirebaseSessions/Sources/Settings/LocalOverrideSettings.swift

@@ -15,39 +15,41 @@
 
 import Foundation
 
-/// Protoco defining the loval override values for the SDK settings.
-protocol SessionLocalConfigProtocol {
-  /// Session enabled flag value.
-  var sessionEnabled: Bool? { get }
-
-  /// Session timeout flag value.
-  var sessionTimeout: TimeInterval? { get }
-
-  /// Session timeout flag value.
-  var sessionSamplingRate: Double? { get }
-}
-
 /// Class that manages the local overrides configs related to the library.
-class SessionLocalConfig: SessionLocalConfigProtocol {
+class LocalOverrideSettings: SettingsProvider, SettingsProtocol {
   static let PlistKey_sessions_enabled = "FirebaseSessionsEnabled"
   static let PlistKey_sessions_timeout = "FirebaseSessionsTimeout"
   static let PlistKey_sessions_samplingRate = "FirebaseSessionsSampingRate"
 
-  var sessionEnabled: Bool? {
-    return plistValueForConfig(configName: SessionLocalConfig.PlistKey_sessions_enabled) as? Bool
+  var sessionsEnabled: Bool? {
+    return plistValueForConfig(configName: LocalOverrideSettings.PlistKey_sessions_enabled) as? Bool
   }
 
   var sessionTimeout: TimeInterval? {
     return
-      plistValueForConfig(configName: SessionLocalConfig.PlistKey_sessions_timeout) as? TimeInterval
+      plistValueForConfig(configName: LocalOverrideSettings
+        .PlistKey_sessions_timeout) as? TimeInterval
   }
 
-  var sessionSamplingRate: Double? {
+  var samplingRate: Double? {
     return
-      plistValueForConfig(configName: SessionLocalConfig.PlistKey_sessions_samplingRate) as? Double
+      plistValueForConfig(configName: LocalOverrideSettings
+        .PlistKey_sessions_samplingRate) as? Double
   }
 
   private func plistValueForConfig(configName: String) -> Any? {
-    return Bundle.main.value(forKey: configName)
+    return Bundle.main.object(forInfoDictionaryKey: configName)
+  }
+}
+
+typealias LocalOverrideSettingsProvider = LocalOverrideSettings
+extension LocalOverrideSettingsProvider {
+  func updateSettings() {
+    // Nothing to be done since there is nothing to be updated.
+  }
+
+  func isSettingsStale() -> Bool {
+    // Settings are never stale since all of these are local settings from Plist
+    return false
   }
 }

FirebaseSessions/Sources/Settings.swift renamed to FirebaseSessions/Sources/Settings/RemoteSettings.swift

@@ -20,22 +20,7 @@ extension ApplicationInfoProtocol {
   var synthesizedVersion: String { return "\(appDisplayVersion) (\(appBuildVersion))" }
 }
 
-extension SettingsProtocol {
-  func fetchAndCacheSettings() {
-    return fetchAndCacheSettings(currentTime: Date())
-  }
-}
-
-/// Provides the APIs to access Settings and their configuration values
-protocol SettingsProtocol {
-  /// Attempts to fetch settings only if the current cache is expired
-  func fetchAndCacheSettings(currentTime: Date)
-  var sessionsEnabled: Bool { get }
-  var samplingRate: Double { get }
-  var sessionTimeout: TimeInterval { get }
-}
-
-class Settings: SettingsProtocol {
+class RemoteSettings: SettingsProvider, SettingsProtocol {
   private static let cacheDurationSecondsDefault: TimeInterval = 60 * 60
   private static let flagSessionsEnabled = "sessions_enabled"
   private static let flagSamplingRate = "sampling_rate"
@@ -46,36 +31,15 @@ class Settings: SettingsProtocol {
   private let downloader: SettingsDownloadClient
   private var cache: SettingsCacheClient
 
-  var sessionsEnabled: Bool {
-    guard let enabled = sessionsCache[Settings.flagSessionsEnabled] as? Bool else {
-      return true
-    }
-    return enabled
-  }
-
-  var samplingRate: Double {
-    guard let rate = sessionsCache[Settings.flagSamplingRate] as? Double else {
-      return 1.0
-    }
-    return rate
-  }
-
-  var sessionTimeout: TimeInterval {
-    guard let timeout = sessionsCache[Settings.flagSessionTimeout] as? Double else {
-      return 30 * 60
-    }
-    return timeout
-  }
-
   private var cacheDurationSeconds: TimeInterval {
-    guard let duration = cache.cacheContent[Settings.flagCacheDuration] as? Double else {
-      return Settings.cacheDurationSecondsDefault
+    guard let duration = cache.cacheContent[RemoteSettings.flagCacheDuration] as? Double else {
+      return RemoteSettings.cacheDurationSecondsDefault
     }
     return duration
   }
 
   private var sessionsCache: [String: Any] {
-    return cache.cacheContent[Settings.flagSessionsCache] as? [String: Any] ?? [:]
+    return cache.cacheContent[RemoteSettings.flagSessionsCache] as? [String: Any] ?? [:]
   }
 
   init(appInfo: ApplicationInfoProtocol,
@@ -86,7 +50,7 @@ class Settings: SettingsProtocol {
     self.downloader = downloader
   }
 
-  func fetchAndCacheSettings(currentTime: Date) {
+  private func fetchAndCacheSettings(currentTime: Date) {
     // Only fetch if cache is expired, otherwise do nothing
     guard isCacheExpired(time: currentTime) else {
       Logger.logDebug("[Settings] Cache is not expired, no fetch will be made.")
@@ -109,6 +73,36 @@ class Settings: SettingsProtocol {
       }
     }
   }
+}
+
+typealias RemoteSettingsConfigurations = RemoteSettings
+extension RemoteSettingsConfigurations {
+  var sessionsEnabled: Bool? {
+    return sessionsCache[RemoteSettings.flagSessionsEnabled] as? Bool
+  }
+
+  var samplingRate: Double? {
+    return sessionsCache[RemoteSettings.flagSamplingRate] as? Double
+  }
+
+  var sessionTimeout: TimeInterval? {
+    return sessionsCache[RemoteSettings.flagSessionTimeout] as? Double
+  }
+}
+
+typealias RemoteSettingsProvider = RemoteSettings
+extension RemoteSettingsConfigurations {
+  func updateSettings(currentTime: Date) {
+    fetchAndCacheSettings(currentTime: currentTime)
+  }
+
+  func updateSettings() {
+    updateSettings(currentTime: Date())
+  }
+
+  func isSettingsStale() -> Bool {
+    return isCacheExpired(time: Date())
+  }
 
   private func isCacheExpired(time: Date) -> Bool {
     guard !cache.cacheContent.isEmpty else {

FirebaseSessions/Sources/Settings/SDKDefaultSettings.swift

@@ -0,0 +1,46 @@
+//
+// Copyright 2022 Google LLC
+//
+// 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.
+
+import Foundation
+
+/// Class that manages the local overrides configs related to the library.
+class SDKDefaultSettings: SettingsProvider, SettingsProtocol {
+  var sessionsEnabled: Bool? {
+    // Default is sessions enabled
+    return true
+  }
+
+  var sessionTimeout: TimeInterval? {
+    // Default is 30 minutes
+    return 30 * 60
+  }
+
+  var samplingRate: Double? {
+    // Default is all events are dispatched
+    return 1.0
+  }
+}
+
+typealias SDKDefaultSettingsProvider = SDKDefaultSettings
+extension SDKDefaultSettingsProvider {
+  func updateSettings() {
+    // Nothing to be done since there is nothing to be updated.
+  }
+
+  func isSettingsStale() -> Bool {
+    // Settings are never stale since all of these are local settings from Plist
+    return false
+  }
+}

FirebaseSessions/Sources/Settings/SessionsSettings.swift

@@ -0,0 +1,84 @@
+//
+// Copyright 2022 Google LLC
+//
+// 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.
+
+import Foundation
+
+/// Class that manages the configs related to the settings library
+class SessionsSettings {
+  private let appInfo: ApplicationInfoProtocol
+  private let installations: InstallationsProtocol
+  private let sdkDefaults: SDKDefaultSettings
+  private let localOverrides: LocalOverrideSettings
+  private let remoteSettings: RemoteSettings
+
+  convenience init(appInfo: ApplicationInfoProtocol, installations: InstallationsProtocol) {
+    self.init(appInfo: appInfo,
+              installations: installations,
+              sdkDefaults: SDKDefaultSettings(),
+              localOverrides: LocalOverrideSettings(),
+              remoteSettings: RemoteSettings(appInfo: appInfo,
+                                             downloader: SettingsDownloader(appInfo: appInfo,
+                                                                            installations: installations)))
+  }
+
+  init(appInfo: ApplicationInfoProtocol,
+       installations: InstallationsProtocol,
+       sdkDefaults: SDKDefaultSettings,
+       localOverrides: LocalOverrideSettings,
+       remoteSettings: RemoteSettings) {
+    self.appInfo = appInfo
+    self.installations = installations
+    self.sdkDefaults = sdkDefaults
+    self.localOverrides = localOverrides
+    self.remoteSettings = remoteSettings
+  }
+
+  var sessionsEnabled: Bool {
+    // Order of precendence LocalOverrides > Remote Settings > SDK Defaults
+    if let sessionEnabled = localOverrides.sessionsEnabled {
+      return sessionEnabled
+    } else if let sessionEnabled = remoteSettings.sessionsEnabled {
+      return sessionEnabled
+    }
+    return sdkDefaults.sessionsEnabled!
+  }
+
+  var sessionTimeout: TimeInterval {
+    // Order of precendence LocalOverrides > Remote Settings > SDK Defaults
+    if let sessionTimeout = localOverrides.sessionTimeout {
+      return sessionTimeout
+    } else if let sessionTimeout = remoteSettings.sessionTimeout {
+      return sessionTimeout
+    }
+    return sdkDefaults.sessionTimeout!
+  }
+
+  var samplingRate: Double {
+    // Order of precendence LocalOverrides > Remote Settings > SDK Defaults
+    if let samplingRate = localOverrides.samplingRate {
+      return samplingRate
+    } else if let samplingRate = remoteSettings.samplingRate {
+      return samplingRate
+    }
+    return sdkDefaults.samplingRate!
+  }
+
+  func updateSettings() {
+    // Update the settings for all the settings providers
+    sdkDefaults.updateSettings()
+    remoteSettings.updateSettings()
+    localOverrides.updateSettings()
+  }
+}

FirebaseSessions/Sources/SettingsCacheClient.swift renamed to FirebaseSessions/Sources/Settings/SettingsCacheClient.swift

@@ -27,13 +27,10 @@ protocol SettingsDownloadClient {
 
 class SettingsDownloader: SettingsDownloadClient {
   private let appInfo: ApplicationInfoProtocol
-  private let identifiers: IdentifierProvider
   private let installations: InstallationsProtocol
 
-  init(appInfo: ApplicationInfoProtocol, identifiers: IdentifierProvider,
-       installations: InstallationsProtocol) {
+  init(appInfo: ApplicationInfoProtocol, installations: InstallationsProtocol) {
     self.appInfo = appInfo
-    self.identifiers = identifiers
     self.installations = installations
   }
 

FirebaseSessions/Sources/SettingsDownloadClient.swift renamed to FirebaseSessions/Sources/Settings/SettingsDownloadClient.swift

@@ -0,0 +1,29 @@
+//
+// Copyright 2022 Google LLC
+//
+// 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.
+
+import Foundation
+
+/// Provides the APIs to access Settings and their configuration values
+protocol SettingsProtocol {
+  // Config to show if sessions is enabled
+  var sessionsEnabled: Bool? { get }
+
+  // Config showing the sampling rate for sessions
+
+  var samplingRate: Double? { get }
+
+  // Background timeout config value before which a new session is generated
+  var sessionTimeout: TimeInterval? { get }
+}