Refactor settings manager

Author: aravind-raveendran

Sources/DolbyIORTSCore/Manager/SettingsManager.swift

@@ -0,0 +1,55 @@
+//
+//  SettingsManager.swift
+//
+
+import Combine
+import DolbyIORTSCore
+import Foundation
+
+public enum SettingsMode: Equatable {
+    case global
+    case stream(streamName: String, accountID: String)
+    
+    // Key against which `global settings` is stored in the `SettingsDictionary`
+    fileprivate static let keyGlobalStreamSettings = "global"
+
+    fileprivate var storageKey: String {
+        switch self {
+        case .global:
+            return Self.keyGlobalStreamSettings
+        case let .stream(streamName: streamName, accountID: accountID):
+            return "\(streamName)-\(accountID)"
+        }
+    }
+}
+
+final public class SettingsManager {
+
+    private enum Constants {
+        static let keyStreamSettingsDictionary = "stream-settings"
+    }
+    
+    private typealias SettingsDictionary = [String: StreamSettings]
+
+    @UserDefaultsCodableBacked(key: Constants.keyStreamSettingsDictionary, defaultValue: [SettingsMode.keyGlobalStreamSettings: StreamSettings.default])
+    private var settingsDictionary: SettingsDictionary
+    
+    public static let shared = SettingsManager()
+    
+    public func publisher(for mode: SettingsMode) -> AnyPublisher<StreamSettings, Never> {
+        $settingsDictionary
+            .map {
+                $0[mode.storageKey] ?? StreamSettings.default
+            }
+            .removeDuplicates()
+            .eraseToAnyPublisher()
+    }
+
+    public func removeSettings(for mode: SettingsMode) {
+        settingsDictionary.removeValue(forKey: mode.storageKey)
+    }
+    
+    func update(settings: StreamSettings, for mode: SettingsMode) {
+        settingsDictionary[mode.storageKey] = settings
+    }
+}

Sources/DolbyIORTSCore/Model/StreamSettings.swift

@@ -0,0 +1,42 @@
+//
+//  StreamSettings.swift
+//
+
+import Foundation
+import SwiftUI
+
+public struct StreamSettings: Codable, Equatable {
+
+    public enum MultiviewLayout: String, Codable, Equatable {
+        case list
+        case single
+        case grid
+    }
+
+    public enum StreamSortOrder: String, Codable, Equatable {
+        case connectionOrder
+        case alphaNumeric
+    }
+
+    public enum AudioSelection: Codable, Equatable {
+        case firstSource
+        case followVideo
+        case mainSource
+        case source(sourceId: String)
+    }
+
+    public var showSourceLabels: Bool
+    public var multiviewLayout: MultiviewLayout
+    public var streamSortOrder: StreamSortOrder
+    public var audioSelection: AudioSelection
+    public var audioSources: [String] = []
+}
+
+extension StreamSettings {
+    public static let `default`: StreamSettings = .init(
+        showSourceLabels: true,
+        multiviewLayout: .list,
+        streamSortOrder: .connectionOrder,
+        audioSelection: .firstSource
+    )
+}

Sources/DolbyIORTSUIKit/Private/Managers/SettingsManager.swift

@@ -0,0 +1,24 @@
+//
+//  UserDefaults+Codable.swift
+//
+
+import Foundation
+
+extension UserDefaults {
+    func registerCodableDefaults<T: Codable>(_ defaults: T, forKey defaultName: String) {
+        let encoded = try? JSONEncoder().encode(defaults)
+        register(defaults: [defaultName: (encoded ?? nil) as Any])
+    }
+    
+    func setCodableValue<T: Codable>(_ data: T?, forKey defaultName: String) {
+        let encoded = try? JSONEncoder().encode(data)
+        set(encoded, forKey: defaultName)
+    }
+    
+    func getCodableValue<T: Codable>(dataType: T.Type, key: String) -> T? {
+        guard let userDefaultData = data(forKey: key) else {
+            return nil
+        }
+        return try? JSONDecoder().decode(T.self, from: userDefaultData)
+    }
+}

Sources/DolbyIORTSUIKit/Private/Models/StreamSettings.swift

@@ -0,0 +1,97 @@
+//
+//  UserDefaultsBacked.swift
+//
+
+import Combine
+import Foundation
+
+@propertyWrapper
+struct UserDefaultsBacked<T> {
+    let key: String
+    let defaultValue: T
+    let userDefaults: UserDefaults
+    
+    private let publisher: CurrentValueSubject<T, Never>
+    
+    init(key: String, defaultValue: T, container: UserDefaults = .standard) {
+        self.key = key
+        self.defaultValue = defaultValue
+        self.userDefaults = container
+        self.publisher = .init(defaultValue)
+        
+        // Register default value
+        userDefaults.register(defaults: [key: defaultValue])
+        
+        defer {
+            self.publisher.send(wrappedValue)
+        }
+    }
+    
+    var wrappedValue: T {
+        get {
+            return userDefaults.object(forKey: key) as? T ?? defaultValue
+        }
+        set {
+            if let optional = newValue as? AnyOptional, optional.isNil {
+                userDefaults.removeObject(forKey: key)
+            } else {
+                userDefaults.set(newValue, forKey: key)
+            }
+            publisher.send(newValue)
+        }
+    }
+    
+    var projectedValue: AnyPublisher<T, Never> {
+        return publisher.eraseToAnyPublisher()
+    }
+}
+
+@propertyWrapper
+struct UserDefaultsCodableBacked<T: Codable> {
+    let key: String
+    let defaultValue: T
+    let userDefaults: UserDefaults
+    
+    private let publisher: CurrentValueSubject<T, Never>
+    
+    init(key: String, defaultValue: T, container: UserDefaults = .standard) {
+        self.key = key
+        self.defaultValue = defaultValue
+        self.userDefaults = container
+        self.publisher = .init(defaultValue)
+        
+        // Register default value
+        userDefaults.registerCodableDefaults(defaultValue, forKey: key)
+        
+        defer {
+            self.publisher.send(wrappedValue)
+        }
+    }
+    
+    var wrappedValue: T {
+        get {
+            return userDefaults.getCodableValue(dataType: T.self, key: key) ?? defaultValue
+        }
+        set {
+            if let optional = newValue as? AnyOptional, optional.isNil {
+                userDefaults.removeObject(forKey: key)
+            } else {
+                userDefaults.setCodableValue(newValue, forKey: key)
+            }
+            publisher.send(newValue)
+        }
+    }
+    
+    var projectedValue: AnyPublisher<T, Never> {
+        return publisher.eraseToAnyPublisher()
+    }
+}
+
+protocol AnyOptional {
+    var isNil: Bool { get }
+}
+
+extension Optional: AnyOptional {
+    var isNil: Bool { self == nil }
+}
+