如何检测 iPhone 上的屏幕锁定/解锁事件？

Question

如何检测 iPhone 上的屏幕锁定/解锁事件？当用户解锁时，我想显示来自我的 iPhone 应用程序的通知警报。 （就像 Android 中用于屏幕解锁的广播接收器一样。）

Answer 1

看看这个，我想检测锁定/解锁事件，我通过达尔文通知解决了它。
您可以通过“com.apple.springboard.lockcomplete”检测设备锁定时的事件。

//call back
static void displayStatusChanged(CFNotificationCenterRef center, void *observer, CFStringRef name, const void *object, CFDictionaryRef userInfo)
{
    // the "com.apple.springboard.lockcomplete" notification will always come after the "com.apple.springboard.lockstate" notification

    NSString *lockState = (NSString*)name;
    NSLog(@"Darwin notification NAME = %@",name);

    if([lockState isEqualToString:@"com.apple.springboard.lockcomplete"])
    {
        NSLog(@"DEVICE LOCKED");
    }
    else
    {
        NSLog(@"LOCK STATUS CHANGED");
    }   
}


-(void)registerforDeviceLockNotif
{
    //Screen lock notifications
    CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(), //center
                                    NULL, // observer
                                    displayStatusChanged, // callback
                                    CFSTR("com.apple.springboard.lockcomplete"), // event name
                                    NULL, // object
                                    CFNotificationSuspensionBehaviorDeliverImmediately);

    CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(), //center
                                    NULL, // observer
                                    displayStatusChanged, // callback
                                    CFSTR("com.apple.springboard.lockstate"), // event name
                                    NULL, // object
                                    CFNotificationSuspensionBehaviorDeliverImmediately);  
}   

Answer 2

要在 swift 5 中检测应用程序内部的锁定/解锁，只有这对我有用：

override func viewDidLoad() {
    super.viewDidLoad()

     NotificationCenter.default.addObserver(self, selector: #selector(applicationDidBecomeActive), name: UIApplication.willEnterForegroundNotification, object: nil)
     NotificationCenter.default.addObserver(self, selector: #selector(applicationDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
}

@objc func applicationDidBecomeActive(notification: NSNotification) {
    print("ACTIVE")
}
@objc func applicationDidEnterBackground(notification: NSNotification) {
    print("BACKGROUND")
}

Answer 3

1. 向 App Store 提交应用时，不能使用 com.apple.springboard.lockcomplete 或 com.apple.springboard.lockstate，您的应用将被拒绝因为它是私有 API。

2. com.apple.springboard.lockcomplete 通知并不总是在 com.apple.springboard.lockstate 通知之后出现，它可能会提前或稍后发生。您需要设置一个计时器来等待该事件。

以下是在 Swift 5 中检测屏幕锁定和解锁状态的方法：

struct NotificationName {
    // Listen to CFNotification, and convert to Notification
    public static let lockComplete = Notification.Name("NotificationName.lockComplete")
    public static let lockState = Notification.Name("NotificationName.lockState")

    // Handle lockComplete and lockState Notification to post locked or unlocked notification.
    public static let locked = Notification.Name("NotificationName.locked")
    public static let unlocked = Notification.Name("NotificationName.unlocked")
}

func addNotificationObservers() {
    let lockCompleteString = "com.apple.springboard.lockcomplete"
    let lockString = "com.apple.springboard.lockstate"

    // Listen to CFNotification, post Notification accordingly.
    CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(),
                                    nil,
                                    { (_, _, _, _, _) in
                                        NotificationCenter.default.post(name: NotificationName.lockComplete, object: nil)
                                    },
                                    lockCompleteString as CFString,
                                    nil,
                                    CFNotificationSuspensionBehavior.deliverImmediately)

    CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(),
                                    nil,
                                    { (_, _, _, _, _) in
                                        NotificationCenter.default.post(name: NotificationName.lockState, object: nil)
                                    },
                                    lockString as CFString,
                                    nil,
                                    CFNotificationSuspensionBehavior.deliverImmediately)

    // Listen to Notification and handle.
    NotificationCenter.default.addObserver(self,
                                            selector: #selector(onLockComplete),
                                            name: NotificationName.lockComplete,
                                            object: nil)

    NotificationCenter.default.addObserver(self,
                                            selector: #selector(onLockState),
                                            name: NotificationName.lockState,
                                            object: nil)
}

