VuoEventLoop.m

Go to the documentation of this file.

 
#include "VuoEventLoop.h"
#include "VuoLog.h"
#include "VuoCompositionState.h"
 
#import <AppKit/AppKit.h>
#import <IOKit/pwr_mgt/IOPMLib.h>
#import <IOKit/pwr_mgt/IOPM.h>
 
#include <objc/objc-runtime.h>
 
#include <dlfcn.h>
 
bool VuoEventLoop_systemAsleep = false;  
 
static id *nsAppGlobal;  
static void __attribute__((constructor)) VuoEventLoop_init()
{
    // Can't just use `NSApp` directly, since the composition might not link to AppKit.
    nsAppGlobal = (id *)dlsym(RTLD_DEFAULT, "NSApp");
}
 
static bool VuoEventLoop_isMainThread(void)
{
    static void **mainThread;
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        mainThread = (void **)dlsym(RTLD_SELF, "VuoApp_mainThread");
        if (!mainThread)
            mainThread = (void **)dlsym(RTLD_DEFAULT, "VuoApp_mainThread");
 
        if (!mainThread)
        {
            VUserLog("Error: Couldn't find VuoApp_mainThread.");
            VuoLog_backtrace();
            exit(1);
        }
 
        if (!*mainThread)
        {
            VUserLog("Error: VuoApp_mainThread isn't set.");
            VuoLog_backtrace();
            exit(1);
        }
    });
 
    return *mainThread == (void *)pthread_self();
}
 
void VuoEventLoop_processEvent(VuoEventLoopMode mode)
{
    if (!VuoEventLoop_isMainThread())
    {
        VUserLog("Error: VuoEventLoop_processEvent must be called from the main thread.");
        VuoLog_backtrace();
        exit(1);
    }
 
    NSAutoreleasePool *pool = [NSAutoreleasePool new];
 
    // Support running either with or without an NSApplication.
    if (nsAppGlobal && *nsAppGlobal)
    {
        // http://www.cocoawithlove.com/2009/01/demystifying-nsapplication-by.html
        // https://stackoverflow.com/questions/6732400/cocoa-integrate-nsapplication-into-an-existing-c-mainloop
 
        // When the composition is ready to stop, it posts a killswitch NSEvent,
        // to ensure that this function returns immediately.
        NSEvent *event = [*nsAppGlobal nextEventMatchingMask:NSEventMaskAny
                                                   untilDate:(mode == VuoEventLoop_WaitIndefinitely ? [NSDate distantFuture] : [NSDate distantPast])
                                                      inMode:NSDefaultRunLoopMode
                                                     dequeue:YES];
        [*nsAppGlobal sendEvent:event];
        [*nsAppGlobal updateWindows];
    }
    else
    {
        // This blocks until CFRunLoopStop() is called.
        // When the composition is ready to stop (or switch into NSApplication mode), it calls CFRunLoopStop().
        if (mode == VuoEventLoop_WaitIndefinitely)
            CFRunLoopRun();
        else
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, false);
    }
 
    [pool drain];
}
 
void VuoEventLoop_break(void)
{
    if (nsAppGlobal && *nsAppGlobal)
    {
        // Send an event, to ensure VuoEventLoop_processEvent()'s call to `nextEventMatchingMask:…` returns immediately.
        // -[NSApplication postEvent:atStart:] must be called from the main thread.
        dispatch_async(dispatch_get_main_queue(), ^{
            NSEvent *killswitch = [NSEvent otherEventWithType:NSEventTypeApplicationDefined
                                   location:NSMakePoint(0,0)
                              modifierFlags:0
                                  timestamp:0
                               windowNumber:0
                                    context:nil
                                    subtype:0
                                      data1:0
                                      data2:0];
            [*nsAppGlobal postEvent:killswitch atStart:NO];
        });
    }
    else
        // https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html#//apple_ref/doc/uid/10000057i-CH16-SW26
        // says this can be called from any thread.
        CFRunLoopStop(CFRunLoopGetMain());
}
 
void VuoEventLoop_switchToAppMode(void)
{
    // https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html#//apple_ref/doc/uid/10000057i-CH16-SW26
    // says this can be called from any thread.
    CFRunLoopStop(CFRunLoopGetMain());
}
 
