PrefsController.m

//
//  PrefsController.m
//  Jiggler
//
//  Created by Ben Haller on Wed Jul 23 2003.
//  Copyright (c) 2003 Stick Software. All rights reserved.
//

#import "PrefsController.h"
#import "CocoaExtra.h"
#import "AppDelegate.h"

#import <ServiceManagement/ServiceManagement.h>		// SMAppService on 13.0+; LSSharedFileList* (CoreServices) is auto-imported via Cocoa


// User defaults keys
static NSString *JiggleTimeDefaultsKey = @"JiggleTime";							// version 1.3 and before: -1 = 20 secs, 0 = 40 secs, >=1 is number of minutes
static NSString *JiggleSecondsDefaultsKey = @"JiggleSeconds";					// version 1.4 and later: the actual number of seconds between jiggles (minimum 5)
static NSString *ShowIconWhenJigglingDefaultsKey = @"ShowIconWhenJiggling";
static NSString *JiggleOnlyWhenIdleDefaultsKey = @"JiggleOnlyWhenIdle";

static NSString *ZenJiggleDefaultsKey = @"ZenJiggle";							// version 1.7 and before, superseded by JiggleStyleDefaultsKey
static NSString *JiggleStyleDefaultsKey = @"JiggleStyle";						// 0 is standard, 1 is Zen jiggle, 2 is click jiggle, 3 is keystroke jiggle (hidden; issue #28)
static NSString *JiggleDistanceDefaultsKey = @"JiggleDistance";

static NSString *OnlyWithCPUUsageDefaultsKey = @"OnlyWithCPUUsage";
static NSString *CPUUsageThresholdDefaultsKey = @"CPUUsageThreshold";
static NSString *OnlyWithRemovableWritableDisksDefaultsKey = @"OnlyWithRemovableWritableDisks";
static NSString *OnlyWithMusicPlayingDefaultsKey = @"OnlyWithITunesPlaying";	// historical key name retained for backwards compatibility with stored prefs
static NSString *OnlyWithApplicationsNamedXDefaultsKey = @"OnlyWithApplicationsNamedX";
static NSString *OnlyWithIdentityDefaultsKey = @"OnlyWithIdentity";
static NSString *ApplicationNameComponentDefaultsKey = @"ApplicationNameComponent";
static NSString *NotWhenScreenLockedDefaultsKey = @"NotWhenScreenLocked";
static NSString *NotOnBatteryDefaultsKey = @"NotOnBattery";
static NSString *NotWithFrontAppsNamedXDefaultsKey = @"NotWithFrontAppsNamedX";
static NSString *FrontAppNameComponentDefaultsKey = @"FrontAppNameComponent";


@implementation PrefsController

+ (PrefsController *)sharedPrefsController
{
	static PrefsController *sharedInstance = nil;
	static dispatch_once_t onceToken;
	dispatch_once(&onceToken, ^{
		sharedInstance = [[PrefsController alloc] init];
	});
	return sharedInstance;
}

