|
|
|
@ -1,122 +1,79 @@
|
|
|
|
// Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
// Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
|
|
|
|
|
|
|
|
import UIKit
|
|
|
|
import UIKit
|
|
|
|
|
|
|
|
import LocalAuthentication
|
|
|
|
import SessionUIKit
|
|
|
|
import SessionUIKit
|
|
|
|
import SessionMessagingKit
|
|
|
|
import SessionMessagingKit
|
|
|
|
import SessionUtilitiesKit
|
|
|
|
import SessionUtilitiesKit
|
|
|
|
import SignalUtilitiesKit
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ScreenLockUI {
|
|
|
|
// MARK: - Singleton
|
|
|
|
public static let shared: ScreenLockUI = ScreenLockUI()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private var dependencies: Dependencies?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public lazy var screenBlockingWindow: UIWindow = {
|
|
|
|
|
|
|
|
let result: UIWindow = UIWindow()
|
|
|
|
|
|
|
|
result.isHidden = false
|
|
|
|
|
|
|
|
result.windowLevel = .background
|
|
|
|
|
|
|
|
result.isOpaque = true
|
|
|
|
|
|
|
|
result.themeBackgroundColorForced = .theme(.classicDark, color: .backgroundPrimary)
|
|
|
|
|
|
|
|
result.rootViewController = self.screenBlockingViewController
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return result
|
|
|
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private lazy var screenBlockingViewController: ScreenLockViewController = {
|
|
|
|
|
|
|
|
let result: ScreenLockViewController = ScreenLockViewController { [weak self] in
|
|
|
|
|
|
|
|
guard self?.appIsInactiveOrBackground == false else {
|
|
|
|
|
|
|
|
// This button can be pressed while the app is inactive
|
|
|
|
|
|
|
|
// for a brief window while the iOS auth UI is dismissing.
|
|
|
|
|
|
|
|
return
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Log.info("unlockButtonWasTapped")
|
|
|
|
public extension Singleton {
|
|
|
|
|
|
|
|
static let screenLock: SingletonConfig<ScreenLockWindow> = Dependencies.create(
|
|
|
|
|
|
|
|
identifier: "screenLock",
|
|
|
|
|
|
|
|
createInstance: { dependencies in ScreenLockWindow(using: dependencies) }
|
|
|
|
|
|
|
|
)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
self?.didLastUnlockAttemptFail = false
|
|
|
|
/// Obscures the app screen:
|
|
|
|
self?.ensureUI()
|
|
|
|
///
|
|
|
|
}
|
|
|
|
/// * In the app switcher.
|
|
|
|
|
|
|
|
/// * During 'Screen Lock' unlock process.
|
|
|
|
return result
|
|
|
|
public class ScreenLockWindow {
|
|
|
|
}()
|
|
|
|
private let dependencies: Dependencies
|
|
|
|
|
|
|
|
|
|
|
|
/// Unlike UIApplication.applicationState, this state reflects the notifications, i.e. "did become active", "will resign active",
|
|
|
|
/// Indicates whether or not the user is currently locked out of the app. Should only be set if `db[.isScreenLockEnabled]`.
|
|
|
|
/// "will enter foreground", "did enter background".
|
|
|
|
|
|
|
|
///
|
|
|
|
|
|
|
|
/// We want to update our state to reflect these transitions and have the "update" logic be consistent with "last reported"
|
|
|
|
|
|
|
|
/// state. i.e. when you're responding to "will resign active", we need to behave as though we're already inactive.
|
|
|
|
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// Secondly, we need to show the screen protection _before_ we become inactive in order for it to be reflected in the
|
|
|
|
/// * The user is locked out by default on app launch.
|
|
|
|
/// app switcher.
|
|
|
|
/// * The user is also locked out if the app is sent to the background
|
|
|
|
private var appIsInactiveOrBackground: Bool = false {
|
|
|
|
@ThreadSafe private var isScreenLockLocked: Bool = false
|
|
|
|
didSet {
|
|
|
|
|
|
|
|
if self.appIsInactiveOrBackground {
|
|
|
|
|
|
|
|
if !self.isShowingScreenLockUI {
|
|
|
|
|
|
|
|
self.didLastUnlockAttemptFail = false
|
|
|
|
|
|
|
|
self.tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
else if !self.didUnlockJustSucceed {
|
|
|
|
|
|
|
|
self.tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
self.didUnlockJustSucceed = false
|
|
|
|
|
|
|
|
self.ensureUI()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
private var appIsInBackground: Bool = false {
|
|
|
|
|
|
|
|
didSet {
|
|
|
|
|
|
|
|
self.didUnlockJustSucceed = false
|
|
|
|
|
|
|
|
self.tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
|
|
|
|
self.ensureUI()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private var isShowingScreenLockUI: Bool = false
|
|
|
|
private var isShowingScreenLockUI: Bool = false
|
|
|
|
private var didUnlockJustSucceed: Bool = false
|
|
|
|
private var didUnlockJustSucceed: Bool = false
|
|
|
|
private var didLastUnlockAttemptFail: Bool = false
|
|
|
|
private var didLastUnlockAttemptFail: Bool = false
|
|
|
|
|
|
|
|
|
|
|
|
/// We want to remain in "screen lock" mode while "local auth" UI is dismissing. So we lazily clear isShowingScreenLockUI
|
|
|
|
/// We want to remain in "screen lock" mode while "local auth" UI is dismissing. So we lazily clear isShowingScreenLockUI
|
|
|
|
/// using this property.
|
|
|
|
/// using this property.
|
|
|
|
private var shouldClearAuthUIWhenActive: Bool = false
|
|
|
|
private var shouldClearAuthUIWhenActive: Bool = false
|
|
|
|
|
|
|
|
|
|
|
|
/// Indicates whether or not the user is currently locked out of the app. Should only be set if db[.isScreenLockEnabled].
|
|
|
|
|
|
|
|
///
|
|
|
|
|
|
|
|
/// * The user is locked out by default on app launch.
|
|
|
|
|
|
|
|
/// * The user is also locked out if the app is sent to the background
|
|
|
|
|
|
|
|
@ThreadSafe private var isScreenLockLocked: Bool = false
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Determines what the state of the app should be.
|
|
|
|
// MARK: - UI
|
|
|
|
private var desiredUIState: ScreenLockViewController.State {
|
|
|
|
|
|
|
|
if isScreenLockLocked {
|
|
|
|
public lazy var window: UIWindow = {
|
|
|
|
if appIsInactiveOrBackground {
|
|
|
|
let result: UIWindow = UIWindow()
|
|
|
|
Log.verbose("desiredUIState: screen protection 1.")
|
|
|
|
result.isHidden = false
|
|
|
|
return .protection
|
|
|
|
result.windowLevel = .background
|
|
|
|
}
|
|
|
|
result.isOpaque = true
|
|
|
|
|
|
|
|
result.themeBackgroundColorForced = .theme(.classicDark, color: .backgroundPrimary)
|
|
|
|
Log.verbose("desiredUIState: screen lock 2.")
|
|
|
|
result.rootViewController = self.viewController
|
|
|
|
return (isShowingScreenLockUI ? .protection : .lock)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if !self.appIsInactiveOrBackground {
|
|
|
|
|
|
|
|
// App is inactive or background.
|
|
|
|
|
|
|
|
Log.verbose("desiredUIState: none 3.");
|
|
|
|
|
|
|
|
return .none;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if SessionEnvironment.shared?.isRequestingPermission == true {
|
|
|
|
return result
|
|
|
|
return .none;
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private lazy var viewController: ScreenLockViewController = ScreenLockViewController { [weak self, dependencies] in
|
|
|
|
|
|
|
|
guard dependencies[singleton: .appContext].isAppForegroundAndActive else {
|
|
|
|
|
|
|
|
// This button can be pressed while the app is inactive
|
|
|
|
|
|
|
|
// for a brief window while the iOS auth UI is dismissing.
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Log.verbose("desiredUIState: screen protection 4.")
|
|
|
|
Log.info(.screenLock, "unlockButtonWasTapped")
|
|
|
|
return .protection;
|
|
|
|
|
|
|
|
|
|
|
|
self?.didLastUnlockAttemptFail = false
|
|
|
|
|
|
|
|
self?.ensureUI()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// MARK: - Lifecycle
|
|
|
|
// MARK: - Lifecycle
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
init(using dependencies: Dependencies) {
|
|
|
|
|
|
|
|
self.dependencies = dependencies
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
deinit {
|
|
|
|
deinit {
|
|
|
|
NotificationCenter.default.removeObserver(self)
|
|
|
|
NotificationCenter.default.removeObserver(self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// MARK: - Observations
|
|
|
|
|
|
|
|
|
|
|
|
private func observeNotifications() {
|
|
|
|
private func observeNotifications() {
|
|
|
|
NotificationCenter.default.addObserver(
|
|
|
|
NotificationCenter.default.addObserver(
|
|
|
|
self,
|
|
|
|
self,
|
|
|
|
@ -150,56 +107,72 @@ class ScreenLockUI {
|
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public func setupWithRootWindow(rootWindow: UIWindow, using dependencies: Dependencies) {
|
|
|
|
public func setupWithRootWindow(rootWindow: UIWindow) {
|
|
|
|
self.dependencies = dependencies
|
|
|
|
self.window.frame = rootWindow.bounds
|
|
|
|
self.screenBlockingWindow.frame = rootWindow.bounds
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public func startObserving() {
|
|
|
|
|
|
|
|
self.appIsInactiveOrBackground = (UIApplication.shared.applicationState != .active)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
self.observeNotifications()
|
|
|
|
self.observeNotifications()
|
|
|
|
|
|
|
|
|
|
|
|
// Hide the screen blocking window until "app is ready" to
|
|
|
|
/// Hide the screen blocking window until "app is ready" to avoid blocking the loading view
|
|
|
|
// avoid blocking the loading view.
|
|
|
|
|
|
|
|
updateScreenBlockingWindow(state: .none, animated: false)
|
|
|
|
updateScreenBlockingWindow(state: .none, animated: false)
|
|
|
|
|
|
|
|
|
|
|
|
// Initialize the screen lock state.
|
|
|
|
/// Initialize the screen lock state.
|
|
|
|
//
|
|
|
|
///
|
|
|
|
// It's not safe to access OWSScreenLock.isScreenLockEnabled
|
|
|
|
/// It's not safe to access `isScreenLockEnabled` in `storage` until the app is ready
|
|
|
|
// until the app is ready.
|
|
|
|
dependencies[singleton: .appReadiness].runNowOrWhenAppWillBecomeReady { [weak self, dependencies] in
|
|
|
|
dependencies?[singleton: .appReadiness].runNowOrWhenAppWillBecomeReady { [weak self, dependencies] in
|
|
|
|
self?.isScreenLockLocked = (dependencies[singleton: .storage, key: .isScreenLockEnabled] == true)
|
|
|
|
DispatchQueue.global(qos: .background).async {
|
|
|
|
|
|
|
|
self?.isScreenLockLocked = (dependencies?[singleton: .storage, key: .isScreenLockEnabled] == true)
|
|
|
|
switch Thread.isMainThread {
|
|
|
|
|
|
|
|
case true: self?.ensureUI()
|
|
|
|
DispatchQueue.main.async {
|
|
|
|
case false: DispatchQueue.main.async { self?.ensureUI() }
|
|
|
|
self?.ensureUI()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// MARK: - Functions
|
|
|
|
// MARK: - Functions
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private func determineDesiredUIState() -> ScreenLockViewController.State {
|
|
|
|
|
|
|
|
if isScreenLockLocked {
|
|
|
|
|
|
|
|
if dependencies[singleton: .appContext].isNotInForeground {
|
|
|
|
|
|
|
|
Log.verbose(.screenLock, "App not in foreground, desiredUIState is: protection.")
|
|
|
|
|
|
|
|
return .protection
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Log.verbose(.screenLock, "App in foreground and locked, desiredUIState is: \(isShowingScreenLockUI ? "protection" : "lock").")
|
|
|
|
|
|
|
|
return (isShowingScreenLockUI ? .protection : .lock)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if dependencies[singleton: .appContext].isAppForegroundAndActive {
|
|
|
|
|
|
|
|
// App is inactive or background.
|
|
|
|
|
|
|
|
Log.verbose(.screenLock, "App in foreground and not locked, desiredUIState is: none.")
|
|
|
|
|
|
|
|
return .none;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if SessionEnvironment.shared?.isRequestingPermission == true {
|
|
|
|
|
|
|
|
Log.verbose(.screenLock, "App requesting permissions and not locked, desiredUIState is: none.")
|
|
|
|
|
|
|
|
return .none;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Log.verbose(.screenLock, "desiredUIState is: protection.")
|
|
|
|
|
|
|
|
return .protection;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private func tryToActivateScreenLockBasedOnCountdown() {
|
|
|
|
private func tryToActivateScreenLockBasedOnCountdown() {
|
|
|
|
guard dependencies?[singleton: .appReadiness].isAppReady == true else {
|
|
|
|
guard dependencies[singleton: .appReadiness].isAppReady else {
|
|
|
|
// It's not safe to access OWSScreenLock.isScreenLockEnabled
|
|
|
|
/// It's not safe to access `isScreenLockEnabled` in `storage` until the app is ready
|
|
|
|
// until the app is ready.
|
|
|
|
///
|
|
|
|
//
|
|
|
|
/// We don't need to try to lock the screen lock;
|
|
|
|
// We don't need to try to lock the screen lock;
|
|
|
|
/// It will be initialized by `setupWithRootWindow`
|
|
|
|
// It will be initialized by `setupWithRootWindow`.
|
|
|
|
Log.verbose(.screenLock, "tryToActivateScreenLockUponBecomingActive NO 0")
|
|
|
|
Log.verbose("tryToActivateScreenLockUponBecomingActive NO 0")
|
|
|
|
|
|
|
|
return
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
guard dependencies?[singleton: .storage, key: .isScreenLockEnabled] == true else {
|
|
|
|
guard dependencies[singleton: .storage, key: .isScreenLockEnabled] else {
|
|
|
|
// Screen lock is not enabled.
|
|
|
|
/// Screen lock is not enabled.
|
|
|
|
Log.verbose("tryToActivateScreenLockUponBecomingActive NO 1")
|
|
|
|
Log.verbose(.screenLock, "tryToActivateScreenLockUponBecomingActive NO 1")
|
|
|
|
return;
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
guard !isScreenLockLocked else {
|
|
|
|
guard !isScreenLockLocked else {
|
|
|
|
// Screen lock is already activated.
|
|
|
|
/// Screen lock is already activated.
|
|
|
|
Log.verbose("tryToActivateScreenLockUponBecomingActive NO 2")
|
|
|
|
Log.verbose(.screenLock, "tryToActivateScreenLockUponBecomingActive NO 2")
|
|
|
|
return;
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
self.isScreenLockLocked = true
|
|
|
|
self.isScreenLockLocked = true
|
|
|
|
@ -210,49 +183,52 @@ class ScreenLockUI {
|
|
|
|
/// * The blocking window has the correct state.
|
|
|
|
/// * The blocking window has the correct state.
|
|
|
|
/// * That we show the "iOS auth UI to unlock" if necessary.
|
|
|
|
/// * That we show the "iOS auth UI to unlock" if necessary.
|
|
|
|
private func ensureUI() {
|
|
|
|
private func ensureUI() {
|
|
|
|
guard dependencies?[singleton: .appReadiness].isAppReady == true else {
|
|
|
|
guard dependencies[singleton: .appReadiness].isAppReady else {
|
|
|
|
dependencies?[singleton: .appReadiness].runNowOrWhenAppWillBecomeReady { [weak self] in
|
|
|
|
dependencies[singleton: .appReadiness].runNowOrWhenAppWillBecomeReady { [weak self] in
|
|
|
|
self?.ensureUI()
|
|
|
|
self?.ensureUI()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let desiredUIState: ScreenLockViewController.State = self.desiredUIState
|
|
|
|
let desiredUIState: ScreenLockViewController.State = determineDesiredUIState()
|
|
|
|
Log.verbose("ensureUI: \(desiredUIState)")
|
|
|
|
Log.verbose(.screenLock, "ensureUI: \(desiredUIState)")
|
|
|
|
|
|
|
|
|
|
|
|
// Show the "iOS auth UI to unlock" if necessary.
|
|
|
|
/// Show the "iOS auth UI to unlock" if necessary.
|
|
|
|
if desiredUIState == .lock && !didLastUnlockAttemptFail {
|
|
|
|
if desiredUIState == .lock && !didLastUnlockAttemptFail {
|
|
|
|
tryToPresentAuthUIToUnlockScreenLock()
|
|
|
|
tryToPresentAuthUIToUnlockScreenLock()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Note: We want to regenerate the 'desiredUIState' as if we are about to show the
|
|
|
|
/// Note: We want to regenerate the `desiredUIState` as if we are about to show the "unlock screen" UI then we
|
|
|
|
// 'unlock screen' UI then we shouldn't show the "unlock" button
|
|
|
|
/// shouldn't show the "unlock" button
|
|
|
|
updateScreenBlockingWindow(state: self.desiredUIState, animated: true)
|
|
|
|
updateScreenBlockingWindow(state: determineDesiredUIState(), animated: true)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private func tryToPresentAuthUIToUnlockScreenLock() {
|
|
|
|
private func tryToPresentAuthUIToUnlockScreenLock() {
|
|
|
|
guard !isShowingScreenLockUI else { return } // We're already showing the auth UI; abort
|
|
|
|
/// If we're already showing the auth UI; or the app isn't active then don't do anything
|
|
|
|
guard !appIsInactiveOrBackground else { return } // Never show the auth UI unless active
|
|
|
|
guard
|
|
|
|
|
|
|
|
!isShowingScreenLockUI,
|
|
|
|
|
|
|
|
dependencies[singleton: .appContext].isAppForegroundAndActive
|
|
|
|
|
|
|
|
else { return }
|
|
|
|
|
|
|
|
|
|
|
|
Log.info("try to unlock screen lock")
|
|
|
|
Log.info(.screenLock, "Try to unlock screen lock")
|
|
|
|
isShowingScreenLockUI = true
|
|
|
|
isShowingScreenLockUI = true
|
|
|
|
|
|
|
|
|
|
|
|
ScreenLock.shared.tryToUnlockScreenLock(
|
|
|
|
ScreenLock.tryToUnlockScreenLock(
|
|
|
|
success: { [weak self] in
|
|
|
|
success: { [weak self] in
|
|
|
|
Log.info("unlock screen lock succeeded.")
|
|
|
|
Log.info(.screenLock, "Unlock screen lock succeeded")
|
|
|
|
self?.isShowingScreenLockUI = false
|
|
|
|
self?.isShowingScreenLockUI = false
|
|
|
|
self?.isScreenLockLocked = false
|
|
|
|
self?.isScreenLockLocked = false
|
|
|
|
self?.didUnlockJustSucceed = true
|
|
|
|
self?.didUnlockJustSucceed = true
|
|
|
|
self?.ensureUI()
|
|
|
|
self?.ensureUI()
|
|
|
|
},
|
|
|
|
},
|
|
|
|
failure: { [weak self] error in
|
|
|
|
failure: { [weak self] error in
|
|
|
|
Log.info("unlock screen lock failed.")
|
|
|
|
Log.info(.screenLock, "Unlock screen lock failed")
|
|
|
|
self?.clearAuthUIWhenActive()
|
|
|
|
self?.clearAuthUIWhenActive()
|
|
|
|
self?.didLastUnlockAttemptFail = true
|
|
|
|
self?.didLastUnlockAttemptFail = true
|
|
|
|
self?.showScreenLockFailureAlert(message: "\(error)")
|
|
|
|
self?.showScreenLockFailureAlert(message: "\(error)")
|
|
|
|
},
|
|
|
|
},
|
|
|
|
unexpectedFailure: { [weak self] error in
|
|
|
|
unexpectedFailure: { [weak self] error in
|
|
|
|
Log.info("unlock screen lock unexpectedly failed.")
|
|
|
|
Log.warn(.screenLock, "Unlock screen lock unexpectedly failed")
|
|
|
|
|
|
|
|
|
|
|
|
// Local Authentication isn't working properly.
|
|
|
|
// Local Authentication isn't working properly.
|
|
|
|
// This isn't covered by the docs or the forums but in practice
|
|
|
|
// This isn't covered by the docs or the forums but in practice
|
|
|
|
@ -262,7 +238,7 @@ class ScreenLockUI {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
},
|
|
|
|
cancel: { [weak self] in
|
|
|
|
cancel: { [weak self] in
|
|
|
|
Log.info("unlock screen lock cancelled.")
|
|
|
|
Log.info(.screenLock, "Unlock screen lock cancelled")
|
|
|
|
|
|
|
|
|
|
|
|
self?.clearAuthUIWhenActive()
|
|
|
|
self?.clearAuthUIWhenActive()
|
|
|
|
self?.didLastUnlockAttemptFail = true
|
|
|
|
self?.didLastUnlockAttemptFail = true
|
|
|
|
@ -277,7 +253,7 @@ class ScreenLockUI {
|
|
|
|
|
|
|
|
|
|
|
|
private func showScreenLockFailureAlert(message: String) {
|
|
|
|
private func showScreenLockFailureAlert(message: String) {
|
|
|
|
let modal: ConfirmationModal = ConfirmationModal(
|
|
|
|
let modal: ConfirmationModal = ConfirmationModal(
|
|
|
|
targetView: screenBlockingWindow.rootViewController?.view,
|
|
|
|
targetView: viewController.view,
|
|
|
|
info: ConfirmationModal.Info(
|
|
|
|
info: ConfirmationModal.Info(
|
|
|
|
title: "authenticateFailed".localized(),
|
|
|
|
title: "authenticateFailed".localized(),
|
|
|
|
body: .text(message),
|
|
|
|
body: .text(message),
|
|
|
|
@ -286,36 +262,7 @@ class ScreenLockUI {
|
|
|
|
afterClosed: { [weak self] in self?.ensureUI() } // After the alert, update the UI
|
|
|
|
afterClosed: { [weak self] in self?.ensureUI() } // After the alert, update the UI
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
screenBlockingWindow.rootViewController?.present(modal, animated: true)
|
|
|
|
viewController.present(modal, animated: true)
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// 'Screen Blocking' window obscures the app screen:
|
|
|
|
|
|
|
|
///
|
|
|
|
|
|
|
|
/// * In the app switcher.
|
|
|
|
|
|
|
|
/// * During 'Screen Lock' unlock process.
|
|
|
|
|
|
|
|
private func createScreenBlockingWindow(rootWindow: UIWindow) {
|
|
|
|
|
|
|
|
let window: UIWindow = UIWindow(frame: rootWindow.bounds)
|
|
|
|
|
|
|
|
window.isHidden = false
|
|
|
|
|
|
|
|
window.windowLevel = .background
|
|
|
|
|
|
|
|
window.isOpaque = true
|
|
|
|
|
|
|
|
window.themeBackgroundColorForced = .theme(.classicDark, color: .backgroundPrimary)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let viewController: ScreenLockViewController = ScreenLockViewController { [weak self] in
|
|
|
|
|
|
|
|
guard self?.appIsInactiveOrBackground == false else {
|
|
|
|
|
|
|
|
// This button can be pressed while the app is inactive
|
|
|
|
|
|
|
|
// for a brief window while the iOS auth UI is dismissing.
|
|
|
|
|
|
|
|
return
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Log.info("unlockButtonWasTapped")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
self?.didLastUnlockAttemptFail = false
|
|
|
|
|
|
|
|
self?.ensureUI()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
window.rootViewController = viewController
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
self.screenBlockingWindow = window
|
|
|
|
|
|
|
|
self.screenBlockingViewController = viewController
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The "screen blocking" window has three possible states:
|
|
|
|
/// The "screen blocking" window has three possible states:
|
|
|
|
@ -327,7 +274,7 @@ class ScreenLockUI {
|
|
|
|
let shouldShowBlockWindow: Bool = (state != .none)
|
|
|
|
let shouldShowBlockWindow: Bool = (state != .none)
|
|
|
|
|
|
|
|
|
|
|
|
OWSWindowManager.shared().isScreenBlockActive = shouldShowBlockWindow
|
|
|
|
OWSWindowManager.shared().isScreenBlockActive = shouldShowBlockWindow
|
|
|
|
self.screenBlockingViewController.updateUI(state: state, animated: animated)
|
|
|
|
self.viewController.updateUI(state: state, animated: animated)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// MARK: - Events
|
|
|
|
// MARK: - Events
|
|
|
|
@ -335,7 +282,7 @@ class ScreenLockUI {
|
|
|
|
private func clearAuthUIWhenActive() {
|
|
|
|
private func clearAuthUIWhenActive() {
|
|
|
|
// For continuity, continue to present blocking screen in "screen lock" mode while
|
|
|
|
// For continuity, continue to present blocking screen in "screen lock" mode while
|
|
|
|
// dismissing the "local auth UI".
|
|
|
|
// dismissing the "local auth UI".
|
|
|
|
if self.appIsInactiveOrBackground {
|
|
|
|
if !dependencies[singleton: .appContext].isAppForegroundAndActive {
|
|
|
|
self.shouldClearAuthUIWhenActive = true
|
|
|
|
self.shouldClearAuthUIWhenActive = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
else {
|
|
|
|
@ -345,42 +292,61 @@ class ScreenLockUI {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@objc private func applicationDidBecomeActive() {
|
|
|
|
@objc private func applicationDidBecomeActive() {
|
|
|
|
if self.shouldClearAuthUIWhenActive {
|
|
|
|
if shouldClearAuthUIWhenActive {
|
|
|
|
self.shouldClearAuthUIWhenActive = false
|
|
|
|
shouldClearAuthUIWhenActive = false
|
|
|
|
self.isShowingScreenLockUI = false
|
|
|
|
isShowingScreenLockUI = false
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if !didUnlockJustSucceed {
|
|
|
|
|
|
|
|
tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
self.appIsInactiveOrBackground = false
|
|
|
|
didUnlockJustSucceed = false
|
|
|
|
|
|
|
|
ensureUI()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// When the OS shows the TouchID/FaceID/Pin UI the application will resign active (and we don't want to re-authenticate if we are
|
|
|
|
|
|
|
|
/// already locked)
|
|
|
|
|
|
|
|
///
|
|
|
|
|
|
|
|
/// Secondly, we need to show the screen protection _before_ we become inactive in order for it to be reflected in the app switcher
|
|
|
|
@objc private func applicationWillResignActive() {
|
|
|
|
@objc private func applicationWillResignActive() {
|
|
|
|
self.appIsInactiveOrBackground = true
|
|
|
|
if !isShowingScreenLockUI {
|
|
|
|
|
|
|
|
didLastUnlockAttemptFail = false
|
|
|
|
|
|
|
|
tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
didUnlockJustSucceed = false
|
|
|
|
|
|
|
|
ensureUI()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@objc private func applicationWillEnterForeground() {
|
|
|
|
@objc private func applicationWillEnterForeground() {
|
|
|
|
self.appIsInBackground = false
|
|
|
|
didUnlockJustSucceed = false
|
|
|
|
|
|
|
|
tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
|
|
|
|
ensureUI()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@objc private func applicationDidEnterBackground() {
|
|
|
|
@objc private func applicationDidEnterBackground() {
|
|
|
|
self.appIsInBackground = true
|
|
|
|
didUnlockJustSucceed = false
|
|
|
|
|
|
|
|
tryToActivateScreenLockBasedOnCountdown()
|
|
|
|
|
|
|
|
ensureUI()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Whenever the device date/time is edited by the user, trigger screen lock immediately if enabled.
|
|
|
|
/// Whenever the device date/time is edited by the user, trigger screen lock immediately if enabled.
|
|
|
|
@objc private func clockDidChange() {
|
|
|
|
@objc private func clockDidChange() {
|
|
|
|
Log.info("clock did change")
|
|
|
|
Log.info(.screenLock, "clock did change")
|
|
|
|
|
|
|
|
|
|
|
|
guard dependencies?[singleton: .appReadiness].isAppReady == true else {
|
|
|
|
guard dependencies[singleton: .appReadiness].isAppReady == true else {
|
|
|
|
// It's not safe to access OWSScreenLock.isScreenLockEnabled
|
|
|
|
// It's not safe to access OWSScreenLock.isScreenLockEnabled
|
|
|
|
// until the app is ready.
|
|
|
|
// until the app is ready.
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// We don't need to try to lock the screen lock;
|
|
|
|
// We don't need to try to lock the screen lock;
|
|
|
|
// It will be initialized by `setupWithRootWindow`.
|
|
|
|
// It will be initialized by `setupWithRootWindow`.
|
|
|
|
Log.verbose("clockDidChange 0")
|
|
|
|
Log.verbose(.screenLock, "clockDidChange 0")
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
DispatchQueue.global(qos: .background).async { [dependencies] in
|
|
|
|
DispatchQueue.global(qos: .background).async { [dependencies] in
|
|
|
|
self.isScreenLockLocked = (dependencies?[singleton: .storage, key: .isScreenLockEnabled] == true)
|
|
|
|
self.isScreenLockLocked = (dependencies[singleton: .storage, key: .isScreenLockEnabled] == true)
|
|
|
|
|
|
|
|
|
|
|
|
DispatchQueue.main.async {
|
|
|
|
DispatchQueue.main.async {
|
|
|
|
// NOTE: this notifications fires _before_ applicationDidBecomeActive,
|
|
|
|
// NOTE: this notifications fires _before_ applicationDidBecomeActive,
|
Morgan Pretty
2 months ago
committed by
GitHub