import AVFoundation internal import Expo import React import ReactAppDependencyProvider import RNKeychain import RNNotifications import RNSentry import react_native_paste_input import mattermost_calls_native import mattermost_rnutils import mattermost_hardware_keyboard import TurboLogIOSNative import UIKit import UserNotifications import os.log #if canImport(MSAL) import MSAL #endif #if canImport(mattermost_intune) import mattermost_intune #endif private let notificationClearAction = "clear" private let notificationSessionAction = "session" private let notificationTestAction = "test" @main class AppDelegate: ExpoAppDelegate, OrientationLockable { @objc var orientationLock: UIInterfaceOrientationMask = .allButUpsideDown var window: UIWindow? var reactNativeDelegate: ExpoReactNativeFactoryDelegate? var reactNativeFactory: RCTReactNativeFactory? // Background-task assertion held across the background transition so any // in-flight WatermelonDB operation (read or write) can finish and release // the shared App Group SQLite lock before the OS suspends the app. Without // it, iOS terminates the app with RUNNINGBOARD 0xdead10cc when it suspends // while a SQLite statement still holds the lock. Only touched from main- // thread lifecycle callbacks and the (also main-thread) expiration handler. private var databaseLockBackgroundTask: UIBackgroundTaskIdentifier = .invalid override func application( _ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void ) { os_log("Mattermost will attach session from handleEventsForBackgroundURLSession!! identifier=%{public}@", identifier) GekidouWrapper.default.attachSession(identifier, completionHandler: completionHandler) os_log("Mattermost session ATTACHED from handleEventsForBackgroundURLSession!! identifier=%{public}@", identifier) } override func application( _ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil ) -> Bool { // Initialize Sentry early for native crash reporting (only when DSN is configured) if let optionsPath = Bundle.main.path(forResource: "sentry.options", ofType: "json"), let data = try? Data(contentsOf: URL(fileURLWithPath: optionsPath)), let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], let dsn = json["dsn"] as? String, !dsn.isEmpty { RNSentrySDK.start() } // Configure TurboLog if let appGroupId = Bundle.main.object(forInfoDictionaryKey: "AppGroupIdentifier") as? String, let containerURL = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupId) { let logsURL = containerURL.appendingPathComponent("Logs") do { try TurboLogger.configure( dailyRolling: false, maximumFileSize: 1024 * 1024, maximumNumberOfFiles: 2, logsDirectory: logsURL.path, logsFilename: "MMLogs" ) } catch { NSLog("Failed to configure TurboLog: %@", error.localizedDescription) } TurboLogger.write(level: .info, message: "Configured turbolog") } // Configure Gekidou to use TurboLog via wrapper GekidouWrapper.default.configureTurboLogForGekidou() // Bootstrap @mattermost/calls-native: allocates the singleton // PKPushRegistry + CXProvider on the main queue, synchronously, // before any VoIP push delegate can fire. CallsBridge.shared.bootstrap() #if canImport(mattermost_intune) // Initialize Intune MAM delegates BEFORE React Native IntuneAccess.initializeIntuneDelegates() #endif OrientationManager.shared.delegate = self // Clear keychain on first run in case of reinstallation if UserDefaults.standard.object(forKey: "FirstRun") == nil { let keychain = RNKeychainManager() if let servers = keychain.getAllServersForInternetPasswords() { TurboLogger.write(level: .info, message: "Servers \(servers)") for server in servers { keychain.deleteCredentials(forServer: server, withOptions: nil) } } UserDefaults.standard.set(true, forKey: "FirstRun") UserDefaults.standard.synchronize() } try? AVAudioSession.sharedInstance().setCategory(.playback) GekidouWrapper.default.setPreference("true", forKey: "ApplicationIsRunning") RNNotifications.startMonitorNotifications() let delegate = ReactNativeDelegate() let factory = ExpoReactNativeFactory(delegate: delegate) delegate.dependencyProvider = RCTAppDependencyProvider() reactNativeDelegate = delegate reactNativeFactory = factory #if os(iOS) || os(tvOS) window = UIWindow(frame: UIScreen.main.bounds) factory.startReactNative( withModuleName: "Mattermost", in: window, launchOptions: launchOptions ) #endif let result = super.application(application, didFinishLaunchingWithOptions: launchOptions) os_log("Mattermost started!!") if let factory = reactNativeFactory { PasteInputModule.setup(factory.rootViewFactory) } #if canImport(mattermost_intune) // Restore enrollments if needed (silent, non-blocking) IntuneAccess.checkAndRestoreEnrollmentOnLaunch() #endif return result } // MARK: - Remote Notifications override func application( _ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data ) { RNNotifications.didRegisterForRemoteNotifications(withDeviceToken: deviceToken) } override func application( _ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error ) { RNNotifications.didFailToRegisterForRemoteNotificationsWithError(error) } override func application( _ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void ) { let state = UIApplication.shared.applicationState let action = userInfo["type"] as? String let isClearAction = action == notificationClearAction let isTestAction = action == notificationTestAction let isSessionAction = action == notificationSessionAction if isTestAction { completionHandler(.noData) return } if !GekidouWrapper.default.verifySignature(userInfo) { var notification = userInfo notification["verified"] = "false" RNNotifications.didReceiveBackgroundNotification(notification, withCompletionHandler: completionHandler) return } if isClearAction { NotificationHelper.default.clearChannelOrThreadNotifications(userInfo: userInfo as NSDictionary) GekidouWrapper.default.postNotificationReceipt(userInfo) RNNotifications.didReceiveBackgroundNotification(userInfo, withCompletionHandler: completionHandler) return } if isSessionAction { GekidouWrapper.default.postNotificationReceipt(userInfo) RNNotifications.didReceiveBackgroundNotification(userInfo, withCompletionHandler: completionHandler) return } if state != .active { GekidouWrapper.default.fetchDataForPushNotification(userInfo) { data in var notification = userInfo if let data = data { do { if let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] { notification["data"] = json } else { TurboLogger.write(level: .warning, message: "Mattermost AppDelegate: JSON serialization returned nil without error") } } catch { TurboLogger.write(level: .error, message: "Mattermost AppDelegate: JSON serialization error \(error.localizedDescription)") } } RNNotifications.didReceiveBackgroundNotification(notification, withCompletionHandler: completionHandler) } } else { completionHandler(.newData) } } // MARK: - Deep Linking override func application( _ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:] ) -> Bool { if handleMSALURL(url) { return true } return RCTLinkingManager.application(app, open: url, options: options) } func application( _ application: UIApplication, open url: URL, sourceApplication: String?, annotation: Any ) -> Bool { if handleMSALURL(url) { return true } return RCTLinkingManager.application(application, open: url, sourceApplication: sourceApplication, annotation: annotation) } private func handleMSALURL(_ url: URL) -> Bool { #if canImport(MSAL) if let bundleId = Bundle.main.bundleIdentifier, url.absoluteString.hasPrefix("msauth.\(bundleId)") { TurboLogger.write(level: .info, message: "[Intune] MSAL URL handled") return MSALPublicClientApplication.handleMSALResponse(url, sourceApplication: nil) } #endif return false } override func application( _ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void ) -> Bool { return RCTLinkingManager.application(application, continue: userActivity, restorationHandler: restorationHandler) } // MARK: - App Lifecycle override func applicationDidBecomeActive(_ application: UIApplication) { super.applicationDidBecomeActive(application) GekidouWrapper.default.setPreference("true", forKey: "ApplicationIsForeground") endDatabaseLockProtection() } override func applicationWillResignActive(_ application: UIApplication) { super.applicationWillResignActive(application) GekidouWrapper.default.setPreference("false", forKey: "ApplicationIsForeground") } override func applicationDidEnterBackground(_ application: UIApplication) { super.applicationDidEnterBackground(application) GekidouWrapper.default.setPreference("false", forKey: "ApplicationIsForeground") beginDatabaseLockProtection() } override func applicationWillTerminate(_ application: UIApplication) { super.applicationWillTerminate(application) GekidouWrapper.default.setPreference("false", forKey: "ApplicationIsForeground") GekidouWrapper.default.setPreference("false", forKey: "ApplicationIsRunning") endDatabaseLockProtection() } // MARK: - Database lock protection (prevents RUNNINGBOARD 0xdead10cc) // Keeps the app from being suspended while a WatermelonDB statement still // holds the shared App Group SQLite lock. Begun when entering the // background; released when returning to the foreground or when the OS // background-execution time expires (whichever comes first), by which point // any in-flight DB read/write has finished and released the lock. private func beginDatabaseLockProtection() { guard databaseLockBackgroundTask == .invalid else { return } databaseLockBackgroundTask = UIApplication.shared.beginBackgroundTask(withName: "MMDatabaseLockProtection") { [weak self] in self?.endDatabaseLockProtection() } } private func endDatabaseLockProtection() { guard databaseLockBackgroundTask != .invalid else { return } UIApplication.shared.endBackgroundTask(databaseLockBackgroundTask) databaseLockBackgroundTask = .invalid } // MARK: - Orientation override func application( _ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow? ) -> UIInterfaceOrientationMask { return orientationLock } // MARK: - Hardware Keyboard override var keyCommands: [UIKeyCommand]? { return MattermostHardwareKeyboardWrapper.registerKeyCommands( enterPressed: #selector(sendEnter(_:)), shiftEnterPressed: #selector(sendShiftEnter(_:)), findChannels: #selector(sendFindChannels(_:)) ) as? [UIKeyCommand] } @objc private func sendEnter(_ sender: UIKeyCommand) { MattermostHardwareKeyboardWrapper.enterKeyPressed() } @objc private func sendShiftEnter(_ sender: UIKeyCommand) { MattermostHardwareKeyboardWrapper.shiftEnterKeyPressed() } @objc private func sendFindChannels(_ sender: UIKeyCommand) { MattermostHardwareKeyboardWrapper.findChannels() } } // MARK: - ReactNativeDelegate class ReactNativeDelegate: ExpoReactNativeFactoryDelegate { override func bundleURL() -> URL? { #if DEBUG return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index") #else return Bundle.main.url(forResource: "main", withExtension: "jsbundle") #endif } }