- (id)init
{
	if (self = [super init])
	{
		NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
		
		// Set up our default values; should probably be in +initialize, but this gets called right away anyway...
		[userDefaults registerDefaults:@{
			JiggleTimeDefaultsKey:                  @5,        // old defaults key, kept as minimum time value
			JiggleSecondsDefaultsKey:               @(-1),     // -1 == "no value set for the new key" (flag)
			ShowIconWhenJigglingDefaultsKey:        @"YES",
			JiggleOnlyWhenIdleDefaultsKey:          @"YES",

			ZenJiggleDefaultsKey:                   @"NO",     // default for the old key
			JiggleStyleDefaultsKey:                 @(-1),     // -1 == "no value set for the new key" (flag)
			JiggleDistanceDefaultsKey:              @2.0f,     // 0 was the effective default in 1.7 and earlier

			OnlyWithCPUUsageDefaultsKey:            @"NO",
			CPUUsageThresholdDefaultsKey:           @20,

			OnlyWithRemovableWritableDisksDefaultsKey: @"NO",

			OnlyWithMusicPlayingDefaultsKey:        @"NO",

			OnlyWithApplicationsNamedXDefaultsKey:  @"NO",
			OnlyWithIdentityDefaultsKey:            @0,
			ApplicationNameComponentDefaultsKey:    @"",

			NotWhenScreenLockedDefaultsKey:         @"YES",

			NotOnBatteryDefaultsKey:                @"NO",

			NotWithFrontAppsNamedXDefaultsKey:      @"NO",
			FrontAppNameComponentDefaultsKey:       @"",

			@"NSAppSleepDisabled":                  @YES,      // completely disable App Nap; we want to always be live, that's kind of the point
		}];
		
		// Read our de facto values into our caches
		jiggleSeconds = (int)[userDefaults integerForKey:JiggleSecondsDefaultsKey];

		if (jiggleSeconds < 0)
		{
			int jiggleTime;		// old defaults key: -1 is 20 seconds, 0 is 40 seconds, positive integers are a number of minutes

			jiggleTime = (int)[userDefaults integerForKey:JiggleTimeDefaultsKey];

			if (jiggleTime == -1)
				jiggleSeconds = 20;
			else if (jiggleTime == 0)
				jiggleSeconds = 40;
			else
				jiggleSeconds = jiggleTime * 60;
		}

		if (jiggleSeconds < 5)
			jiggleSeconds = 5;
		if (jiggleSeconds > 60 * 60 * 24)
			jiggleSeconds = 60 * 60 * 24;

		showJigglerIconWhenJiggling = [userDefaults boolForKey:ShowIconWhenJigglingDefaultsKey];
		jiggleOnlyWhenIdle = [userDefaults boolForKey:JiggleOnlyWhenIdleDefaultsKey];

		jiggleStyle = (int)[userDefaults integerForKey:JiggleStyleDefaultsKey];
		if (jiggleStyle == -1)
			jiggleStyle = ([userDefaults boolForKey:ZenJiggleDefaultsKey] ? 1 : 0);
		if ((jiggleStyle < 0) || (jiggleStyle > 3)) jiggleStyle = 0;

		jiggleDistance = [userDefaults floatForKey:JiggleDistanceDefaultsKey];
		if (jiggleDistance < 0.0f)
			jiggleDistance = 0.0f;
		if (jiggleDistance > 20.0f)
			jiggleDistance = 20.0f;

		onlyWithCPUUsage = [userDefaults boolForKey:OnlyWithCPUUsageDefaultsKey];
		cpuUsageThreshold = (int)[userDefaults integerForKey:CPUUsageThresholdDefaultsKey];

		onlyWithRemovableWritableDisks = [userDefaults boolForKey:OnlyWithRemovableWritableDisksDefaultsKey];

		onlyWithMusicPlaying = [userDefaults boolForKey:OnlyWithMusicPlayingDefaultsKey];

		onlyWithApplicationsNamedX = [userDefaults boolForKey:OnlyWithApplicationsNamedXDefaultsKey];
		onlyWithIdentityTag = (int)[userDefaults integerForKey:OnlyWithIdentityDefaultsKey];
		applicationNameComponent = [[userDefaults stringForKey:ApplicationNameComponentDefaultsKey] copy];
		applicationNameComponents = nil;

		notWhenScreenLocked = [userDefaults boolForKey:NotWhenScreenLockedDefaultsKey];

		notOnBattery = [userDefaults boolForKey:NotOnBatteryDefaultsKey];

		notWithFrontAppsNamedX = [userDefaults boolForKey:NotWithFrontAppsNamedXDefaultsKey];
		frontAppNameComponent = [[userDefaults stringForKey:FrontAppNameComponentDefaultsKey] copy];
		frontAppNameComponents = nil;
	}

	return self;
}