// nil means don't know; ture or false means we did or did not received such notification.
var receiveLockStateNotification: Bool? = nil
// when we received lockState notification, use timer to wait 0.3s for the lockComplete notification.
var waitForLockCompleteNotificationTimer: Timer? = nil
var receiveLockCompleteNotification: Bool? = nil

// When we received lockComplete notification, invalidate timer and refresh lock status.
@objc
func onLockComplete() {
    if let timer = waitForLockCompleteNotificationTimer {
        timer.invalidate()
        waitForLockCompleteNotificationTimer = nil
    }

    receiveLockCompleteNotification = true
    changeIsLockedIfNeeded()
}

// When we received lockState notification, refresh lock status.
@objc
func onLockState() {
    receiveLockStateNotification = true
    changeIsLockedIfNeeded()
}

func changeIsLockedIfNeeded() {
    guard let state = receiveLockStateNotification, state else {
        // If we don't receive lockState notification, return.
        return
    }

    guard let complete = receiveLockCompleteNotification else {
        // If we don't receive lockComplete notification, wait 0.3s.
        // If nothing happens in 0.3s, then make sure we don't receive lockComplete, and refresh lock status.
        waitForLockCompleteNotificationTimer = Timer.scheduledTimer(withTimeInterval: 0.3, repeats: false, block: { _ in
            self.receiveLockCompleteNotification = false
            self.changeIsLockedIfNeeded()
        })
        return
    }

    // When we determined lockState and lockComplete notification is received or not.
    // We can update the device lock status by 'complete' value.
    NotificationCenter.default.post(
        name: complete ? NotificationName.locked : NotificationName.unlocked,
        object: nil
    )

    // Reset status.
    receiveLockStateNotification = nil
    receiveLockCompleteNotification = nil
}

Answer 4

可能您需要在 AppDelegate 中实现以下方法：

告诉代理应用程序现在位于后台。

- (void)applicationDidEnterBackground:(UIApplication *)application

告诉代理应用程序已变为活动状态。

- (void)applicationDidBecomeActive:(UIApplication *)application

告诉代理应用程序即将变为非活动状态。

- (void)applicationWillResignActive:(UIApplication *)application

Answer 5

实际上我想要的是如果我退出应用程序并锁定iPhone，
一段时间后我解锁了 iPhone，然后退出应用程序
显示通知或提醒启动应用程序。

您无法在 iPhone 上执行此操作。

Answer 6

最初的问题已经很老了，所以对于任何偶然发现这个问题的人来说：

在具有 Face ID 和 Touch ID 的现代设备上，您可以使用 AppDelegate 方法 applicationProtectedDataDidBecomeAvailable(_:) (docs）和 applicationProtectedDataWillBecomeUnavailable(_:) (文档）。

当设备存储被解密或加密时，将调用这些函数。它们的目的是让应用程序知道何时可以读取存储中的数据或何时变得不可用。但是，由于当今几乎所有 iPhone 上都启用了设备加密，因此您还可以使用它们来检测屏幕锁定和解锁事件。

但是，这当然只有在您的应用程序正在运行时才有效。

Answer 7

从当前视图控制器中，您应该为 UIApplicationDidEnterBackgroundNotification 添加一个观察者，并在关闭视图控制器期间删除观察者
[[NSNotificationCenter defaultCenter] addObserver:self 选择器:@selector(didEnterBackground) name:UIApplicationDidEnterBackgroundNotification object:nil];