bool VuoEventLoop_mayBeTerminated(void)
{
    if (!VuoEventLoop_isMainThread())
    {
        VUserLog("Error: VuoEventLoop_mayBeTerminated must be called from the main thread.");
        VuoLog_backtrace();
        exit(1);
    }
 
    if (!nsAppGlobal || !*nsAppGlobal)
        return true;
 
    if ([*nsAppGlobal modalWindow])
        return false;
 
    for (NSWindow *window in [*nsAppGlobal windows])
        if ([window attachedSheet])
            return false;
 
    return true;
}
 
dispatch_queue_attr_t VuoEventLoop_getDispatchInteractiveAttribute(void)
{
    static dispatch_queue_attr_t attr = 0;
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INTERACTIVE, 0);
    });
    return attr;
}
 
void VuoEventLoop_setLimits(void)
{
    // Increase the open-files limit (macOS defaults to 256).
    struct rlimit rl = {OPEN_MAX, OPEN_MAX};
    getrlimit(RLIMIT_NOFILE, &rl);
    rl.rlim_cur = MIN(OPEN_MAX, rl.rlim_max);
    if (setrlimit(RLIMIT_NOFILE, &rl))
        VUserLog("Warning: Couldn't set open-files limit: %s", strerror(errno));
}
 
void VuoEventLoop_installSignalHandlers(void)
{
    typedef void (*vuoStopCompositionType)(struct VuoCompositionState *);
    vuoStopCompositionType vuoStopComposition = (vuoStopCompositionType)dlsym(RTLD_SELF, "vuoStopComposition");
    if (!vuoStopComposition)
        vuoStopComposition = (vuoStopCompositionType)dlsym(RTLD_DEFAULT, "vuoStopComposition");
    if (!vuoStopComposition)
    {
        VUserLog("Warning: Couldn't find vuoStopComposition symbol; not installing clean-shutdown signal handlers.");
        return;
    }
 
    // Disable default signal handlers so libdispatch can catch them.
    signal(SIGINT, SIG_IGN);
    signal(SIGQUIT, SIG_IGN);
    signal(SIGTERM, SIG_IGN);
 
    // Use libdispatch to handle signals instead of `signal`/`sigaction`
    // since `vuoStopComposition()` uses non-signal-safe functions such as `malloc`.
    void (^stop)(void) = ^{
        vuoStopComposition(NULL);
    };
    dispatch_source_t sigintSource  = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGINT,  0, dispatch_get_main_queue());
    dispatch_source_t sigquitSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGQUIT, 0, dispatch_get_main_queue());
    dispatch_source_t sigtermSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGTERM, 0, dispatch_get_main_queue());
    dispatch_source_set_event_handler(sigintSource,  stop);
    dispatch_source_set_event_handler(sigquitSource, stop);
    dispatch_source_set_event_handler(sigtermSource, stop);
    dispatch_resume(sigintSource);
    dispatch_resume(sigquitSource);
    dispatch_resume(sigtermSource);
}
 
static void VuoShowSystemPowerEvent(void *refcon, io_service_t root_domain, natural_t messageType, void *messageArgument)
{
    if (messageType != kIOPMMessageSystemPowerEventOccurred)
        return;
 
    CFDictionaryRef d;
    IOPMCopyCPUPowerStatus(&d);
    CFNumberRef cpuSpeedLimitCF = CFDictionaryGetValue(d, CFSTR(kIOPMCPUPowerLimitProcessorSpeedKey));
    int cpuSpeedLimit = -1;
    CFNumberGetValue(cpuSpeedLimitCF, kCFNumberIntType, &cpuSpeedLimit);
    CFRelease(d);
 
    if (cpuSpeedLimit >= 0)
        VUserLog("The system changed the CPU speed limit to %d%%.", cpuSpeedLimit);
}
 