- (void)setJiggleTimeTextfieldString
{
	if (jiggleSeconds < 60)
		[jiggleTimeTextfield setStringValue:[NSString stringWithFormat:@"(Set to %d seconds)", jiggleSeconds]];
	else if (jiggleSeconds == 60)
		[jiggleTimeTextfield setStringValue:@"(Set to 1 minute)"];
	else if (jiggleSeconds < 60 * 60)
		[jiggleTimeTextfield setStringValue:[NSString stringWithFormat:@"(Set to %.1f minutes)", jiggleSeconds / 60.0]];
	else if (jiggleSeconds == 60 * 60)
		[jiggleTimeTextfield setStringValue:@"(Set to 1 hour)"];
	else
		[jiggleTimeTextfield setStringValue:[NSString stringWithFormat:@"(Set to %.1f hours)", jiggleSeconds / (60.0 * 60.0)]];
}

- (void)showWindow
{
    if (!preferencesWindow)
	{
		[[NSBundle mainBundle] loadNibNamed:@"Preferences" owner:self topLevelObjects:NULL];

		// We want command-W to close us, but we have no File menu, so we use a transparent button to make it work
		[invisibleCloseButton setTransparent:YES];
		
		// Set up our launch on login checkbox, which is not backed by a pref kept by us
		[launchOnLoginCheckbox setState:([self launchOnLogin] ? NSControlStateValueOn : NSControlStateValueOff)];
		
		// Set the jiggle time slider.  It has values from 0 to 5, with ticks at each integer, for 5 secs, 1 min, 5 min, 1 hour, 5 hours, and 24 hours.
		// We treat each segment of that slider range as an independent linear scale, so it's a bit complicated...
		if (jiggleSeconds < 60)
			[jiggleTimeSlider setFloatValue:(jiggleSeconds - 5) / (60.0 - 5.0)];													// 5 seconds to 60 seconds
		else if (jiggleSeconds < 60 * 5)
			[jiggleTimeSlider setFloatValue:(jiggleSeconds - 60) / (60.0 * 5.0 - 60.0) + 1.0];										// 1 minute to 5 minutes
		else if (jiggleSeconds < 60 * 60)
			[jiggleTimeSlider setFloatValue:(jiggleSeconds - 60 * 5) / (60.0 * 60.0 - 60.0 * 5) + 2.0];								// 5 minutes to 1 hour
		else if (jiggleSeconds < 60 * 60 * 5)
			[jiggleTimeSlider setFloatValue:(jiggleSeconds - 60 * 60) / (60.0 * 60.0 * 5.0 - 60.0 * 60.0) + 3.0];					// 1 hour to 5 hours
		else
			[jiggleTimeSlider setFloatValue:(jiggleSeconds - 60 * 60 * 5.0) / (60.0 * 60.0 * 24.0 - 60.0 * 60.0 * 5.0) + 4.0];		// 5 hours to 24 hours
		
		// Set other control states
		[self setJiggleTimeTextfieldString];
		[showJigglerIconWhenJigglingButton setState:showJigglerIconWhenJiggling];
		[jiggleOnlyWhenIdleRadio selectCellWithTag:(jiggleOnlyWhenIdle ? 1 : 0)];
		
		[jiggleStyleRadio selectCellWithTag:jiggleStyle];
        [jiggleDistanceSlider setEnabled:(jiggleStyle == 0)];
		[jiggleDistanceSlider setFloatValue:jiggleDistance];
		
		[onlyWithCPUUsageCheckbox setState:onlyWithCPUUsage];
        [cpuUsageSlider setEnabled:onlyWithCPUUsage];
		[cpuUsageSlider setIntValue:cpuUsageThreshold];
		[cpuUsageTextfield setStringValue:[NSString stringWithFormat:@"%d%%", cpuUsageThreshold]];
		
		[onlyWithRemovableWritableDisksCheckbox setState:onlyWithRemovableWritableDisks];
        
		[onlyWithMusicPlayingCheckbox setState:onlyWithMusicPlaying];
        
		[onlyWithApplicationsNamedXCheckbox setState:(onlyWithApplicationsNamedX && [applicationNameComponent length])];
        [onlyWithIdentityPopUp selectItemWithTag:onlyWithIdentityTag];
        [onlyWithIdentityPopUp setEnabled:onlyWithApplicationsNamedX];
		[applicationNameComponentTextfield setStringValue:applicationNameComponent];
        [applicationNameComponentTextfield setEnabled:onlyWithApplicationsNamedX];
        
		[notWhenScreenLockedCheckbox setState:notWhenScreenLocked];
        
		[notOnBatteryCheckbox setState:notOnBattery];
        
		[notWithFrontAppsNamedXCheckbox setState:(notWithFrontAppsNamedX && [frontAppNameComponent length])];
		[frontAppsNameComponentTextfield setStringValue:frontAppNameComponent];
        [frontAppsNameComponentTextfield setEnabled:notWithFrontAppsNamedX];
        
		[preferencesWindow centerOnPrimaryScreen];
		[preferencesWindow setReleasedWhenClosed:NO];
	}
	
	[NSApp activateIgnoringOtherApps:YES];
    [preferencesWindow makeKeyAndOrderFront:nil];
	[preferencesWindow makeFirstResponder:preferencesWindow];
}

