Определение настроек записи экрана в macOS Catalina

Apple предоставляет прямой низкоуровневый API для проверки доступа и предоставления доступа. Не нужно использовать хитрые обходные пути.

/* Checks whether the current process already has screen capture access */
@available(macOS 10.15, *)
public func CGPreflightScreenCaptureAccess() -> Bool

Используйте указанные выше функции, чтобы проверить доступ к захвату экрана.

если доступ не предоставлен, используйте функцию ниже, чтобы запросить доступ

/* Requests event listening access if absent, potentially prompting */
@available(macOS 10.15, *)
public func CGRequestScreenCaptureAccess() -> Bool

Снимок экрана взят из документации

Все представленные здесь решения так или иначе имеют изъяны. Корень проблемы в том, что нет корреляции между вашим разрешением знать об окне (через имя в списке окон), вашим разрешением знать о процессе-владельце окна (например, WindowServer и Dock). Ваше разрешение на просмотр пикселей на экране - это комбинация двух разреженных наборов информации.

Вот эвристика, которая охватывает все случаи начиная с macOS 10.15.1:

BOOL canRecordScreen = YES;
if (@available(macOS 10.15, *)) {
    canRecordScreen = NO;
    NSRunningApplication *runningApplication = NSRunningApplication.currentApplication;
    NSNumber *ourProcessIdentifier = [NSNumber numberWithInteger:runningApplication.processIdentifier];

    CFArrayRef windowList = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
    NSUInteger numberOfWindows = CFArrayGetCount(windowList);
    for (int index = 0; index < numberOfWindows; index++) {
        // get information for each window
        NSDictionary *windowInfo = (NSDictionary *)CFArrayGetValueAtIndex(windowList, index);
        NSString *windowName = windowInfo[(id)kCGWindowName];
        NSNumber *processIdentifier = windowInfo[(id)kCGWindowOwnerPID];

        // don't check windows owned by this process
        if (! [processIdentifier isEqual:ourProcessIdentifier]) {
            // get process information for each window
            pid_t pid = processIdentifier.intValue;
            NSRunningApplication *windowRunningApplication = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
            if (! windowRunningApplication) {
                // ignore processes we don't have access to, such as WindowServer, which manages the windows named "Menubar" and "Backstop Menubar"
            }
            else {
                NSString *windowExecutableName = windowRunningApplication.executableURL.lastPathComponent;
                if (windowName) {
                    if ([windowExecutableName isEqual:@"Dock"]) {
                        // ignore the Dock, which provides the desktop picture
                    }
                    else {
                        canRecordScreen = YES;
                        break;
                    }
                }
            }
        }
    }
    CFRelease(windowList);
}

Если canRecordScreen не установлен, вам нужно будет создать своего рода диалоговое окно, предупреждающее пользователя о том, что он сможет видеть только строку меню, изображение рабочего стола и собственные окна приложения. Вот как мы представили это в нашем приложении xScope.

И да, мне все еще горько, что эти средства защиты были введены с незначительным вниманием к удобству использования.

@ marek-h опубликовал хороший пример, который может определять настройку записи экрана без отображения предупреждения о конфиденциальности. Кстати, @ jordan-h упомянул, что это решение не работает, когда приложение выдает предупреждение через beginSheetModalForWindow.

Я обнаружил, что процесс SystemUIServer всегда создает окна с именами: AppleVolumeExtra, AppleClockExtra, AppleBluetoothExtra ...

Мы не можем получить имена этих окон, пока запись экрана не будет включена в настройках конфиденциальности. И когда мы можем получить хотя бы одно из этих имен, это означает, что пользователь включил запись экрана.

Таким образом, мы можем проверить имена окон (созданных процессом SystemUIServer), чтобы определить предпочтение записи экрана, и оно отлично работает в macOS Catalina.

#include <AppKit/AppKit.h>
#include <libproc.h>

bool isScreenRecordingEnabled()
{
    if (@available(macos 10.15, *)) {
        bool bRet = false;
        CFArrayRef list = CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
        if (list) {
            int n = (int)(CFArrayGetCount(list));
            for (int i = 0; i < n; i++) {
                NSDictionary* info = (NSDictionary*)(CFArrayGetValueAtIndex(list, (CFIndex)i));
                NSString* name = info[(id)kCGWindowName];
                NSNumber* pid = info[(id)kCGWindowOwnerPID];
                if (pid != nil && name != nil) {
                    int nPid = [pid intValue];
                    char path[PROC_PIDPATHINFO_MAXSIZE+1];
                    int lenPath = proc_pidpath(nPid, path, PROC_PIDPATHINFO_MAXSIZE);
                    if (lenPath > 0) {
                        path[lenPath] = 0;
                        if (strcmp(path, "/System/Library/CoreServices/SystemUIServer.app/Contents/MacOS/SystemUIServer") == 0) {
                            bRet = true;
                            break;
                        }
                    }
                }
            }
            CFRelease(list);
        }
        return bRet;
    } else {
        return true;
    }
}

Мне неизвестен API, специально предназначенный для получения статуса разрешения на запись экрана. Помимо создания CGDisplayStream и проверки на ноль, успехи в безопасности macOS WWDC В презентации также упоминалось, что определенные метаданные из CGWindowListCopyWindowInfo() API не будут возвращены, пока не будет предоставлено разрешение. Кажется, что-то вроде этого работает, хотя у него та же проблема, связанная с деталями реализации этой функции:

private func canRecordScreen() -> Bool {
    guard let windows = CGWindowListCopyWindowInfo([.optionOnScreenOnly], kCGNullWindowID) as? [[String: AnyObject]] else { return false }
    return windows.allSatisfy({ window in
        let windowName = window[kCGWindowName as String] as? String
        return windowName != nil
    })
}