static void VuoThermalState(void)
{
    void (^logThermalState)(int thermalState) = ^(int thermalState){
        if (thermalState == 0)
            VUserLog("thermalState = nominal");
        else if (thermalState == 1)
            VUserLog("thermalState = fair (\"fans audible\")");
        else if (thermalState == 2)
            VUserLog("thermalState = serious (\"fans at maximum speed\")");
        else if (thermalState == 3)
            VUserLog("thermalState = critical (\"system needs to cool down\")");
    };
    if ([NSProcessInfo.processInfo respondsToSelector:@selector(thermalState)])
    {
        logThermalState(((int (*)(id, SEL))objc_msgSend)(NSProcessInfo.processInfo, @selector(thermalState)));
        [NSNotificationCenter.defaultCenter addObserverForName:@"NSProcessInfoThermalStateDidChangeNotification" object:nil queue:nil usingBlock:^(NSNotification *note){
            logThermalState(((int (*)(id, SEL))objc_msgSend)(note.object, @selector(thermalState)));
        }];
    }
 
 
    // Start listening for system power events.
    io_service_t rootDomain = IORegistryEntryFromPath(kIOMasterPortDefault, kIOPowerPlane ":/IOPowerConnection/IOPMrootDomain");
    IONotificationPortRef notePort = IONotificationPortCreate(MACH_PORT_NULL);
    if (rootDomain && notePort)
    {
        io_object_t notification_object = MACH_PORT_NULL;
        IOReturn ret = IOServiceAddInterestNotification(notePort, rootDomain, kIOGeneralInterest, VuoShowSystemPowerEvent, NULL, &notification_object);
        if (ret == kIOReturnSuccess)
        {
            CFRunLoopSourceRef runLoopSrc = IONotificationPortGetRunLoopSource(notePort);
            if (runLoopSrc)
                CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSrc, kCFRunLoopDefaultMode);
        }
    }
}
 
static void VuoMemoryPressure(void)
{
    dispatch_source_t memoryPressureWatcher = dispatch_source_create(DISPATCH_SOURCE_TYPE_MEMORYPRESSURE, 0, DISPATCH_MEMORYPRESSURE_NORMAL|DISPATCH_MEMORYPRESSURE_WARN|DISPATCH_MEMORYPRESSURE_CRITICAL, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
    dispatch_source_set_event_handler(memoryPressureWatcher, ^{
        int pressure = dispatch_source_get_data(memoryPressureWatcher);
        if (pressure == DISPATCH_MEMORYPRESSURE_NORMAL)
            VUserLog("memoryPressure = normal");
        else if (pressure == DISPATCH_MEMORYPRESSURE_WARN)
            VUserLog("memoryPressure = warning");
        else if (pressure == DISPATCH_MEMORYPRESSURE_CRITICAL)
            VUserLog("memoryPressure = critical");
    });
    dispatch_resume(memoryPressureWatcher);
}
 
static void VuoWorkspaceState(void)
{
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceWillSleepNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The system is going to sleep.");
        VuoEventLoop_systemAsleep = true;
    }];
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceDidWakeNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The system is waking up.");
        VuoEventLoop_systemAsleep = false;
    }];
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceWillPowerOffNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The system is powering off");
    }];
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceScreensDidSleepNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The screens are going to sleep.");
    }];
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceScreensDidWakeNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The screens are waking up.");
    }];
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceSessionDidBecomeActiveNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The system is switching back to this user account.");
    }];
    [NSWorkspace.sharedWorkspace.notificationCenter addObserverForName:NSWorkspaceSessionDidResignActiveNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The system is switching away to another user account.");
    }];
    [NSNotificationCenter.defaultCenter addObserverForName:NSSystemClockDidChangeNotification object:nil queue:nil usingBlock:^(NSNotification *note){
        VUserLog("The system's clock changed to %s", NSDate.date.description.UTF8String);
    }];
}
 
bool VuoEventLoop_isSystemAsleep(void)
{
    return VuoEventLoop_systemAsleep;
}
 
void VuoEventLoop_installSleepHandlers(void)
{
    VuoThermalState();
    VuoMemoryPressure();
    VuoWorkspaceState();
}
 
void VuoEventLoop_disableAppNap(void)
{
    id activityToken = [NSProcessInfo.processInfo beginActivityWithOptions:NSActivityUserInitiated & ~NSActivitySuddenTerminationDisabled
        reason: @"Many Vuo compositions need to process input and send output even when the app's window is not visible."];
 
    [activityToken retain];
}