- (int)jiggleSeconds
{
	return jiggleSeconds;
}

- (BOOL)showJigglerIconWhenJiggling
{
	return showJigglerIconWhenJiggling;
}

- (BOOL)jiggleOnlyWhenIdle
{
	return jiggleOnlyWhenIdle;
}

- (int)jiggleStyle
{
	return jiggleStyle;
}

- (int)jiggleDistance
{
	// Slider is 0..20 (float); we return a pixel tolerance that grows quadratically.
	// The "+ 2" floor used to be "+ 10", but users running activity-sensitive apps
	// (Teams, Slack) asked for a smaller minimum so the cursor barely moves while
	// still registering as motion (issue #43).  Quadratic shape keeps fine control
	// at low slider values and large reach at high values.
	return (int)(jiggleDistance * jiggleDistance + 2);
}

- (BOOL)onlyWithCPUUsage
{
	return onlyWithCPUUsage;
}

- (int)cpuUsageThreshold
{
    return cpuUsageThreshold;
}

- (BOOL)onlyWithRemovableWritableDisks
{
	return onlyWithRemovableWritableDisks;
}

- (BOOL)onlyWithMusicPlaying
{
	return onlyWithMusicPlaying;
}

- (BOOL)onlyWithApplicationsNamedX
{
	return onlyWithApplicationsNamedX;
}

- (int)onlyWithIdentityTag
{
    return onlyWithIdentityTag;
}

- (NSArray *)applicationNameComponents
{
	if (!applicationNameComponents && [applicationNameComponent length])
	{
		NSMutableArray *newAppNameComponents = [[NSMutableArray alloc] init];
		NSArray *uncorrectedComponents = [applicationNameComponent componentsSeparatedByString:@","];
		NSCharacterSet *trimSet = [NSCharacterSet characterSetWithCharactersInString:@" \t\""];
		int i, c;
		
		for (i = 0, c = (int)[uncorrectedComponents count]; i < c; ++i)
		{
			NSString *uncorrectedComponent = uncorrectedComponents[i];
			NSString *correctedString = [uncorrectedComponent stringByTrimmingCharactersInSet:trimSet];
			
			if ([correctedString length])
				[newAppNameComponents addObject:correctedString];
		}
		
		applicationNameComponents = (NSArray *)newAppNameComponents;
	}
	
	return applicationNameComponents;
}

- (BOOL)notWhenScreenLocked
{
	return notWhenScreenLocked;
}

- (BOOL)notOnBattery
{
	return notOnBattery;
}

