1581 lines
51 KiB
Objective-C
1581 lines
51 KiB
Objective-C
//
|
||
//
|
||
// AppDelegate.m
|
||
// iTunes Volume Control
|
||
//
|
||
// Created by Andrea Alberti on 25.12.12.
|
||
// Copyright (c) 2012 Andrea Alberti. All rights reserved.
|
||
//
|
||
|
||
#import "AppDelegate.h"
|
||
#import "SystemVolume.h"
|
||
#import "AccessibilityDialog.h"
|
||
#import "TahoeVolumeHUD.h"
|
||
|
||
#import <IOKit/hidsystem/ev_keymap.h>
|
||
#import <ServiceManagement/ServiceManagement.h>
|
||
|
||
#import "OSD.h"
|
||
|
||
//This will handle signals for us, specifically SIGTERM.
|
||
void handleSIGTERM(int sig) {
|
||
[NSApp terminate:nil];
|
||
}
|
||
|
||
#define USE_APPLE_CMD_MODIFIER_MENU_ID 3
|
||
#define LOCK_SYSTEM_AND_PLAYER_VOLUME_ID 9
|
||
#define START_AT_LOGIN_ID 4
|
||
#define AUTOMATIC_UPDATES_ID 8
|
||
#define PLAY_SOUND_FEEDBACK_ID 7
|
||
#define TAPPING_ID 1
|
||
#define HIDE_FROM_STATUS_BAR_ID 5
|
||
#define HIDE_VOLUME_WINDOW_ID 6
|
||
|
||
#pragma mark - Tapping key stroke events
|
||
|
||
CGEventRef event_tap_callback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)
|
||
{
|
||
// Keep track of how many consecutive timeouts we’ve seen.
|
||
// macOS fires kCGEventTapDisabledByTimeout when it thinks the tap is “hung”
|
||
// (e.g. if the app is suspended by TCC while showing an Apple Events dialog).
|
||
// We auto-resume a few times, then give up and alert the user if it persists.
|
||
static int timeout_count = 0;
|
||
|
||
if (type == kCGEventTapDisabledByTimeout) {
|
||
if (timeout_count < 5) {
|
||
// This handles “false positives” that occur when macOS temporarily
|
||
// suspends the app for Apple Events permission prompts.
|
||
timeout_count++;
|
||
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)),
|
||
dispatch_get_main_queue(), ^{
|
||
// Try to resume tapping automatically.
|
||
AppDelegate *app = (__bridge AppDelegate *)refcon;
|
||
if ([app Tapping]) { // guard if user disabled it manually
|
||
[app setTapping:YES]; // attempt to re-enable tap
|
||
}
|
||
});
|
||
} else {
|
||
// After 5 consecutive timeouts, assume it’s a real problem
|
||
// (e.g. the tap logic is genuinely unresponsive).
|
||
// Disable tapping and inform the user instead of looping forever.
|
||
timeout_count = 0; // reset counter for next time
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
AppDelegate *app = (__bridge AppDelegate *)refcon;
|
||
[app setTapping:NO];
|
||
|
||
NSAlert *alert = [[NSAlert alloc] init];
|
||
alert.messageText = @"Tapping Disabled";
|
||
alert.informativeText = @"Volume Control lost its ability to monitor volume keys because it became unresponsive. "
|
||
@"Tapping has been turned off. You can re-enable it from the menu.";
|
||
|
||
[alert addButtonWithTitle:@"OK"];
|
||
[alert addButtonWithTitle:@"Report Issue on GitHub"];
|
||
|
||
NSModalResponse response = [alert runModal];
|
||
if (response == NSAlertSecondButtonReturn) {
|
||
[[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:
|
||
@"https://github.com/alberti42/Volume-Control/issues"]];
|
||
}
|
||
});
|
||
}
|
||
return event; // always return quickly so system input isn’t blocked
|
||
}
|
||
|
||
// Pass through events we don't care about
|
||
if (type != NX_SYSDEFINED) return event;
|
||
|
||
NSEvent *sysEvent = [NSEvent eventWithCGEvent:event];
|
||
if ([sysEvent subtype] != NX_SUBTYPE_AUX_CONTROL_BUTTONS) return event;
|
||
|
||
// Extract key info
|
||
int keyFlags = ([sysEvent data1] & 0x0000FFFF);
|
||
int keyCode = (([sysEvent data1] & 0xFFFF0000) >> 16);
|
||
int keyState = (((keyFlags & 0xFF00) >> 8)) == 0xA;
|
||
bool keyIsRepeat = (keyFlags & 0x1);
|
||
CGEventFlags keyModifier = [sysEvent modifierFlags] | 0xFFFF;
|
||
|
||
// Decide here if it's a volume/mute event
|
||
BOOL isMediaKey = (keyCode == NX_KEYTYPE_MUTE ||
|
||
keyCode == NX_KEYTYPE_SOUND_UP ||
|
||
keyCode == NX_KEYTYPE_SOUND_DOWN);
|
||
|
||
if(isMediaKey /*&& keyModifier==1114111*/) {
|
||
// Hand off all actual logic to main thread
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
AppDelegate *app = (__bridge AppDelegate *)refcon;
|
||
[app handleAsynchronouslyTappedEventWithKeyCode:keyCode
|
||
keyState:keyState
|
||
keyIsRepeat:keyIsRepeat
|
||
keyModifier:keyModifier];
|
||
});
|
||
|
||
return NULL;
|
||
} else {
|
||
// Always return immediately to keep the system input flowing
|
||
return event;
|
||
}
|
||
}
|
||
|
||
|
||
#pragma mark - Class extension for status menu
|
||
|
||
@interface AppDelegate () <NSMenuDelegate>
|
||
{
|
||
//StatusItemView* _statusBarItemView;
|
||
NSTimer* _statusBarHideTimer;
|
||
NSPopover* _hideFromStatusBarHintPopover;
|
||
NSTextField* _hideFromStatusBarHintLabel;
|
||
NSTimer *_hideFromStatusBarHintPopoverUpdateTimer;
|
||
|
||
NSView* _hintView;
|
||
NSViewController* _hintVC;
|
||
|
||
NSTimer* accessibilityCheckTimer;
|
||
NSTimer* volumeRampTimer;
|
||
NSTimer* timerImgSpeaker;
|
||
NSTimer* checkPlayerTimer;
|
||
NSTimer* updateSystemVolumeTimer;
|
||
NSTimeInterval waitOverlayPanel;
|
||
bool fadeInAnimationReady;
|
||
|
||
// Event tap state
|
||
int _previousKeyCode;
|
||
BOOL _muteDown;
|
||
}
|
||
|
||
// Forward declare private methods
|
||
- (id)runningPlayer;
|
||
- (void)completeInitialization;
|
||
- (void)setVolumeUp:(bool)increase;
|
||
- (void) setItunesVolume:(NSInteger)volume;
|
||
- (void) setSpotifyVolume:(NSInteger)volume;
|
||
- (void) setSystemVolume:(NSInteger)volume;
|
||
- (void)stopVolumeRampTimer;
|
||
- (void)updatePercentages;
|
||
- (bool)createEventTap;
|
||
- (void)handleEventTapDisabledByUser;
|
||
|
||
@end
|
||
|
||
#pragma mark - Extention music applications
|
||
|
||
@implementation PlayerApplication
|
||
|
||
@synthesize currentVolume = _currentVolume;
|
||
@synthesize icon = _icon;
|
||
|
||
- (void) setCurrentVolume:(double)currentVolume
|
||
{
|
||
[self setDoubleVolume:currentVolume];
|
||
|
||
[musicPlayer setSoundVolume:round(currentVolume)];
|
||
}
|
||
|
||
- (double) currentVolume
|
||
{
|
||
double vol = [musicPlayer soundVolume];
|
||
|
||
if (fabs(vol-[self doubleVolume])<1)
|
||
{
|
||
vol = [self doubleVolume];
|
||
}
|
||
|
||
return vol;
|
||
}
|
||
|
||
- (void) nextTrack
|
||
{
|
||
return [musicPlayer nextTrack];
|
||
}
|
||
|
||
- (void) previousTrack
|
||
{
|
||
return [musicPlayer previousTrack];
|
||
}
|
||
|
||
- (void) playPause
|
||
{
|
||
return [musicPlayer playPause];
|
||
}
|
||
|
||
- (BOOL) isRunning
|
||
{
|
||
return [musicPlayer isRunning];
|
||
}
|
||
|
||
- (NSInteger) playerState
|
||
{
|
||
return [musicPlayer playerState];
|
||
}
|
||
|
||
-(id)initWithBundleIdentifier:(NSString*) bundleIdentifier andIcon:(NSImage*)icon {
|
||
if (self = [super init]) {
|
||
[self setCurrentVolume: -100];
|
||
[self setOldVolume: -1];
|
||
musicPlayer = [SBApplication applicationWithBundleIdentifier:bundleIdentifier];
|
||
[self setIcon:icon];
|
||
}
|
||
return self;
|
||
}
|
||
|
||
@end
|
||
|
||
#pragma mark - Implementation AppDelegate
|
||
|
||
@implementation AppDelegate
|
||
|
||
// @synthesize AppleRemoteConnected=_AppleRemoteConnected;
|
||
@synthesize StartAtLogin=_StartAtLogin;
|
||
@synthesize Tapping=_Tapping;
|
||
@synthesize UseAppleCMDModifier=_UseAppleCMDModifier;
|
||
@synthesize LockSystemAndPlayerVolume=_LockSystemAndPlayerVolume;
|
||
@synthesize AppleCMDModifierPressed=_AppleCMDModifierPressed;
|
||
@synthesize AutomaticUpdates=_AutomaticUpdates;
|
||
@synthesize hideFromStatusBar = _hideFromStatusBar;
|
||
@synthesize hideVolumeWindow = _hideVolumeWindow;
|
||
@synthesize loadIntroAtStart = _loadIntroAtStart;
|
||
@synthesize statusBar = _statusBar;
|
||
|
||
@synthesize iTunesBtn = _iTunesBtn;
|
||
@synthesize spotifyBtn = _spotifyBtn;
|
||
@synthesize systemBtn = _systemBtn;
|
||
@synthesize dopplerBtn = _dopplerBtn;
|
||
|
||
@synthesize iTunesPerc = _iTunesPerc;
|
||
@synthesize spotifyPerc = _spotifyPerc;
|
||
@synthesize systemPerc = _systemPerc;
|
||
@synthesize dopplerPerc = _dopplerPerc;
|
||
|
||
@synthesize sparkle_updater = _sparkle_updater;
|
||
|
||
@synthesize statusMenu = _statusMenu;
|
||
|
||
static NSTimeInterval volumeRampTimeInterval=0.01f;
|
||
static NSTimeInterval statusBarHideDelay=10.0f;
|
||
static NSTimeInterval checkPlayerTimeout=0.3f;
|
||
//static NSTimeInterval volumeLockSyncInterval=1.0f;
|
||
static NSTimeInterval updateSystemVolumeInterval=0.1f;
|
||
|
||
- (NSString *)helperBundleID {
|
||
return [[[NSBundle mainBundle] bundleIdentifier] stringByAppendingString:@"Helper"];
|
||
}
|
||
|
||
- (IBAction)terminate:(id)sender
|
||
{
|
||
if (eventTap && CFMachPortIsValid(eventTap)) {
|
||
if (CFMachPortIsValid(eventTap)) {
|
||
CFMachPortInvalidate(eventTap);
|
||
}
|
||
if (runLoopSource) {
|
||
CFRunLoopSourceInvalidate(runLoopSource);
|
||
CFRelease(runLoopSource);
|
||
runLoopSource = nil;
|
||
}
|
||
CFRelease(eventTap);
|
||
eventTap = nil;
|
||
}
|
||
|
||
[[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];
|
||
|
||
systemAudio = nil;
|
||
iTunes = nil;
|
||
spotify = nil;
|
||
doppler = nil;
|
||
|
||
_statusBar = nil;
|
||
|
||
accessibilityDialog = nil;
|
||
introWindowController = nil;
|
||
|
||
[volumeRampTimer invalidate];
|
||
volumeRampTimer = nil;
|
||
|
||
[checkPlayerTimer invalidate];
|
||
checkPlayerTimer = nil;
|
||
|
||
[timerImgSpeaker invalidate];
|
||
timerImgSpeaker = nil;
|
||
|
||
[updateSystemVolumeTimer invalidate];
|
||
updateSystemVolumeTimer = nil;
|
||
|
||
preferences = nil;
|
||
|
||
// IMPORTANT: Use [NSApp terminate:nil] for a clean exit.
|
||
// This ensures AppKit tears down the NSStatusItem properly
|
||
// and preserves the status bar icon position between launches.
|
||
// Simply returning or calling exit() would skip this cleanup
|
||
// and cause the icon to reset to the default position.
|
||
[NSApp terminate:nil];
|
||
}
|
||
|
||
- (void)updateStartAtLoginMenuItem
|
||
{
|
||
BOOL enabled = [self StartAtLogin];
|
||
NSMenuItem* menuItem = [self.statusMenu itemWithTag:START_AT_LOGIN_ID];
|
||
[menuItem setState:enabled ? NSControlStateValueOn : NSControlStateValueOff];
|
||
}
|
||
|
||
- (IBAction)toggleStartAtLogin:(id)sender {
|
||
BOOL currentlyEnabled = [self StartAtLogin];
|
||
|
||
if (currentlyEnabled) {
|
||
// User clicked to disable
|
||
[self setStartAtLogin:NO savePreferences:YES];
|
||
} else {
|
||
// User clicked to enable
|
||
[self setStartAtLogin:YES savePreferences:YES];
|
||
|
||
if (@available(macOS 13.0, *)) {
|
||
SMAppService *service = [SMAppService loginItemServiceWithIdentifier:[self helperBundleID]];
|
||
if (service.status == SMAppServiceStatusRequiresApproval) {
|
||
// TODO: prompt user to open System Settings
|
||
NSLog(@"Login item requires approval in System Settings → Login Items");
|
||
}
|
||
}
|
||
}
|
||
[self updateStartAtLoginMenuItem];
|
||
}
|
||
|
||
- (void)setStartAtLogin:(BOOL)enabled savePreferences:(BOOL)savePreferences
|
||
{
|
||
NSString *helperBundleID = [self helperBundleID];
|
||
|
||
if (@available(macOS 13.0, *)) {
|
||
SMAppService *service = [SMAppService loginItemServiceWithIdentifier:helperBundleID];
|
||
NSError *error = nil;
|
||
|
||
if (enabled) {
|
||
if (service.status != SMAppServiceStatusEnabled) {
|
||
if (![service registerAndReturnError:&error]) {
|
||
NSLog(@"[Volume Control] Error registering login item: %@", error.localizedDescription);
|
||
}
|
||
}
|
||
} else {
|
||
if (service.status != SMAppServiceStatusNotRegistered) {
|
||
if (![service unregisterAndReturnError:&error]) {
|
||
NSLog(@"[Volume Control] Error unregistering login item: %@", error.localizedDescription);
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// Legacy fallback (macOS 12 and older)
|
||
#pragma clang diagnostic push
|
||
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||
if (!SMLoginItemSetEnabled((__bridge CFStringRef)helperBundleID, enabled)) {
|
||
NSLog(@"[Volume Control] SMLoginItemSetEnabled failed.");
|
||
}
|
||
#pragma clang diagnostic pop
|
||
}
|
||
|
||
if (savePreferences) {
|
||
[preferences setBool:enabled forKey:@"StartAtLoginPreference"];
|
||
}
|
||
|
||
[self updateStartAtLoginMenuItem];
|
||
}
|
||
|
||
- (bool)StartAtLogin
|
||
{
|
||
// Enabled → the login item is registered and will launch at login.
|
||
// NotRegistered → no login item exists.
|
||
// RequiresApproval → your app tried to register the login item, but the user hasn’t granted approval yet in System Settings
|
||
//
|
||
// sfltool dumpbtm → dump the entire macOS database of login authorizations for inspection from the command line.
|
||
// sfltool resetbtm → reset the entire macOS database of login authorizations. Be careful: the reset applies to all apps, not only this one
|
||
|
||
NSString *helperBundleID = [self helperBundleID];
|
||
|
||
if (@available(macOS 13.0, *)) {
|
||
SMAppService *service = [SMAppService loginItemServiceWithIdentifier:helperBundleID];
|
||
|
||
// In case of RequiresApproval, it means the user requested to start the app at login, but the request has not been approved yet.
|
||
// In this case, "Start at login" should be assumed to be checked because it would confuse the user to have click on the toggle
|
||
// and see no changes.
|
||
return (service.status == SMAppServiceStatusEnabled ||
|
||
service.status == SMAppServiceStatusRequiresApproval);
|
||
} else {
|
||
return [preferences boolForKey:@"StartAtLoginPreference"];
|
||
}
|
||
}
|
||
|
||
- (void)wasAuthorized
|
||
{
|
||
[accessibilityDialog close];
|
||
accessibilityDialog = nil;
|
||
|
||
[self completeInitialization];
|
||
}
|
||
|
||
- (void)stopVolumeRampTimer
|
||
{
|
||
[volumeRampTimer invalidate];
|
||
volumeRampTimer=nil;
|
||
[self emitAcousticFeedback];
|
||
|
||
checkPlayerTimer = [NSTimer timerWithTimeInterval:checkPlayerTimeout target:self selector:@selector(resetCurrentPlayer:) userInfo:nil repeats:NO];
|
||
[[NSRunLoop mainRunLoop] addTimer:checkPlayerTimer forMode:NSRunLoopCommonModes];
|
||
}
|
||
|
||
- (void)rampVolumeUp:(NSTimer*)theTimer
|
||
{
|
||
[self setVolumeUp:true];
|
||
}
|
||
|
||
- (void)rampVolumeDown:(NSTimer*)theTimer
|
||
{
|
||
[self setVolumeUp:false];
|
||
}
|
||
|
||
- (void)checkAccessibilityTrust:(NSTimer *)timer {
|
||
if (eventTap && ![self isTappingTrusted]) {
|
||
// NSLog(@"Accessibility permission revoked during runtime. Cleaning up tap.");
|
||
[self handleEventTapDisabledByUser];
|
||
}
|
||
}
|
||
|
||
- (BOOL)isTappingTrusted {
|
||
// Key must be a CFStringRef (no need to retain/release since it's a constant)
|
||
const void *keys[] = { kAXTrustedCheckOptionPrompt };
|
||
// Value must be a CFBooleanRef
|
||
const void *values[] = { kCFBooleanFalse };
|
||
|
||
CFDictionaryRef options = CFDictionaryCreate(
|
||
kCFAllocatorDefault, // allocator
|
||
keys, // keys
|
||
values, // values
|
||
1, // number of keys/values
|
||
&kCFTypeDictionaryKeyCallBacks, // standard key callbacks
|
||
&kCFTypeDictionaryValueCallBacks // standard value callbacks
|
||
);
|
||
|
||
BOOL trusted = AXIsProcessTrustedWithOptions(options);
|
||
CFRelease(options);
|
||
|
||
return trusted;
|
||
}
|
||
|
||
- (BOOL)tryCreateEventTap {
|
||
BOOL trusted = [self isTappingTrusted];
|
||
|
||
if (trusted) {
|
||
if ([self createEventTap]) {
|
||
return YES;
|
||
}
|
||
}
|
||
return NO;
|
||
}
|
||
|
||
- (bool)createEventTap
|
||
{
|
||
if (eventTap != nil && CFMachPortIsValid(eventTap)) {
|
||
CFMachPortInvalidate(eventTap);
|
||
CFRunLoopSourceInvalidate(runLoopSource);
|
||
CFRelease(eventTap);
|
||
CFRelease(runLoopSource);
|
||
eventTap = nil;
|
||
runLoopSource = nil;
|
||
}
|
||
|
||
CGEventMask eventMask = CGEventMaskBit(NX_SYSDEFINED);
|
||
eventTap = CGEventTapCreate(kCGSessionEventTap,
|
||
kCGHeadInsertEventTap,
|
||
kCGEventTapOptionDefault,
|
||
eventMask,
|
||
event_tap_callback,
|
||
(__bridge void *)self);
|
||
|
||
if (eventTap != nil) {
|
||
runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
|
||
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
|
||
|
||
// Start safety timer to monitor trust state
|
||
accessibilityCheckTimer = [NSTimer scheduledTimerWithTimeInterval:2.0
|
||
target:self
|
||
selector:@selector(checkAccessibilityTrust:)
|
||
userInfo:nil
|
||
repeats:YES];
|
||
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
- (void)handleEventTapDisabledByUser {
|
||
if (eventTap && CFMachPortIsValid(eventTap)) {
|
||
if (CFMachPortIsValid(eventTap)) {
|
||
CFMachPortInvalidate(eventTap);
|
||
}
|
||
if (runLoopSource) {
|
||
CFRunLoopSourceInvalidate(runLoopSource);
|
||
CFRelease(runLoopSource);
|
||
runLoopSource = nil;
|
||
}
|
||
CFRelease(eventTap);
|
||
eventTap = nil;
|
||
}
|
||
|
||
if (accessibilityCheckTimer) {
|
||
[accessibilityCheckTimer invalidate];
|
||
accessibilityCheckTimer = nil;
|
||
}
|
||
|
||
// Update toggle state to reflect reality
|
||
[self setTapping:NO];
|
||
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
NSAlert *alert = [[NSAlert alloc] init];
|
||
alert.messageText = @"Accessibility Permission Revoked";
|
||
alert.informativeText = @"Volume Control has lost permission to monitor keyboard events. "
|
||
@"Keyboard input may stop working until you restore permission in "
|
||
@"System Settings → Privacy & Security → Accessibility.";
|
||
[alert runModal];
|
||
});
|
||
}
|
||
|
||
- (void)handleAsynchronouslyTappedEventWithKeyCode:(int)keyCode
|
||
keyState:(BOOL)keyState
|
||
keyIsRepeat:(BOOL)keyIsRepeat
|
||
keyModifier:(CGEventFlags)keyModifier
|
||
{
|
||
[self setAppleCMDModifierPressed:(keyModifier & NX_COMMANDMASK) == NX_COMMANDMASK];
|
||
|
||
switch (keyCode) {
|
||
case NX_KEYTYPE_MUTE:
|
||
if (_previousKeyCode != keyCode && self->volumeRampTimer) {
|
||
[self stopVolumeRampTimer];
|
||
}
|
||
_previousKeyCode = keyCode;
|
||
|
||
if (keyState == 1) {
|
||
_muteDown = true;
|
||
[self MuteVol];
|
||
} else {
|
||
_muteDown = false;
|
||
}
|
||
break;
|
||
|
||
case NX_KEYTYPE_SOUND_UP:
|
||
case NX_KEYTYPE_SOUND_DOWN:
|
||
if (!_muteDown) {
|
||
if (_previousKeyCode != keyCode && self->volumeRampTimer) {
|
||
[self stopVolumeRampTimer];
|
||
}
|
||
_previousKeyCode = keyCode;
|
||
|
||
if (keyState == 1) {
|
||
if (!self->volumeRampTimer) {
|
||
BOOL increase = (keyCode == NX_KEYTYPE_SOUND_UP);
|
||
[self adjustVolumeUp:increase ramp:keyIsRepeat];
|
||
}
|
||
} else {
|
||
if (self->volumeRampTimer) {
|
||
[self stopVolumeRampTimer];
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
-(void) sendMediaKey: (int)key {
|
||
// create and send down key event
|
||
NSEvent* key_event;
|
||
|
||
key_event = [NSEvent otherEventWithType:NSEventTypeSystemDefined location:CGPointZero modifierFlags:0xa00 timestamp:0 windowNumber:0 context:0 subtype:8 data1:((key << 16) | (0xa << 8)) data2:-1];
|
||
CGEventPost(0, key_event.CGEvent);
|
||
// NSLog(@"%d keycode (down) sent",key);
|
||
|
||
// create and send up key event
|
||
key_event = [NSEvent otherEventWithType:NSEventTypeSystemDefined location:CGPointZero modifierFlags:0xb00 timestamp:0 windowNumber:0 context:0 subtype:8 data1:((key << 16) | (0xb << 8)) data2:-1];
|
||
CGEventPost(0, key_event.CGEvent);
|
||
// NSLog(@"%d keycode (up) sent",key);
|
||
}
|
||
|
||
/*
|
||
- (void)PlayPauseMusic
|
||
{
|
||
[self sendMediaKey:NX_KEYTYPE_PLAY];
|
||
}
|
||
|
||
- (void)NextTrackMusic
|
||
{
|
||
[self sendMediaKey:NX_KEYTYPE_NEXT];
|
||
}
|
||
|
||
- (void)PreviousTrackMusic
|
||
{
|
||
[self sendMediaKey:NX_KEYTYPE_PREVIOUS];
|
||
}
|
||
*/
|
||
|
||
- (void)MuteVol
|
||
{
|
||
id runningPlayerPtr = [self runningPlayer];
|
||
|
||
if (runningPlayerPtr != nil)
|
||
{
|
||
if([runningPlayerPtr oldVolume]<0)
|
||
{
|
||
[runningPlayerPtr setOldVolume:[runningPlayerPtr currentVolume]];
|
||
[runningPlayerPtr setCurrentVolume:0];
|
||
|
||
if (_LockSystemAndPlayerVolume && runningPlayerPtr != systemAudio) {
|
||
[systemAudio setOldVolume:[systemAudio currentVolume]];
|
||
[systemAudio setCurrentVolume:0];
|
||
}
|
||
|
||
if(!_hideVolumeWindow){
|
||
if (@available(macOS 16.0, *)) {
|
||
// On Tahoe, show the new popover HUD.
|
||
[[TahoeVolumeHUD sharedManager] showHUDWithVolume:0 usingMusicPlayer:runningPlayerPtr andLabel:[systemAudio getDefaultOutputDeviceName] anchoredToStatusButton:self.statusBar.button];
|
||
} else {
|
||
// On older systems, use the classic OSD.
|
||
id osdMgr = [self->OSDManager sharedManager];
|
||
if (osdMgr) {
|
||
[osdMgr showImage:OSDGraphicSpeakerMute onDisplayID:CGSMainDisplayID() priority:OSDPriorityDefault msecUntilFade:1000 filledChiclets:0 totalChiclets:(unsigned int)100 locked:NO];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
[runningPlayerPtr setCurrentVolume:[runningPlayerPtr oldVolume]];
|
||
|
||
if (_LockSystemAndPlayerVolume && runningPlayerPtr != systemAudio) {
|
||
[systemAudio setCurrentVolume:[systemAudio oldVolume]];
|
||
}
|
||
|
||
if(!_hideVolumeWindow)
|
||
{
|
||
if (@available(macOS 16.0, *)) {
|
||
// On Tahoe, show the new popover HUD.
|
||
[[TahoeVolumeHUD sharedManager] showHUDWithVolume:[runningPlayerPtr oldVolume] usingMusicPlayer:runningPlayerPtr andLabel:[systemAudio getDefaultOutputDeviceName] anchoredToStatusButton:self.statusBar.button];
|
||
} else {
|
||
// On older systems, use the classic OSD.
|
||
id osdMgr = [self->OSDManager sharedManager];
|
||
if (osdMgr) {
|
||
[osdMgr showImage:OSDGraphicSpeaker onDisplayID:CGSMainDisplayID() priority:OSDPriorityDefault msecUntilFade:1000 filledChiclets:(unsigned int)[runningPlayerPtr oldVolume] totalChiclets:(unsigned int)100 locked:NO];
|
||
}
|
||
}
|
||
}
|
||
|
||
[runningPlayerPtr setOldVolume:-1];
|
||
}
|
||
|
||
if (runningPlayerPtr == iTunes)
|
||
[self setItunesVolume:[runningPlayerPtr currentVolume]];
|
||
else if (runningPlayerPtr == spotify)
|
||
[self setSpotifyVolume:[runningPlayerPtr currentVolume]];
|
||
else if (runningPlayerPtr == doppler)
|
||
[self setSpotifyVolume:[runningPlayerPtr currentVolume]];
|
||
|
||
// Update system UI if system volume is affected or when locked
|
||
if (_LockSystemAndPlayerVolume || runningPlayerPtr == systemAudio) {
|
||
[self setSystemVolume:[systemAudio currentVolume]];
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
- (void)adjustVolumeUp:(BOOL)increase ramp:(BOOL)ramp {
|
||
if (ramp) {
|
||
[checkPlayerTimer invalidate];
|
||
checkPlayerTimer = nil;
|
||
|
||
SEL selector = increase ? @selector(rampVolumeUp:) : @selector(rampVolumeDown:);
|
||
volumeRampTimer = [NSTimer timerWithTimeInterval:volumeRampTimeInterval * (NSTimeInterval)increment
|
||
target:self
|
||
selector:selector
|
||
userInfo:nil
|
||
repeats:YES];
|
||
[[NSRunLoop mainRunLoop] addTimer:volumeRampTimer forMode:NSRunLoopCommonModes];
|
||
|
||
if (timerImgSpeaker) {
|
||
[timerImgSpeaker invalidate];
|
||
timerImgSpeaker = nil;
|
||
}
|
||
} else {
|
||
[self setVolumeUp:increase];
|
||
}
|
||
}
|
||
|
||
- (id)init
|
||
{
|
||
self = [super init];
|
||
if(self)
|
||
{
|
||
self->eventTap = nil;
|
||
menuIsVisible=false;
|
||
currentPlayer=nil;
|
||
|
||
updateSystemVolumeTimer=nil;
|
||
volumeRampTimer=nil;
|
||
timerImgSpeaker=nil;
|
||
checkPlayerTimer=nil;
|
||
|
||
// Explicitly initialize event tap state
|
||
_previousKeyCode = 0;
|
||
_muteDown = NO;
|
||
}
|
||
return self;
|
||
}
|
||
|
||
-(void)completeInitialization
|
||
{
|
||
SPUUpdater* updater = [[self sparkle_updater] updater];
|
||
[updater clearFeedURLFromUserDefaults];
|
||
[[self sparkle_updater] userDriver];
|
||
[updater setUpdateCheckInterval:60*60*24*7]; // look for new updates every 7 days
|
||
|
||
//[[SUUpdater sharedUpdater] setFeedURL:[NSURL URLWithString:[NSString stringWithFormat: @"http://quantum-technologies.iap.uni-bonn.de/alberti/iTunesVolumeControl/VolumeControlCast.xml.php?version=%@&osxversion=%@",version,[operatingSystemVersionString stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLQueryAllowedCharacterSet]]]]];
|
||
//[[SUUpdater sharedUpdater] setUpdateCheckInterval:60*60*24*7]; // look for new updates every 7 days
|
||
|
||
// [self _loadBezelServices]; // El Capitan and probably older systems
|
||
if (@available(macOS 16.0, *)) {
|
||
// Running on Tahoe (2026) or newer
|
||
} else {
|
||
[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/OSD.framework"] load];
|
||
self->OSDManager = NSClassFromString(@"OSDManager");
|
||
}
|
||
|
||
if (@available(macOS 16.0, *)) {
|
||
iTunes = [[PlayerApplication alloc] initWithBundleIdentifier:@"com.apple.Music" andIcon:[NSImage imageNamed:@"AppleMusicTahoe"]];
|
||
} else {
|
||
iTunes = [[PlayerApplication alloc] initWithBundleIdentifier:@"com.apple.Music" andIcon:[NSImage imageNamed:@"AppleMusicSequoia"]];
|
||
}
|
||
|
||
spotify = [[PlayerApplication alloc] initWithBundleIdentifier:@"com.spotify.client" andIcon:[NSImage imageNamed:@"spotify"]];
|
||
|
||
doppler = [[PlayerApplication alloc] initWithBundleIdentifier:@"co.brushedtype.doppler-macos" andIcon:[NSImage imageNamed:@"doppler"]];
|
||
|
||
// Force MacOS to ask for authorization to AppleEvents if this was not already given
|
||
if([iTunes isRunning])
|
||
[iTunes currentVolume];
|
||
if([spotify isRunning])
|
||
[spotify currentVolume];
|
||
if([doppler isRunning])
|
||
[doppler currentVolume];
|
||
|
||
systemAudio = [[SystemApplication alloc] init];
|
||
|
||
// Install icon into the menu bar
|
||
[self showInStatusBarWithCompletion:^{
|
||
// This code will only run AFTER the icon has been created and is visible.
|
||
|
||
// Initiate hiding it
|
||
if([self hideFromStatusBar]) {
|
||
// NSLog(@"Started hiding from status bar");
|
||
[self setHideFromStatusBar:YES];
|
||
}
|
||
}];
|
||
|
||
// NSString* iTunesVersion = [[NSString alloc] initWithString:[iTunes version]];
|
||
// NSString* spotifyVersion = [[NSString alloc] initWithString:[spotify version]];
|
||
|
||
[self initializePreferences];
|
||
|
||
[self setStartAtLogin:[self StartAtLogin] savePreferences:false];
|
||
|
||
volumeSound = [[NSSound alloc] initWithContentsOfFile:@"/System/Library/LoginPlugins/BezelServices.loginPlugin/Contents/Resources/volume.aiff" byReference:false];
|
||
}
|
||
|
||
- (BOOL)validateMenuItem:(NSMenuItem *)menuItem {
|
||
// if (menuItem.tag == USE_APPLE_CMD_MODIFIER_MENU_ID) { // CMD Modifier menu item
|
||
// return ![self LockSystemAndPlayerVolume]; // Disable when locked
|
||
// }
|
||
return YES; // Default behavior
|
||
}
|
||
|
||
- (void)emitAcousticFeedback
|
||
{
|
||
if([self PlaySoundFeedback] && (_AppleCMDModifierPressed != _UseAppleCMDModifier || [[self runningPlayer] isKindOfClass:[SystemApplication class]]))
|
||
{
|
||
if([volumeSound isPlaying])
|
||
[volumeSound stop];
|
||
[volumeSound play];
|
||
}
|
||
}
|
||
|
||
- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
|
||
{
|
||
[[[NSWorkspace sharedWorkspace] notificationCenter] addObserver: self selector: @selector(receiveWakeNote:) name:NSWorkspaceDidWakeNotification object: NULL];
|
||
|
||
signal(SIGTERM, handleSIGTERM);
|
||
|
||
if ([self tryCreateEventTap]) {
|
||
[self completeInitialization];
|
||
} else {
|
||
// Not yet trusted, show helper dialog
|
||
accessibilityDialog = [[AccessibilityDialog alloc] initWithWindowNibName:@"AccessibilityDialog"];
|
||
[accessibilityDialog showWindow:self];
|
||
}
|
||
|
||
[TahoeVolumeHUD sharedManager].delegate = self;
|
||
}
|
||
|
||
- (BOOL)applicationShouldHandleReopen:(NSApplication *)sender hasVisibleWindows:(BOOL)flag
|
||
{
|
||
if ([self hideFromStatusBar]) {
|
||
// First, tell the status bar to show itself.
|
||
[self showInStatusBarWithCompletion:^{
|
||
// This code will only run AFTER the icon has been created and is visible.
|
||
|
||
// Initiate hiding it
|
||
[self setHideFromStatusBar:YES];
|
||
|
||
// Actively show the popover to make sure user notices; delay it until status item has settled in its final position
|
||
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)),
|
||
dispatch_get_main_queue(), ^{
|
||
[self showHideFromStatusBarHintPopover];
|
||
});
|
||
}];
|
||
}
|
||
return false;
|
||
}
|
||
|
||
- (void)showInStatusBarWithCompletion:(void (^)(void))completion
|
||
{
|
||
if (!self.statusBar) {
|
||
// the status bar item needs a custom view so that we can show a NSPopover for the hide-from-status-bar hint
|
||
// the view now reacts to the mouseDown event to show the menu
|
||
self.statusBar = [[NSStatusBar systemStatusBar] statusItemWithLength:NSSquareStatusItemLength];
|
||
self.statusBar.menu = self.statusMenu;
|
||
}
|
||
|
||
// Defer the button configuration to the next run loop cycle.
|
||
// This allows the system to create and place the status item
|
||
// before you try to modify its view hierarchy.
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
// Show the status bar item first.
|
||
[self showStatusBarItem];
|
||
|
||
NSImage *icon = [NSImage imageNamed:@"statusbar-icon"];
|
||
icon.template = YES;
|
||
|
||
if (self.statusBar.button) {
|
||
self.statusBar.button.image = icon;
|
||
}
|
||
|
||
// Now that the UI work is complete, call the completion handler.
|
||
if (completion) {
|
||
completion();
|
||
}
|
||
});
|
||
}
|
||
|
||
|
||
- (void)updateSystemVolume:(NSTimer*)theTimer
|
||
{
|
||
if([systemAudio isMuted])
|
||
[[self systemPerc] setStringValue:[NSString stringWithFormat:@"(%d%%)",0]];
|
||
else
|
||
[[self systemPerc] setStringValue:[NSString stringWithFormat:@"(%d%%)",(int)[systemAudio currentVolume]]];
|
||
}
|
||
|
||
- (void)initializePreferences
|
||
{
|
||
preferences = [NSUserDefaults standardUserDefaults];
|
||
NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
|
||
[NSNumber numberWithInt:2], @"volumeIncrement",
|
||
[NSNumber numberWithBool:true] , @"TappingEnabled",
|
||
[NSNumber numberWithBool:false], @"UseAppleCMDModifier",
|
||
[NSNumber numberWithBool:false], @"LockSystemAndPlayerVolume",
|
||
[NSNumber numberWithBool:true], @"AutomaticUpdates",
|
||
[NSNumber numberWithBool:false], @"hideFromStatusBarPreference",
|
||
[NSNumber numberWithBool:false], @"hideVolumeWindowPreference",
|
||
[NSNumber numberWithBool:true], @"iTunesControl",
|
||
[NSNumber numberWithBool:true], @"spotifyControl",
|
||
[NSNumber numberWithBool:true], @"dopplerControl",
|
||
[NSNumber numberWithBool:true], @"systemControl",
|
||
[NSNumber numberWithBool:true], @"PlaySoundFeedback",
|
||
nil ]; // terminate the list
|
||
[preferences registerDefaults:dict];
|
||
|
||
[self setTapping:[preferences boolForKey: @"TappingEnabled"]];
|
||
[self setUseAppleCMDModifier:[preferences boolForKey: @"UseAppleCMDModifier"]];
|
||
[self setLockSystemAndPlayerVolume:[preferences boolForKey: @"LockSystemAndPlayerVolume"]];
|
||
[self setAutomaticUpdates:[preferences boolForKey: @"AutomaticUpdates"]];
|
||
[self setHideFromStatusBar:[preferences boolForKey: @"hideFromStatusBarPreference"]];
|
||
[self setHideVolumeWindow:[preferences boolForKey: @"hideVolumeWindowPreference"]];
|
||
[[self iTunesBtn] setState:[preferences boolForKey: @"iTunesControl"]];
|
||
if (@available(macOS 10.15, *)) {
|
||
[[self iTunesBtn] setTitle:@"Music"];
|
||
}
|
||
[[self iTunesBtn] setState:[preferences boolForKey: @"iTunesControl"]];
|
||
[[self spotifyBtn] setState:[preferences boolForKey: @"spotifyControl"]];
|
||
[[self dopplerBtn] setState:[preferences boolForKey: @"dopplerControl"]];
|
||
//[[self systemBtn] setState:[preferences boolForKey: @"systemControl"]];
|
||
[[self systemBtn] setState:true]; // hard coded always to true
|
||
[[self systemBtn] setEnabled:false];
|
||
[self setPlaySoundFeedback:[preferences boolForKey: @"PlaySoundFeedback"]];
|
||
|
||
NSInteger volumeIncSetting = [preferences integerForKey:@"volumeIncrement"];
|
||
[self setVolumeInc:volumeIncSetting];
|
||
|
||
[[self volumeIncrementsSlider] setIntegerValue: volumeIncSetting];
|
||
}
|
||
|
||
- (IBAction)toggleAutomaticUpdates:(id)sender
|
||
{
|
||
[self setAutomaticUpdates:![self AutomaticUpdates]];
|
||
}
|
||
|
||
- (void) setAutomaticUpdates:(bool)enabled
|
||
{
|
||
NSMenuItem* menuItem=[_statusMenu itemWithTag:AUTOMATIC_UPDATES_ID];
|
||
[menuItem setState:enabled];
|
||
|
||
[preferences setBool:enabled forKey:@"AutomaticUpdates"];
|
||
[preferences synchronize];
|
||
|
||
_AutomaticUpdates=enabled;
|
||
|
||
[[[self sparkle_updater] updater] setAutomaticallyChecksForUpdates:enabled];
|
||
}
|
||
|
||
- (IBAction)togglePlaySoundFeedback:(id)sender
|
||
{
|
||
[self setPlaySoundFeedback:![self PlaySoundFeedback]];
|
||
}
|
||
|
||
- (void)setPlaySoundFeedback:(bool)enabled
|
||
{
|
||
[preferences setBool:enabled forKey:@"PlaySoundFeedback"];
|
||
[preferences synchronize];
|
||
|
||
NSMenuItem* menuItem=[_statusMenu itemWithTag:PLAY_SOUND_FEEDBACK_ID];
|
||
[menuItem setState:enabled];
|
||
|
||
_PlaySoundFeedback=enabled;
|
||
}
|
||
|
||
- (void) setUseAppleCMDModifier:(bool)enabled
|
||
{
|
||
NSMenuItem* menuItem=[_statusMenu itemWithTag:USE_APPLE_CMD_MODIFIER_MENU_ID];
|
||
[menuItem setState:enabled];
|
||
|
||
[preferences setBool:enabled forKey:@"UseAppleCMDModifier"];
|
||
[preferences synchronize];
|
||
|
||
_UseAppleCMDModifier=enabled;
|
||
}
|
||
|
||
- (IBAction)toggleUseAppleCMDModifier:(id)sender
|
||
{
|
||
[self setUseAppleCMDModifier:![self UseAppleCMDModifier]];
|
||
}
|
||
|
||
- (IBAction)toggleLockSystemAndPlayerVolume:(id)sender
|
||
{
|
||
[self setLockSystemAndPlayerVolume:![self LockSystemAndPlayerVolume]];
|
||
}
|
||
|
||
/*
|
||
- (void) syncSystemVolume:(NSTimer*)theTimer
|
||
{
|
||
id runningPlayerPtr = [self runningPlayer];
|
||
|
||
if (runningPlayerPtr != nil && runningPlayerPtr != systemAudio)
|
||
{
|
||
double systemVolume = [systemAudio currentVolume];
|
||
double volume = [runningPlayerPtr currentVolume];
|
||
double diff = systemVolume - volume;
|
||
if (diff<0) diff = -diff;
|
||
if( diff>1E-3 ) {
|
||
NSLog(@"EQUALIZING");
|
||
NSLog(@"Player volume: %1.5f",volume);
|
||
NSLog(@"Apple Music: %d",runningPlayerPtr == iTunes);
|
||
NSLog(@"System volume: %1.5f",systemVolume);
|
||
NSLog(@"Diff: %1.10f",diff);
|
||
[systemAudio setCurrentVolume:volume];
|
||
[self setSystemVolume:volume];
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
- (void) setLockSystemAndPlayerVolume:(bool)enabled
|
||
{
|
||
NSMenuItem* menuItem=[_statusMenu itemWithTag:LOCK_SYSTEM_AND_PLAYER_VOLUME_ID];
|
||
[menuItem setState:enabled];
|
||
|
||
[preferences setBool:enabled forKey:@"LockSystemAndPlayerVolume"];
|
||
[preferences synchronize];
|
||
|
||
_LockSystemAndPlayerVolume=enabled;
|
||
|
||
/*
|
||
if(_LockSystemAndPlayerVolume) {
|
||
volumeLockSyncTimer = [NSTimer timerWithTimeInterval:volumeLockSyncInterval target:self selector:@selector(syncSystemVolume:) userInfo:nil repeats:YES];
|
||
[[NSRunLoop mainRunLoop] addTimer:volumeLockSyncTimer forMode:NSRunLoopCommonModes];
|
||
} else {
|
||
[volumeLockSyncTimer invalidate];
|
||
volumeLockSyncTimer = nil;
|
||
}
|
||
*/
|
||
}
|
||
|
||
- (void)setTapping:(bool)enabled {
|
||
if (eventTap) {
|
||
CGEventTapEnable(eventTap, enabled);
|
||
// Reset key state tracking to avoid stale state after re-creation
|
||
_previousKeyCode = 0;
|
||
_muteDown = NO;
|
||
} else if (enabled) {
|
||
// Try to recreate the tap if it was torn down
|
||
if (![self createEventTap]) {
|
||
NSLog(@"[Volume Control] Failed to recreate event tap.");
|
||
// You could also show an alert here if desired
|
||
enabled = NO; // fallback
|
||
}
|
||
}
|
||
|
||
NSMenuItem *menuItem = [_statusMenu itemWithTag:TAPPING_ID];
|
||
[menuItem setState:enabled];
|
||
|
||
[[[self statusBar] button] setAppearsDisabled:!enabled];
|
||
|
||
[preferences setBool:enabled forKey:@"TappingEnabled"];
|
||
[preferences synchronize];
|
||
|
||
_Tapping = enabled;
|
||
}
|
||
|
||
- (IBAction)toggleTapping:(id)sender
|
||
{
|
||
[self setTapping:![self Tapping]];
|
||
}
|
||
|
||
- (IBAction)sliderValueChanged:(NSSliderCell*)slider
|
||
{
|
||
NSInteger volumeIncSetting = [[self volumeIncrementsSlider] integerValue];
|
||
|
||
[self setVolumeInc:volumeIncSetting];
|
||
|
||
[preferences setInteger:volumeIncSetting forKey:@"volumeIncrement"];
|
||
[preferences synchronize];
|
||
|
||
}
|
||
|
||
- (void) setVolumeInc:(NSInteger)volumeIncSetting
|
||
{
|
||
switch(volumeIncSetting)
|
||
{
|
||
case 5:
|
||
increment = 25;
|
||
break;
|
||
case 4:
|
||
increment = 12.5;
|
||
break;
|
||
case 3:
|
||
increment = 6.25;
|
||
break;
|
||
case 2:
|
||
increment = 3.125;
|
||
break;
|
||
case 1:
|
||
default:
|
||
increment = 1.5625;
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
- (IBAction)aboutPanel:(id)sender
|
||
{
|
||
NSDictionary *infoDict = [[NSBundle mainBundle] infoDictionary];
|
||
|
||
NSString *shortVersion = infoDict[@"CFBundleShortVersionString"]; // e.g. "1.7.7"
|
||
NSString *buildNumber = infoDict[@"CFBundleVersion"]; // e.g. "190"
|
||
|
||
NSDictionary *options = @{NSAboutPanelOptionApplicationVersion: shortVersion, NSAboutPanelOptionVersion: buildNumber};
|
||
|
||
[[NSApplication sharedApplication] activateIgnoringOtherApps:YES];
|
||
[[NSApplication sharedApplication] orderFrontStandardAboutPanelWithOptions:options];
|
||
}
|
||
|
||
- (void) receiveWakeNote: (NSNotification*) note
|
||
{
|
||
NSLog(@"Received WakeNote: %@", [note name]);
|
||
[self setTapping:[self Tapping]];
|
||
}
|
||
|
||
- (void)resetCurrentPlayer:(NSTimer*)theTimer
|
||
{
|
||
// Keep memory of the current player until this timeout is reached
|
||
// After the timeout, it is forced to check again what the current player is
|
||
[checkPlayerTimer invalidate];
|
||
checkPlayerTimer = nil;
|
||
currentPlayer = nil;
|
||
}
|
||
|
||
- (id)runningPlayer
|
||
{
|
||
if(currentPlayer)
|
||
return currentPlayer;
|
||
|
||
checkPlayerTimer = [NSTimer timerWithTimeInterval:checkPlayerTimeout target:self selector:@selector(resetCurrentPlayer:) userInfo:nil repeats:NO];
|
||
[[NSRunLoop mainRunLoop] addTimer:checkPlayerTimer forMode:NSRunLoopCommonModes];
|
||
|
||
if(_AppleCMDModifierPressed == _UseAppleCMDModifier)
|
||
{
|
||
if([_iTunesBtn state] && [iTunes isRunning] && [iTunes playerState] == iTunesEPlSPlaying)
|
||
{
|
||
currentPlayer = iTunes;
|
||
}
|
||
else if([_spotifyBtn state] && [spotify isRunning] && (SpotifyEPlS)[spotify playerState] == SpotifyEPlSPlaying)
|
||
{
|
||
currentPlayer = spotify;
|
||
}
|
||
else if([_dopplerBtn state] && [doppler isRunning] && (DopplerEPlS)[doppler playerState] == DopplerEPlSPlaying)
|
||
{
|
||
currentPlayer = doppler;
|
||
}
|
||
else if([_systemBtn state])
|
||
{
|
||
currentPlayer = systemAudio;
|
||
}
|
||
}
|
||
else
|
||
currentPlayer = systemAudio;
|
||
|
||
return currentPlayer;
|
||
}
|
||
|
||
- (void)setVolumeUp:(bool)increase
|
||
{
|
||
id runningPlayerPtr = [self runningPlayer];
|
||
|
||
if (runningPlayerPtr != nil)
|
||
{
|
||
double volume = [runningPlayerPtr currentVolume];
|
||
// NSLog(@"Current volume: %1.2f%%", volume);
|
||
|
||
if([runningPlayerPtr oldVolume]<0) // if it was not mute
|
||
{
|
||
//volume=[musicProgramPnt soundVolume]+_volumeInc*(increase?1:-1);
|
||
volume += (increase?1:-1)*increment;
|
||
}
|
||
else // if it was mute
|
||
{
|
||
// [volumeImageLayer setContents:imgVolOn]; // restore the image of the speaker from mute speaker
|
||
volume=[runningPlayerPtr oldVolume];
|
||
[runningPlayerPtr setOldVolume:-1]; // this says that it is not mute
|
||
}
|
||
if (volume<0) volume=0;
|
||
if (volume>100) volume=100;
|
||
|
||
OSDGraphic image = 0;
|
||
NSInteger numFullBlks = 0;
|
||
NSInteger numQrtsBlks = 0;
|
||
|
||
if (@available(macOS 16.0, *)) {
|
||
// On Tahoe, show the new popover HUD anchored to the status item.
|
||
} else {
|
||
image = (volume > 0)? OSDGraphicSpeaker : OSDGraphicSpeakerMute;
|
||
numFullBlks = floor(volume/6.25);
|
||
numQrtsBlks = round((volume-(double)numFullBlks*6.25)/1.5625);
|
||
}
|
||
|
||
//NSLog(@"%d %d",(int)numFullBlks,(int)numQrtsBlks);
|
||
|
||
if(!_hideVolumeWindow)
|
||
{
|
||
if (@available(macOS 16.0, *)) {
|
||
// On Tahoe, show the new popover HUD anchored to the status item.
|
||
[[TahoeVolumeHUD sharedManager] showHUDWithVolume:volume usingMusicPlayer:runningPlayerPtr andLabel:[systemAudio getDefaultOutputDeviceName] anchoredToStatusButton:self.statusBar.button];
|
||
} else {
|
||
if(image) {
|
||
id osdMgr = [self->OSDManager sharedManager];
|
||
if (osdMgr) {
|
||
[osdMgr showImage:image onDisplayID:CGSMainDisplayID() priority:OSDPriorityDefault msecUntilFade:1000 filledChiclets:(unsigned int)(round(((numFullBlks*4+numQrtsBlks)*1.5625)*100)) totalChiclets:(unsigned int)10000 locked:NO];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
[runningPlayerPtr setCurrentVolume:volume];
|
||
if (_LockSystemAndPlayerVolume && runningPlayerPtr != systemAudio) {
|
||
[systemAudio setCurrentVolume:volume];
|
||
}
|
||
|
||
if(self->volumeRampTimer == nil)
|
||
[self emitAcousticFeedback];
|
||
|
||
if( runningPlayerPtr == iTunes)
|
||
[self setItunesVolume:volume];
|
||
else if( runningPlayerPtr == spotify)
|
||
[self setSpotifyVolume:volume];
|
||
else if (runningPlayerPtr == doppler)
|
||
[self setDopplerVolume:volume];
|
||
|
||
if(_LockSystemAndPlayerVolume || runningPlayerPtr == systemAudio)
|
||
[self setSystemVolume:volume];
|
||
|
||
[self refreshVolumeBar:(int)volume];
|
||
|
||
// NSLog(@"New volume: %1.2f%%", [runningPlayerPtr currentVolume]);
|
||
}
|
||
}
|
||
|
||
- (void) setItunesVolume:(NSInteger)volume
|
||
{
|
||
if (volume == -1)
|
||
[[self iTunesPerc] setHidden:YES];
|
||
else
|
||
{
|
||
[[self iTunesPerc] setHidden:NO];
|
||
[[self iTunesPerc] setStringValue:[NSString stringWithFormat:@"(%d%%)",(int)volume]];
|
||
}
|
||
}
|
||
|
||
- (void) setSpotifyVolume:(NSInteger)volume
|
||
{
|
||
if (volume == -1)
|
||
[[self spotifyPerc] setHidden:YES];
|
||
else
|
||
{
|
||
[[self spotifyPerc] setHidden:NO];
|
||
[[self spotifyPerc] setStringValue:[NSString stringWithFormat:@"(%d%%)",(int)volume]];
|
||
}
|
||
}
|
||
|
||
- (void) setDopplerVolume:(NSInteger)volume
|
||
{
|
||
if (volume == -1)
|
||
[[self dopplerPerc] setHidden:YES];
|
||
else
|
||
{
|
||
[[self dopplerPerc] setHidden:NO];
|
||
[[self dopplerPerc] setStringValue:[NSString stringWithFormat:@"(%d%%)",(int)volume]];
|
||
}
|
||
}
|
||
|
||
- (void) setSystemVolume:(NSInteger)volume
|
||
{
|
||
if (volume == -1)
|
||
[[self systemPerc] setHidden:YES];
|
||
else
|
||
{
|
||
[[self systemPerc] setHidden:NO];
|
||
[[self systemPerc] setStringValue:[NSString stringWithFormat:@"(%d%%)",(int)volume]];
|
||
}
|
||
|
||
}
|
||
|
||
- (void) updatePercentages
|
||
{
|
||
if([iTunes isRunning])
|
||
[self setItunesVolume:[iTunes currentVolume]];
|
||
else
|
||
[self setItunesVolume:-1];
|
||
|
||
if([spotify isRunning])
|
||
[self setSpotifyVolume:[spotify currentVolume]];
|
||
else
|
||
[self setSpotifyVolume:-1];
|
||
|
||
if ([doppler isRunning])
|
||
[self setDopplerVolume:[doppler currentVolume]];
|
||
else
|
||
[self setDopplerVolume:-1];
|
||
|
||
[self setSystemVolume:[systemAudio currentVolume]];
|
||
}
|
||
|
||
- (void) refreshVolumeBar:(NSInteger)volume
|
||
{
|
||
NSInteger doubleFullRectangles = (NSInteger)round(32.0f * volume / 100.0f);
|
||
NSInteger fullRectangles=doubleFullRectangles>>1;
|
||
|
||
[CATransaction begin];
|
||
[CATransaction setAnimationDuration: 0.0];
|
||
[CATransaction setDisableActions: TRUE];
|
||
|
||
if(volume==0)
|
||
{
|
||
[volumeImageLayer setContents:imgVolOff];
|
||
}
|
||
else
|
||
{
|
||
[volumeImageLayer setContents:imgVolOn];
|
||
}
|
||
|
||
CGRect frame;
|
||
|
||
for(NSInteger i=0; i<fullRectangles; i++)
|
||
{
|
||
frame = [volumeBar[i] frame];
|
||
frame.size.width=9;
|
||
[volumeBar[i] setFrame:frame];
|
||
|
||
[volumeBar[i] setHidden:NO];
|
||
}
|
||
for(NSInteger i=fullRectangles; i<16; i++)
|
||
{
|
||
frame = [volumeBar[i] frame];
|
||
frame.size.width=9;
|
||
[volumeBar[i] setFrame:frame];
|
||
|
||
[volumeBar[i] setHidden:YES];
|
||
}
|
||
|
||
if(fullRectangles*2 != doubleFullRectangles)
|
||
{
|
||
|
||
frame = [volumeBar[fullRectangles] frame];
|
||
frame.size.width=5;
|
||
|
||
[volumeBar[fullRectangles] setFrame:frame];
|
||
[volumeBar[fullRectangles] setHidden:NO];
|
||
}
|
||
|
||
[CATransaction commit];
|
||
}
|
||
|
||
|
||
#pragma mark - Hide From Status Bar
|
||
|
||
- (IBAction)toggleHideFromStatusBar:(id)sender
|
||
{
|
||
[self setHideFromStatusBar:![self hideFromStatusBar]];
|
||
if ([self hideFromStatusBar])
|
||
[self showHideFromStatusBarHintPopover];
|
||
}
|
||
|
||
- (void)setHideFromStatusBar:(bool)want_hide
|
||
{
|
||
// NSLog(@"Will it hide: %d",want_hide);
|
||
|
||
_hideFromStatusBar=want_hide;
|
||
|
||
NSMenuItem* menuItem=[_statusMenu itemWithTag:HIDE_FROM_STATUS_BAR_ID];
|
||
[menuItem setState:[self hideFromStatusBar]];
|
||
|
||
[preferences setBool:want_hide forKey:@"hideFromStatusBarPreference"];
|
||
[preferences synchronize];
|
||
|
||
if(want_hide){
|
||
// Pre-create the popover so it's ready when we need to show it
|
||
if (! _hideFromStatusBarHintPopover)
|
||
{
|
||
CGRect popoverRect = (CGRect) {
|
||
.size.width = 250,
|
||
.size.height = 63
|
||
};
|
||
|
||
_hideFromStatusBarHintLabel = [[NSTextField alloc] initWithFrame:CGRectInset(popoverRect, 10, 10)];
|
||
[_hideFromStatusBarHintLabel setFont:[NSFont systemFontOfSize:[NSFont smallSystemFontSize]]];
|
||
[_hideFromStatusBarHintLabel setEditable:false];
|
||
[_hideFromStatusBarHintLabel setSelectable:false];
|
||
[_hideFromStatusBarHintLabel setBezeled:false];
|
||
[_hideFromStatusBarHintLabel setBackgroundColor:[NSColor clearColor]];
|
||
[_hideFromStatusBarHintLabel setAlignment:NSTextAlignmentCenter];
|
||
|
||
_hintView = [[NSView alloc] initWithFrame:popoverRect];
|
||
[_hintView addSubview:_hideFromStatusBarHintLabel];
|
||
|
||
_hintVC = [[NSViewController alloc] init];
|
||
[_hintVC setView:_hintView];
|
||
|
||
_hideFromStatusBarHintPopover = [[NSPopover alloc] init];
|
||
[_hideFromStatusBarHintPopover setContentViewController:_hintVC];
|
||
}
|
||
}
|
||
|
||
if(want_hide && self.statusBar.isVisible)
|
||
{
|
||
if (![_statusBarHideTimer isValid] )
|
||
{
|
||
// NSLog(@"Start new timers");
|
||
[self setHideFromStatusBarHintLabelWithSeconds:statusBarHideDelay];
|
||
_statusBarHideTimer = [NSTimer timerWithTimeInterval:statusBarHideDelay target:self selector:@selector(doHideFromStatusBar:) userInfo:nil repeats:NO];
|
||
[[NSRunLoop mainRunLoop] addTimer:_statusBarHideTimer forMode:NSRunLoopCommonModes];
|
||
_hideFromStatusBarHintPopoverUpdateTimer = [NSTimer timerWithTimeInterval:0.1 target:self selector:@selector(updateHideFromStatusBarHintPopover:) userInfo:nil repeats:YES];
|
||
[[NSRunLoop mainRunLoop] addTimer:_hideFromStatusBarHintPopoverUpdateTimer forMode:NSRunLoopCommonModes];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// NSLog(@"INVALIDATE TIMERS");
|
||
[_hideFromStatusBarHintPopover close];
|
||
[_statusBarHideTimer invalidate];
|
||
_statusBarHideTimer = nil;
|
||
[_hideFromStatusBarHintPopoverUpdateTimer invalidate];
|
||
_hideFromStatusBarHintPopoverUpdateTimer = nil;
|
||
}
|
||
}
|
||
|
||
-(void)hideStatusBarItem {
|
||
if (self.statusBar) {
|
||
self.statusBar.visible = NO;
|
||
// self.statusBar.length = 0; // collapses to zero width, however, some space remains allocated by macOS
|
||
}
|
||
}
|
||
|
||
- (void)showStatusBarItem {
|
||
if (self.statusBar) {
|
||
self.statusBar.visible = YES;
|
||
// self.statusBar.length = NSSquareStatusItemLength;
|
||
}
|
||
}
|
||
|
||
- (void)doHideFromStatusBar:(NSTimer*)aTimer
|
||
{
|
||
// NSLog(@"doHideFromStatusBar");
|
||
[_hideFromStatusBarHintPopoverUpdateTimer invalidate];
|
||
_hideFromStatusBarHintPopoverUpdateTimer = nil;
|
||
|
||
[_statusBarHideTimer invalidate];
|
||
_statusBarHideTimer = nil;
|
||
|
||
[_hideFromStatusBarHintPopover close];
|
||
[self hideStatusBarItem];
|
||
[self setHideFromStatusBar:true];
|
||
}
|
||
|
||
- (void)showHideFromStatusBarHintPopover
|
||
{
|
||
if ([_hideFromStatusBarHintPopover isShown]) return;
|
||
|
||
// NSLog(@"Will show popover");
|
||
|
||
NSStatusBarButton *statusBarButton = [[self statusBar] button];
|
||
[_hideFromStatusBarHintPopover showRelativeToRect:[statusBarButton bounds] ofView:statusBarButton preferredEdge:NSMinYEdge];
|
||
}
|
||
|
||
- (void)updateHideFromStatusBarHintPopover:(NSTimer*)aTimer
|
||
{
|
||
NSDate *now = [NSDate date];
|
||
NSTimeInterval remaining = [[_statusBarHideTimer fireDate] timeIntervalSinceDate:now];
|
||
NSUInteger rounded = (NSUInteger)ceil(remaining);
|
||
[self setHideFromStatusBarHintLabelWithSeconds:rounded];
|
||
// NSLog(@"Timer remaining: %lu s", (unsigned long)rounded);
|
||
}
|
||
|
||
- (void)setHideFromStatusBarHintLabelWithSeconds:(NSUInteger)seconds
|
||
{
|
||
[_hideFromStatusBarHintLabel setStringValue:[NSString stringWithFormat:@"Volume Control will hide after %ld seconds. Launch the app again to make the icon reappear in the menu bar.",seconds]];
|
||
}
|
||
|
||
#pragma mark - Music players
|
||
|
||
- (IBAction)toggleMusicPlayer:(id)sender
|
||
{
|
||
if (sender == _iTunesBtn) {
|
||
[preferences setBool:[sender state] forKey:@"iTunesControl"];
|
||
}
|
||
else if (sender == _spotifyBtn)
|
||
{
|
||
[preferences setBool:[sender state] forKey:@"spotifyControl"];
|
||
}
|
||
else if (sender == _dopplerBtn)
|
||
{
|
||
[preferences setBool:[sender state] forKey:@"dopplerControl"];
|
||
}
|
||
|
||
[preferences synchronize];
|
||
}
|
||
|
||
#pragma mark - NSMenuDelegate
|
||
|
||
- (IBAction)toggleHideVolumeWindow:(id)sender
|
||
{
|
||
[self setHideVolumeWindow:![self hideVolumeWindow]];
|
||
}
|
||
|
||
- (void)setHideVolumeWindow:(bool)enabled
|
||
{
|
||
_hideVolumeWindow=enabled;
|
||
|
||
NSMenuItem* menuItem=[_statusMenu itemWithTag:HIDE_VOLUME_WINDOW_ID];
|
||
[menuItem setState:[self hideVolumeWindow]];
|
||
|
||
[preferences setBool:enabled forKey:@"hideVolumeWindowPreference"];
|
||
[preferences synchronize];
|
||
}
|
||
|
||
- (void)menuWillOpen:(NSMenu *)menu
|
||
{
|
||
[self updatePercentages];
|
||
|
||
if(!_Tapping)
|
||
{
|
||
updateSystemVolumeTimer = [NSTimer timerWithTimeInterval:updateSystemVolumeInterval target:self selector:@selector(updateSystemVolume:) userInfo:nil repeats:YES];
|
||
[[NSRunLoop mainRunLoop] addTimer:updateSystemVolumeTimer forMode:NSRunLoopCommonModes];
|
||
}
|
||
|
||
[_hideFromStatusBarHintPopover close];
|
||
menuIsVisible=true;
|
||
}
|
||
|
||
- (void)menuDidClose:(NSMenu *)menu
|
||
{
|
||
menuIsVisible=false;
|
||
if([[self statusBar] isVisible] && [self hideFromStatusBar])
|
||
{
|
||
[self showHideFromStatusBarHintPopover];
|
||
}
|
||
|
||
// Remove timer used to update volume bar status in the menu bar
|
||
if(updateSystemVolumeTimer)
|
||
{
|
||
[updateSystemVolumeTimer invalidate];
|
||
updateSystemVolumeTimer = nil;
|
||
}
|
||
}
|
||
|
||
#pragma mark - TahoeVolumeHUDDelegate
|
||
|
||
- (void)hud:(TahoeVolumeHUD *)hud didChangeVolume:(double)volume forPlayer:(PlayerApplication*)controlledPlayer{
|
||
// This method is called every time the user drags the slider in the HUD.
|
||
// The received 'volume' is a value between 0.0 and 1.0.
|
||
|
||
// 1. Convert the 0.0-1.0 scale to the 0-100 scale our app uses.
|
||
double volumePercent = volume * 100.0;
|
||
|
||
// 2. Get the currently active player, just like we do for the volume keys.
|
||
id runningPlayerPtr = controlledPlayer;
|
||
|
||
if (runningPlayerPtr != nil) {
|
||
// 3. Set the volume for the active player.
|
||
[runningPlayerPtr setCurrentVolume:volumePercent];
|
||
|
||
// 4. If volume is locked, also set the system volume.
|
||
if (_LockSystemAndPlayerVolume && runningPlayerPtr != systemAudio) {
|
||
[systemAudio setCurrentVolume:volumePercent];
|
||
}
|
||
|
||
// 5. Update the percentage labels in the status menu to reflect the change in real-time.
|
||
if (runningPlayerPtr == iTunes) {
|
||
[self setItunesVolume:volumePercent];
|
||
} else if (runningPlayerPtr == spotify) {
|
||
[self setSpotifyVolume:volumePercent];
|
||
} else if (runningPlayerPtr == doppler) {
|
||
[self setDopplerVolume:volumePercent];
|
||
}
|
||
|
||
if (_LockSystemAndPlayerVolume || runningPlayerPtr == systemAudio) {
|
||
[self setSystemVolume:volumePercent];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)didChangeVolumeFinal:(TahoeVolumeHUD *)hud {
|
||
// This is called when the HUD fades out. We can play the feedback sound here
|
||
[self emitAcousticFeedback];
|
||
}
|
||
|
||
|
||
#pragma mark - Sparkle Delegates
|
||
|
||
// This is the Objective-C equivalent of the Swift property 'supportsGentleScheduledUpdateReminders'
|
||
// This is the correct way to opt-in and remove the warning.
|
||
- (BOOL)supportsGentleScheduledUpdateReminders {
|
||
return YES;
|
||
}
|
||
|
||
@end
|