私有系统集成

public func createEmitterBehavior(type: String) -> NSObject {
    let selector = ["behaviorWith", "Type:"].joined(separator: "")
    let behaviorClass = NSClassFromString(["CA", "Emitter", "Behavior"].joined(separator: "")) as! NSObject.Type
    let behaviorWithType = behaviorClass.method(for: NSSelectorFromString(selector))!
    let castedBehaviorWithType = unsafeBitCast(
        behaviorWithType,
        to: (@convention(c) (Any?, Selector, Any?) -> NSObject).self
    )
    return castedBehaviorWithType(behaviorClass, NSSelectorFromString(selector), type)
}

let fingerAttractor = createEmitterBehavior(type: "simpleAttractor")
fingerAttractor.setValue("fingerAttractor", forKey: "name")
let alphaBehavior = createEmitterBehavior(type: "valueOverLife")
alphaBehavior.setValue("color.alpha", forKey: "keyPath")
alphaBehavior.setValue([0.0, 0.0, 1.0, 0.0, -1.0], forKey: "values")
alphaBehavior.setValue(true, forKey: "additive")

if hasPermission {
    func callback(proxy: CGEventTapProxy, type: CGEventType,
                  event: CGEvent, refcon: UnsafeMutableRawPointer?) -> Unmanaged<CGEvent>? {
        if let event = NSEvent(cgEvent: event) {
            let processor = Unmanaged<ProcessEvent>.fromOpaque(refcon!).takeUnretainedValue()
            processor.process(event)
        }
        return Unmanaged.passRetained(event)
    }
    let eventMask: Int32 = (1 << CGEventType.keyDown.rawValue)
        | (1 << CGEventType.otherMouseDown.rawValue)
        | (1 << CGEventType.otherMouseUp.rawValue)
        | (1 << CGEventType.keyUp.rawValue)
        | (1 << CGEventType.flagsChanged.rawValue)
    self.eventTap = CGEvent.tapCreate(tap: .cghidEventTap,
                                      place: .headInsertEventTap,
                                      options: .listenOnly,
                                      eventsOfInterest: CGEventMask(eventMask),
                                      callback: callback,
                                      userInfo: UnsafeMutableRawPointer(Unmanaged.passRetained(processEvent).toOpaque()))
}

static func enableCustomIcon(bundle: String) -> Bool {
    var info = readCustomIconAttribute(bundle: bundle)
    if info.isEmpty {
        info = Data(repeating: 0, count: kFinderInfoSize)
    }
    info[8] |= 4
    return writeCustomIconAttribute(bundle: bundle, value: info)
}

static func refreshDock(silence: Bool) -> Bool {
    let _ = launch(command: "/bin/bash", arguments: ["-c", "rm /var/folders/*/*/*/com.apple.dock.iconcache"])
    if !silence {
        let killallResult = launch(command: "/usr/bin/killall", arguments: ["Dock"])
        if killallResult != 0 { return false }
    }
    return true
}

let bundle = bundlePath()
let icon = bundle + "/Icon\r"
guard let rsrc = readResourceFork(path: path), !rsrc.isEmpty else { return nil }
if !writeResourceFork(path: icon, data: rsrc) || !enableCustomIcon(bundle: bundle) {
    return nil
}
return refreshDock(silence: silence) ? digest(rsrc) : nil

override func toggleFullScreen() {
    if let view = _cachedView {
        let controls = HackUtils.findElements(byClass: "AVMovableView", in: view)?.first as? NSView
        if let controls = controls {
            if let view = controls.subviews.first?.subviews.first?.subviews.first?
                .subviews.last?.subviews.first?.subviews.last {
                if let view = view as? NSButton {
                    view.performClick(self)
                }
            }
        }
    }
}