- (BOOL)notWithFrontAppsNamedX
{
	return notWithFrontAppsNamedX;
}

- (NSArray *)frontAppNameComponents
{
	if (!frontAppNameComponents && [frontAppNameComponent length])
	{
		NSMutableArray *newAppNameComponents = [[NSMutableArray alloc] init];
		NSArray *uncorrectedComponents = [frontAppNameComponent componentsSeparatedByString:@","];
		NSCharacterSet *trimSet = [NSCharacterSet characterSetWithCharactersInString:@" \t\""];
		int i, c;
		
		for (i = 0, c = (int)[uncorrectedComponents count]; i < c; ++i)
		{
			NSString *uncorrectedComponent = uncorrectedComponents[i];
			NSString *correctedString = [uncorrectedComponent stringByTrimmingCharactersInSet:trimSet];
			
			if ([correctedString length])
				[newAppNameComponents addObject:correctedString];
		}
		
		frontAppNameComponents = (NSArray *)newAppNameComponents;
	}
	
	return frontAppNameComponents;
}

- (IBAction)jiggleTimeChanged:(id)sender
{
	float newValue = [sender floatValue];
	int newSeconds;
	
	if (fabs(round(newValue) - newValue) < 0.006)
		newValue = round(newValue);
	
	if (newValue < 1.0)
		newSeconds = round((newValue - 0.0) * 55.0 + 5.0);										// 0 to 1   ->   5 seconds to 60 seconds
	else if (newValue < 2.0)
		newSeconds = round((newValue - 1.0) * 60.0 * 4.0 + 60.0);								// 1 to 2   ->   1 minute to 5 minutes
	else if (newValue < 3.0)
		newSeconds = round((newValue - 2.0) * 60.0 * 55.0 + 60.0 * 5.0);						// 2 to 3   ->   5 minutes to 60 minutes
	else if (newValue < 4.0)
		newSeconds = round((newValue - 3.0) * 60.0 * 60.0 * 4.0 + 60.0 * 60.0);					// 3 to 4   ->   1 hour to 5 hours
	else
		newSeconds = round((newValue - 4.0) * 60.0 * 60.0 * 19.0 + 60.0 * 60.0 * 5.0);			// 4 to 5   ->   5 hours to 24 hours
	
	if (newSeconds != jiggleSeconds)
	{
		jiggleSeconds = newSeconds;
		[[NSUserDefaults standardUserDefaults] setInteger:jiggleSeconds forKey:JiggleSecondsDefaultsKey];
		
		[self setJiggleTimeTextfieldString];
	}
}

- (IBAction)showJigglerIconWhenJigglingChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != showJigglerIconWhenJiggling)
	{
		showJigglerIconWhenJiggling = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:ShowIconWhenJigglingDefaultsKey];
	}
}

- (IBAction)jiggleOnlyWhenIdleChanged:(id)sender
{
	BOOL newState = ([[sender selectedCell] tag] ? YES : NO);
	
	if (newState != jiggleOnlyWhenIdle)
	{
		jiggleOnlyWhenIdle = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:JiggleOnlyWhenIdleDefaultsKey];
	}
}

- (IBAction)jiggleStyleChanged:(id)sender
{
	int newState = (int)[[sender selectedCell] tag];
	
	if (newState != jiggleStyle)
	{
		jiggleStyle = newState;
		[[NSUserDefaults standardUserDefaults] setInteger:newState forKey:JiggleStyleDefaultsKey];
		
        [jiggleDistanceSlider setEnabled:(jiggleStyle == 0)];
	}
}

- (IBAction)jiggleDistanceSliderChanged:(id)sender
{
    float newValue = [jiggleDistanceSlider floatValue];
    
    if (newValue != jiggleDistance)
    {
        jiggleDistance = newValue;
		[[NSUserDefaults standardUserDefaults] setFloat:jiggleDistance forKey:JiggleDistanceDefaultsKey];
    }
}

