THank you! Here is a simple CLI utility based on your logic

[krackers]

Thank you for the reverse engineering work! I pulled out the core logic that interfaces with iokit into its own C library so that it can be used in a CLI app (I prefer C over swift). Maybe it can be useful to someone.

#import <Foundation/Foundation.h>
#import <IOKit/hidsystem/IOHIDServiceClient.h>
#import <IOKit/hid/IOHIDLib.h>
#import <IOKit/hidsystem/IOHIDServiceClient.h>
#import <IOKit/hidsystem/IOHIDEventSystemClient.h>
#import <IOKit/hidsystem/IOHIDTypes.h>
#import <IOKit/hid/IOHIDKeys.h>
#import <IOKit/hid/IOHIDProperties.h>

void free_ioobject(io_object_t *value) { if (*value != NULL) {IOObjectRelease(*value);} }
void free_cftype(CFTypeRef *value) { if (*value != NULL) {CFRelease(*value);} }

io_service_t getServiceForClient(IOHIDServiceClientRef clientRef) {
	CFTypeRef ref = IOHIDServiceClientGetRegistryID(clientRef);
	NSNumber *number = (__bridge_transfer NSNumber *) ref;
	if (number == NULL) {
		return IO_OBJECT_NULL;
	}
	CFMutableDictionaryRef dict = IORegistryEntryIDMatching([number intValue]);
	io_service_t service = IOServiceGetMatchingService(kIOMainPortDefault, dict);
	if (IOObjectConformsTo(service, "IOHIDDevice") != false) {
		return service;
	}
	__attribute__((cleanup(free_ioobject))) io_iterator_t iterator;
	kern_return_t status = IORegistryEntryCreateIterator(service, "IOService", kIORegistryIterateRecursively | kIORegistryIterateParents, &iterator);
	IOObjectRelease(service);
	if (status != KERN_SUCCESS) {
		return IO_OBJECT_NULL;
	}
	while (true){
		io_service_t service = IOIteratorNext(iterator);
		if (service == MACH_PORT_NULL) {
			break;
		}
		if (IOObjectConformsTo(service, "IOHIDDevice") != false) {
			return service;
		}
		IOObjectRelease(service);
	}
}

IOHIDDeviceRef getDevice(IOHIDServiceClientRef clientRef) {
	__attribute__((cleanup(free_ioobject))) io_service_t service = getServiceForClient(clientRef);
	if (service == IO_OBJECT_NULL) {
		return NULL;
	}
	return IOHIDDeviceCreate(kCFAllocatorDefault, service);
}

// Used only if we want event callback
//void openDevice(IOHIDServiceClientRef clientRef) {
//	IOHIDDeviceRef device = getDevice(clientRef);
//	IOHIDDeviceOpen(device, kIOHIDOptionsTypeNone);
//	IOHIDDeviceScheduleWithRunLoop(device, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
//}
//
//void closeDevice(IOHIDServiceClientRef clientRef) {
//	IOHIDDeviceRef device = getDevice(clientRef);
//	IOHIDDeviceClose(device, kIOHIDOptionsTypeNone);
//	IOHIDDeviceUnscheduleFromRunLoop(device, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
//}

double getSensitivity(IOHIDServiceClientRef client) {
	NSNumber * num = (__bridge_transfer NSNumber *) IOHIDServiceClientCopyProperty(client, CFSTR(kIOHIDPointerResolutionKey));
	return 2000 - [num intValue] / 65536.0;
}

double getAcceleration(IOHIDServiceClientRef client) {
	NSString * str = (__bridge_transfer NSString *) IOHIDServiceClientCopyProperty(client, CFSTR(kIOHIDPointerAccelerationTypeKey));
	if (str == nil) {
		str = @"HIDMouseAcceleration";
	}
	return [((__bridge_transfer NSNumber *)IOHIDServiceClientCopyProperty(client, (__bridge CFStringRef) str)) intValue] / 65536.0;
}

void setSensitivity(IOHIDServiceClientRef client, double newVal) {
	double sensitivity = MAX(5, MIN(newVal, 1990));
	int resolution = (2000 - sensitivity)*65536;
	IOHIDServiceClientSetProperty(client, CFSTR(kIOHIDPointerResolutionKey), (__bridge CFNumberRef) [NSNumber numberWithInt: resolution]);
}