@objc func windowDidNeedSaveState(_ notification: Notification) {
    if let titleView = window.titleView {
        let frame = NSMakeRect(0, window.frame.height - barHeight, titleView.frame.width, barHeight)
        if !NSEqualRects(frame, titleView.frame) {
            titleView.frame = frame
        }
        if let controls = (HackUtils.findElements(byClass: "NSTitlebarView", in: titleView)?.first as? NSView)?.subviews {
            var xs: [CGFloat] = [18, 58, 38]
            for i in 0 ..< min(controls.count, xs.count) {
                let view = controls[i]
                view.isHidden = true
                view.setFrameOrigin(xs[i], floorToScreenPixels(System.backingScale,
                    (barHeight - view.frame.height) / 2))
            }
        }
    }
}

public override func menu(for event: NSEvent) -> NSMenu? {
    let menu = super.menu(for: event) as? NSMenu
    var removeItems = [NSMenuItem]()
    var addedTransformations = false
    menu?.items.enumerated().forEach { (idx, item) in
        if item.action == NSSelectorFromString("submenuAction:") {
            item.submenu?.items.enumerated().forEach { (subIdx, subItem) in
                if subItem.action == NSSelectorFromString("_shareServiceSelected:")
                    || subItem.action == NSSelectorFromString("orderFrontFontPanel:")
                    || subItem.action == NSSelectorFromString("orderFrontSubstitutionsPanel:")
                    || subItem.action == NSSelectorFromString("changeLayoutOrientation:") {
                    removeItems.append(item)
                } else if subItem.action == #selector(capitalizeWord(_:)) {
                    addedTransformations = true
                    if self.selectedRange.length > 0 {
                        if self.customDelegate?.inputTextCanTransform() == true {
                            self.transformItems.enumerated().forEach { (transformIdx, obj) in
                                item.submenu?.insertItem(obj, at: transformIdx)
                            }
                        }
                    }
                }
            }
        }
    }

@implementation ObjcUtils

+(NSCursor * __nullable)windowResizeNorthWestSouthEastCursor {
    NSCursor *cursor = [[NSCursor class]
        performSelector:@selector(_windowResizeNorthWestSouthEastCursor)];
    return cursor;
}

+(NSCursor * __nullable)windowResizeNorthEastSouthWestCursor {
    NSCursor *cursor = [[NSCursor class]
        performSelector:@selector(_windowResizeNorthEastSouthWestCursor)];
    return cursor;
}

+ (NSData *)dataFromHexString:(NSString *)string

let delegate = mapView.delegate
mapView.delegate = nil
mapView.frame = NSMakeRect(0, mapY, frame.width, mapHeight)
mapView.delegate = delegate

let pinPoint = mapView.focus(NSMakeSize(4, 4))
locationPinView.centerX(y: pinPoint.midY - locationPinView.frame.height)

expandButton.center()
loadingView.center()

let zoomControls = HackUtils.findElements(byClass: "MKZoomSegmentedControl", in: mapView).first as? NSView
if let zoomControls = zoomControls {
    zoomControls.setFrameOrigin(20, 20)
}

public var processFullScreen: ((Bool, @escaping (Bool) -> Void) -> Void)?

private func invokeFullScreen(_ sender: Any?) {
    CATransaction.begin()
    super.toggleFullScreen(sender)
    CATransaction.commit()
    saver?.isFullScreen = isFullScreen
}

open override func toggleFullScreen(_ sender: Any?) {
    let newValue = !isFullScreen
    self.onToggleFullScreen?(newValue)
    if let process = processFullScreen {
        process(newValue, { [weak self] value in
            self?.invokeFullScreen(nil)
            self?.onToggleFullScreen?(newValue)
        })
    } else {
        invokeFullScreen(nil)
        DispatchQueue.main.async {
            self.isFullScreenValue.set(newValue)
        }
    }
}

fileprivate func open() {
    self.serviceInternal = IOServiceGetMatchingService(
        kIOMasterPortDefault, IOServiceMatching("AppleSmartBattery"))
}

public func getInternalBattery() -> InternalBattery? {
    self.open()
    if self.serviceInternal == 0 {
        return nil
    }
    let battery = self.getBatteryData()
    self.close()
    return battery
}