- (IBAction)onlyWithCPUUsageChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != onlyWithCPUUsage)
	{
		onlyWithCPUUsage = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:OnlyWithCPUUsageDefaultsKey];
        
        [cpuUsageSlider setEnabled:onlyWithCPUUsage];
	}
}

- (IBAction)cpuUsageSliderChanged:(id)sender
{
    int newValue = [cpuUsageSlider intValue];
    
    if (newValue != cpuUsageThreshold)
    {
        cpuUsageThreshold = newValue;
		[[NSUserDefaults standardUserDefaults] setInteger:newValue forKey:CPUUsageThresholdDefaultsKey];
        
        [cpuUsageTextfield setStringValue:[NSString stringWithFormat:@"%d%%", newValue]];
    }
}

- (IBAction)onlyWithRemovableWritableDisksChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != onlyWithRemovableWritableDisks)
	{
		onlyWithRemovableWritableDisks = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:OnlyWithRemovableWritableDisksDefaultsKey];
	}
}

- (IBAction)onlyWithMusicPlayingChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != onlyWithMusicPlaying)
	{
		onlyWithMusicPlaying = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:OnlyWithMusicPlayingDefaultsKey];
	}
}

- (IBAction)onlyWithApplicationsNamedXChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != onlyWithApplicationsNamedX)
	{
		onlyWithApplicationsNamedX = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:OnlyWithApplicationsNamedXDefaultsKey];
		
        [onlyWithIdentityPopUp setEnabled:onlyWithApplicationsNamedX];
        [applicationNameComponentTextfield setEnabled:onlyWithApplicationsNamedX];
        
		if (onlyWithApplicationsNamedX)
		{
			[applicationNameComponentTextfield selectText:nil];
			[preferencesWindow makeFirstResponder:applicationNameComponentTextfield];
		}
	}
}

- (IBAction)onlyWithIdentityPopUpChanged:(id)sender
{
	int newTag = (int)[[onlyWithIdentityPopUp selectedItem] tag];
	
	if (newTag != onlyWithIdentityTag)
	{
		onlyWithIdentityTag = newTag;
		[[NSUserDefaults standardUserDefaults] setInteger:newTag forKey:OnlyWithIdentityDefaultsKey];
	}
}

- (IBAction)onlyWithFrontAppsNamedXChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != notWithFrontAppsNamedX)
	{
		notWithFrontAppsNamedX = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:NotWithFrontAppsNamedXDefaultsKey];
		
        [frontAppsNameComponentTextfield setEnabled:notWithFrontAppsNamedX];
        
		if (notWithFrontAppsNamedX)
		{
			[frontAppsNameComponentTextfield selectText:nil];
			[preferencesWindow makeFirstResponder:frontAppsNameComponentTextfield];
		}
	}
}

- (void)controlTextDidChange:(NSNotification *)aNotification
{
	id object = [aNotification object];
	
	if (object == applicationNameComponentTextfield)
	{
		applicationNameComponent = [[applicationNameComponentTextfield stringValue] copy];
		applicationNameComponents = nil;

		[[NSUserDefaults standardUserDefaults] setObject:applicationNameComponent forKey:ApplicationNameComponentDefaultsKey];
	}
	if (object == frontAppsNameComponentTextfield)
	{
		frontAppNameComponent = [[frontAppsNameComponentTextfield stringValue] copy];
		frontAppNameComponents = nil;

		[[NSUserDefaults standardUserDefaults] setObject:frontAppNameComponent forKey:FrontAppNameComponentDefaultsKey];
	}
}

- (IBAction)notWhenScreenLockedChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != notWhenScreenLocked)
	{
		notWhenScreenLocked = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:NotWhenScreenLockedDefaultsKey];
	}
}

- (IBAction)notOnBatteryChanged:(id)sender
{
	BOOL newState = [sender state];
	
	if (newState != notOnBattery)
	{
		notOnBattery = newState;
		[[NSUserDefaults standardUserDefaults] setBool:newState forKey:NotOnBatteryDefaultsKey];
	}
}