void setAcceleration(IOHIDServiceClientRef client, double newVal) {
	int acceleration = (int) (newVal * 65536);
	NSString * str = (__bridge_transfer NSString *) IOHIDServiceClientCopyProperty(client, CFSTR(kIOHIDPointerAccelerationTypeKey));
	if (str == nil) {
		str = @"HIDMouseAcceleration";
	}
	IOHIDServiceClientSetProperty(client, (__bridge CFStringRef) str, (__bridge CFNumberRef) [NSNumber numberWithInt: acceleration]);
}

extern IOHIDEventSystemClientRef IOHIDEventSystemClientCreate(CFAllocatorRef allocator);
extern void IOHIDEventSystemClientSetMatching(IOHIDEventSystemClientRef, CFDictionaryRef);

typedef void (^IOHIDServiceClientBlock)(void *, void *, IOHIDServiceClientRef);

void IOHIDEventSystemClientRegisterDeviceMatchingBlock(IOHIDEventSystemClientRef, IOHIDServiceClientBlock, void *, void *);

void doSettingsForDevice(IOHIDServiceClientRef service) {
	if(IOHIDServiceClientConformsTo(service, kHIDPage_GenericDesktop, kHIDUsage_GD_Mouse)) {
		if ([(__bridge_transfer NSNumber *)IOHIDServiceClientCopyProperty(service, CFSTR(kIOHIDProductIDKey)) intValue] == 50184) {
			NSLog(@"services: %@", service);
			printf("Sensitivity: %f\n", getSensitivity(service));
			printf("Acceleration: %f\n", getAcceleration(service));
			
			setSensitivity(service, 1900);
			setAcceleration(service, 0.5);
			
			printf("Sensitivity: %f\n", getSensitivity(service));
			printf("Acceleration: %f\n", getAcceleration(service));
		}
	}
}

int main(int argc, char *argv[]) {
	@autoreleasepool {
		IOHIDEventSystemClientRef eventSystemClient = IOHIDEventSystemClientCreate(kCFAllocatorDefault);
		IOHIDEventSystemClientScheduleWithRunLoop(eventSystemClient, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
		NSDictionary * match = @{@(kIOHIDDeviceUsagePageKey): @(kHIDPage_GenericDesktop)};
		IOHIDEventSystemClientSetMatching(eventSystemClient, (__bridge_retained CFDictionaryRef) match);
		IOHIDEventSystemClientRegisterDeviceMatchingBlock(eventSystemClient, ^(void * target, void * refcon, IOHIDServiceClientRef service) {
			doSettingsForDevice(service);
		}, NULL, NULL);
		
		CFArrayRef services = IOHIDEventSystemClientCopyServices(eventSystemClient);

		for (CFIndex i = 0; i < CFArrayGetCount(services); i++) {
			IOHIDServiceClientRef service = (IOHIDServiceClientRef)CFArrayGetValueAtIndex(services, i);
			doSettingsForDevice(service);
		}
		
		CFRunLoopRun();
	}
}

[lujjjh]

Cool snippet!

IOHIDManager can be used to simplify the code and prevent the use of private APIs if all you want to do is retrieve and modify the pointer acceleration and resolution.

[krackers]

I see, thank you! If IOHIDManager suffices, why does linearmouse need to use IOHIDEventSystemClientRef though? What does it allow you to do that IOHIDManager doesn't?

[lujjjh]

Scrolling features and buttons features, such as reverse scrolling and universal back and forward, are implemented with CGEventTap, which does not provide corresponding devices that generate these CGEvents.

However, LinearMouse needs to know the device information of each CGEvent to achieve the per-device settings.

There are several ways to get the corresponding device of a CGEvent:

1. For some CGEvents, such as scrolling events, coresponding IOHIDEvent can be retrieved via a private API CGEventCopyIOHIDEvent. And the sending device might also be obtained in IOHIDEventData.
2. IOHIDManagerRegisterInputValueCallback: Observe the input values of each IOHIDDevice. The callback does not allow for input value modification; however, as the callback is invoked just before the CGEventTap callback, it's not difficult to record the last active device and get the device in the subsequent calls of CGEventTap callback. The drawback is that external Trackpads do not trigger the callback External trackpads connected via bluetooth does not work #170.
3. IOHIDEventSystemClientRegisterEventBlock: LinearMouse uses this private API to observe external Trackpad events as a complement to IOHIDManagerRegisterInputValueCallback. That's why I have to hold a IOHIDEventSystemClientRef. This API can also observe events from other devices, but pointer moving events and button events do not trigger the callback.