По состоянию на 19 ноября chockenberry имеет правильный ответ.

Как отметил @onelittlefish, kCGWindowName опускается, если пользователь не включил доступ к записи экрана на панели конфиденциальности. Этот метод также не вызывает предупреждение о конфиденциальности.

- (BOOL)canRecordScreen
{
    if (@available(macOS 10.15, *)) {
        CFArrayRef windowList = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
        NSUInteger numberOfWindows = CFArrayGetCount(windowList);
        NSUInteger numberOfWindowsWithName = 0;
        for (int idx = 0; idx < numberOfWindows; idx++) {
            NSDictionary *windowInfo = (NSDictionary *)CFArrayGetValueAtIndex(windowList, idx);
            NSString *windowName = windowInfo[(id)kCGWindowName];
            if (windowName) {
                numberOfWindowsWithName++;
            } else {
                //no kCGWindowName detected -> not enabled
                break; //breaking early, numberOfWindowsWithName not increased
            }

        }
        CFRelease(windowList);
        return numberOfWindows == numberOfWindowsWithName;
    }
    return YES;
}

Самый благоприятный ответ - не совсем правильный, он упустил некоторые смыслы, такие как разделение состояния.

мы можем найти ответ в WWDC (https://developer.apple.com/videos/play/wwdc2019/701/?time=1007).

Вот некоторые выдержки из WWDC: имя окна и состояние совместного использования недоступны, если пользователь предварительно не одобрил приложение для записи экрана. И это потому, что некоторые приложения помещают конфиденциальные данные, такие как имена учетных записей или, что более вероятно, URL-адреса веб-страниц в имя окна.

- (BOOL)ScreeningRecordPermissionCheck {
    if (@available(macOS 10.15, *)) {
        CFArrayRef windowList = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
        NSUInteger numberOfWindows = CFArrayGetCount(windowList);
        NSUInteger numberOfWindowsWithInfoGet = 0;
        for (int idx = 0; idx < numberOfWindows; idx++) {

            NSDictionary *windowInfo = (NSDictionary *)CFArrayGetValueAtIndex(windowList, idx);
            NSString *windowName = windowInfo[(id)kCGWindowName];
            NSNumber* sharingType = windowInfo[(id)kCGWindowSharingState];

            if (windowName || kCGWindowSharingNone != sharingType.intValue) {
                numberOfWindowsWithInfoGet++;
            } else {
                NSNumber* pid = windowInfo[(id)kCGWindowOwnerPID];
                NSString* appName = windowInfo[(id)kCGWindowOwnerName];
                NSLog(@"windowInfo get Fail pid:%lu appName:%@", pid.integerValue, appName);
            }
        }
        CFRelease(windowList);
        if (numberOfWindows == numberOfWindowsWithInfoGet) {
            return YES;
        } else {
            return NO;
        }
    }
    return YES;
}

Начиная с MacOS 10.15.7 эвристика получения имен окон для видимых окон, а значит, знание того, что у нас есть разрешение на захват экрана, не всегда работает. Иногда мы просто не находим допустимые окна, которые можем запросить, и ошибочно делаем вывод, что у нас нет разрешений.

Однако я нашел другой способ напрямую запросить (с помощью sqlite) базу данных Apple TCC - модель, в которой сохраняются разрешения. Разрешения на запись экрана можно найти в базе данных TCC системного уровня (находящейся в /Library/Application Support/com.apple.TCC/TCC.db). Если вы откроете базу данных с помощью sqlite и запросите: SELECT allowed FROM access WHERE client="com.myCompany.myApp" AND service="kTCCServiceScreenCapture", вы получите ответ.

Два недостатка по сравнению с другими ответами:

• чтобы открыть эту базу данных TCC.db, ваше приложение должно иметь разрешение Полный доступ к диску. Ему не нужно запускать с привилегиями root, и привилегии root не помогут, если у вас нет полного доступа к диску.
• для выполнения требуется около 15 миллисекунд, что медленнее, чем запрос списка окон.

Положительная сторона - это прямой запрос фактического объекта и не зависит от каких-либо окон или процессов, существующих во время запроса.

Вот черновик кода для этого:

NSString *client = @"com.myCompany.myApp";
sqlite3 *tccDb = NULL;
sqlite3_stmt *statement = NULL;

NSString *pathToSystemTCCDB = @"/Library/Application Support/com.apple.TCC/TCC.db";
const char *pathToDBFile = [pathToSystemTCCDB fileSystemRepresentation];
if (sqlite3_open(pathToDBFile, &tccDb) != SQLITE_OK)
   return nil;
    
const char *query = [[NSString stringWithFormat: @"SELECT allowed FROM access WHERE client=\"%@\" AND service=\"kTCCServiceScreenCapture\"",client] UTF8String];
if (sqlite3_prepare_v2(tccDb, query , -1, &statement, nil) != SQLITE_OK)
   return nil;
    
BOOL allowed = NO;
while (sqlite3_step(statement) == SQLITE_ROW)
    allowed |= (sqlite3_column_int(statement, 0) == 1);

if (statement)
    sqlite3_finalize(statement);

if (tccDb)
    sqlite3_close(tccDb);

return @(allowed);

}

Приведенный выше ответ не работает нормально. Ниже правильный ответ.

private var canRecordScreen : Bool {
    guard let windows = CGWindowListCopyWindowInfo([.optionOnScreenOnly], kCGNullWindowID) as? [[String: AnyObject]] else { return false }
    return windows.allSatisfy({ window in
        let windowName = window[kCGWindowName as String] as? String
        let isSharingEnabled = window[kCGWindowSharingState as String] as? Int
        return windowName != nil || isSharingEnabled == 1
    })
  }