#pragma mark - Launch on Login

// On macOS 13+ this is the supported API and the only one that works with sandboxed apps
// or apps distributed via the Mac App Store.  On 10.15-12.x we fall back to the deprecated
// LSSharedFileList* API (the legacy path was contributed by Catalin Stan, see
// http://stackoverflow.com/questions/23625255/).

- (BOOL)launchOnLogin
{
	if (@available(macOS 13.0, *))
		return [SMAppService mainAppService].status == SMAppServiceStatusEnabled;

	return [self legacyLaunchOnLogin];
}

- (void)setLaunchOnLogin:(BOOL)launchOnLogin
{
	if (@available(macOS 13.0, *))
	{
		SMAppService *service = [SMAppService mainAppService];
		NSError *error = nil;

		if (launchOnLogin)
			[service registerAndReturnError:&error];
		else
			[service unregisterAndReturnError:&error];

		if (error)
			NSLog(@"[Jiggler] SMAppService %@ failed: %@", launchOnLogin ? @"register" : @"unregister", error.localizedDescription);
		return;
	}

	[self legacySetLaunchOnLogin:launchOnLogin];
}

#pragma mark - Legacy Launch on Login (macOS 10.15-12.x)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"

- (BOOL)legacyLaunchOnLogin
{
	BOOL loginItemFound = NO;
	LSSharedFileListRef loginItemsListRef = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);

	if (loginItemsListRef)
	{
		NSArray *loginItems = (NSArray *)CFBridgingRelease(LSSharedFileListCopySnapshot(loginItemsListRef, NULL));
		NSURL *bundleURL = [NSURL fileURLWithPath:[[NSBundle mainBundle] bundlePath]];

		for (id item in loginItems)
		{
			LSSharedFileListItemRef itemRef = (__bridge LSSharedFileListItemRef)item;
			NSURL *itemURL = (NSURL *)CFBridgingRelease(LSSharedFileListItemCopyResolvedURL(itemRef, 0, NULL));

			if ([itemURL isEqual:bundleURL])
			{
				loginItemFound = YES;
				break;
			}
		}

		CFRelease(loginItemsListRef);
	}

	return loginItemFound;
}

- (void)legacySetLaunchOnLogin:(BOOL)launchOnLogin
{
	LSSharedFileListRef loginItemsListRef = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
	if (!loginItemsListRef) return;

	NSURL *bundleURL = [NSURL fileURLWithPath:[[NSBundle mainBundle] bundlePath]];

	if (launchOnLogin)
	{
		NSDictionary *properties = @{@"com.apple.loginitem.HideOnLaunch": @YES};
		LSSharedFileListItemRef itemRef = LSSharedFileListInsertItemURL(loginItemsListRef, kLSSharedFileListItemLast, NULL, NULL, (__bridge CFURLRef)bundleURL, (__bridge CFDictionaryRef)properties, NULL);
		if (itemRef)
			CFRelease(itemRef);
	}
	else
	{
		NSArray *loginItems = (NSArray *)CFBridgingRelease(LSSharedFileListCopySnapshot(loginItemsListRef, NULL));

		for (id item in loginItems)
		{
			LSSharedFileListItemRef itemRef = (__bridge LSSharedFileListItemRef)item;
			NSURL *itemURL = (NSURL *)CFBridgingRelease(LSSharedFileListItemCopyResolvedURL(itemRef, 0, NULL));

			if ([itemURL isEqual:bundleURL])
				LSSharedFileListItemRemove(loginItemsListRef, itemRef);
		}
	}

	CFRelease(loginItemsListRef);
}

#pragma clang diagnostic pop

- (IBAction)launchOnLoginChanged:(id)sender
{
	BOOL newState = [sender state];
	
	[self setLaunchOnLogin:newState];
}

@end