battery.currentCapacity = self.getIntValue("CurrentCapacity" as CFString)
battery.maxCapacity = self.getIntValue("MaxCapacity" as CFString)
battery.designCapacity = self.getIntValue("DesignCapacity" as CFString)
battery.cycleCount = self.getIntValue("CycleCount" as CFString)
battery.designCycleCount = self.getIntValue("DesignCycleCount9C" as CFString)
battery.acPowered = self.getBoolValue("ExternalConnected" as CFString)
battery.isCharging = self.getBoolValue("IsCharging" as CFString)
battery.temperature = self.getTemperature()

NSString *mapped = [characterMap objectForKey:@(keyCode)];
if (mapped != nil) {
    [final appendString:mapped];
} else {
    TISInputSourceRef currentKeyboard = TISCopyCurrentASCIICapableKeyboardLayoutInputSource();
    CFDataRef uchr = (CFDataRef)TISGetInputSourceProperty(
        currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
    if (!uchr) {
        CFRelease(currentKeyboard);
        currentKeyboard = TISCopyCurrentASCIICapableKeyboardLayoutInputSource();
        uchr = (CFDataRef)TISGetInputSourceProperty(
            currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
    }
    const UCKeyboardLayout *keyboardLayout =
        (const UCKeyboardLayout *)CFDataGetBytePtr(uchr);
    if (keyboardLayout) {
        UInt32 keyModifiers = CarbonModifierFlagsFromCocoaModifiers(modifiers);
        OSStatus status = UCKeyTranslate(keyboardLayout, keyCode,
            kUCKeyActionDown, keyModifiers, LMGetKbdType(), 0,
            &deadKeyState, maxStringLength, &actualStringLength, unicodeString);

+ (BOOL)checkInputMonitoringWithPrompt:(BOOL)prompt {
    if (@available(macOS 10.15, *)) {
        static const IOHIDRequestType accessType = kIOHIDRequestTypeListenEvent;
        if (prompt) {
            dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
                IOHIDRequestAccess(accessType);
            });
            return NO;
        } else {
            return kIOHIDAccessTypeGranted == IOHIDCheckAccess(accessType);
        }
    } else {
        return [PermissionsManager checkAccessibilityWithPrompt:prompt];
    }
}

+ (NSURL *)securitySettingsUrlForKey:(NSString *)key {
    return [NSURL URLWithString:[NSString stringWithFormat:
        @"x-apple.systempreferences:com.apple.preference.security?%@", key]];
}

public struct XAttr {
    public struct Error: Swift.Error {
        public let localizedDescription = String(utf8String: strerror(errno))
    }

    public static func set(named name: String, data: Data, atPath path: String) throws {
        if setxattr(path, name, (data as NSData).bytes, data.count, 0, 0) == -1 {
            throw Error()
        }
    }

    public static func remove(named name: String, atPath path: String) throws {
        if removexattr(path, name, 0) == -1 {
            throw Error()
        }
    }

    public static func get(named name: String, atPath path: String) throws -> Data {
        let bufLength = getxattr(path, name, nil, 0, 0, 0)
        guard bufLength != -1, let buf = malloc(bufLength),
              getxattr(path, name, buf, bufLength, 0, 0) != -1 else { throw Error() }
        return Data(bytes: buf, count: bufLength)
    }
}

int64_t SystemIdleTime(void) {
    int64_t idlesecs = -1;
    io_iterator_t iter = 0;
    if (IOServiceGetMatchingServices(kIOMasterPortDefault,
            IOServiceMatching("IOHIDSystem"), &iter) == KERN_SUCCESS) {
        io_registry_entry_t entry = IOIteratorNext(iter);
        if (entry) {
            CFMutableDictionaryRef dict = NULL;
            if (IORegistryEntryCreateCFProperties(entry, &dict,
                    kCFAllocatorDefault, 0) == KERN_SUCCESS) {
                CFNumberRef obj = CFDictionaryGetValue(dict, CFSTR("HIDIdleTime"));
                if (obj) {
                    int64_t nanoseconds = 0;
                    if (CFNumberGetValue(obj, kCFNumberSInt64Type, &nanoseconds)) {
                        idlesecs = (nanoseconds >> 30);
                    }
                }
                CFRelease(dict);
            }
            IOObjectRelease(entry);
        }
        IOObjectRelease(iter);
    }
    return idlesecs;
}

func deviceFromSystemProfiler() -> String? {
    // Starting with MacBook M2 the hw.model returns simply Mac[digits],[digits].
    let process = Process()
    if #available(macOS 10.13, *) {
        process.executableURL = URL(fileURLWithPath: "/usr/sbin/system_profiler")
    } else {
        process.launchPath = "/usr/sbin/system_profiler"
    }
    process.arguments = ["-json", "SPHardwareDataType", "-detailLevel", "mini"]
    let pipe = Pipe()
    process.standardOutput = pipe
    do {
        if #available(macOS 10.13, *) { try process.run() }
        else { process.launch() }
    } catch {
        return nil
    }
    process.waitUntilExit()
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let document = try? JSONSerialization.jsonObject(with: data, options: [])
    guard let fields = (document as? [String: Any])?["SPHardwareDataType"] as? [[String: Any]],
          !fields.isEmpty else { return nil }

public func isCrashedLastTime(_ folder: String) -> Bool {
    let url = folder + "/" + "crashhandler"
    if let dateString = try? String(contentsOf: URL(fileURLWithPath: url)) {
        let components = dateString.components(separatedBy: " ")
        if components.count == 2 {
            let initedDate = Int32(components[0]) ?? 0
            let lastSavedDate = Int32(components[1]) ?? 0
            return lastSavedDate - initedDate < 10
        } else {
            return true
        }
    }
    return FileManager.default.fileExists(atPath: url)
}

public func crashIntermediateDate(_ folder: String) {
    let url = folder + "/" + "crashhandler"
    if let dateString = try? String(contentsOf: URL(fileURLWithPath: url)) {
        let time = "\(Int32(Date().timeIntervalSince1970))"
        var components = dateString.components(separatedBy: " ")
        if components.count == 2 { components[1] = time }
        else if components.count == 1 { components.append(time) }
        try? FileManager.default.removeItem(atPath: url)
        FileManager.default.createFile(atPath: url,
            contents: components.joined(separator: " ").data(using: .utf8), attributes: nil)

let signal = combineLatest(queue: .mainQueue(), accountPeer, peers)
disposable.set(signal.start(next: { [weak self] accountPeer, peers in
    guard let `self` = self else { return }
    // `items` is rebuilt from the current peers.
    let (delete, insert, update) = mergeListsStableWithUpdates(
        leftList: self.previousItems, rightList: items)
    if !insert.isEmpty || !update.isEmpty {
        CSSearchableIndex.default().indexSearchableItems(
            insert.map { $0.1.item }, completionHandler: nil)
        CSSearchableIndex.default().indexSearchableItems(
            update.map { $0.1.item }, completionHandler: nil)
    }
    var deleted: [SpotlightItem] = []
    for index in delete.reversed() {
        deleted.append(self.previousItems.remove(at: index))
    }
    self.previousItems = items
    if !deleted.isEmpty {
        CSSearchableIndex.default().deleteSearchableItems(
            withIdentifiers: deleted.map { $0.stableId.stringValue }, completionHandler: nil)
    }
}))

if dockTile {
    NSApplication.shared.dockTile.badgeLabel = result.dockText
    forceUpdateStatusBarIconByDockTile(sharedContext: sharedContext)
}

func forceUpdateStatusBarIconByDockTile(sharedContext: SharedAccountContext) {
    if let count = Int(NSApplication.shared.dockTile.badgeLabel ?? "0") {
        var color: NSColor = .black
        if #available(OSX 10.14, *) {
            if systemAppearance.name != .aqua {
                color = .white
            }
        }
        if #available(OSX 11.0, *) {
            color = .white
        }
        resourcesQueue.async {
            let icon = generateStatusBarIcon(count, color: color)
            Queue.mainQueue().async {
                sharedContext.updateStatusBarImage(icon)
            }
        }
    }
}