service/oss: detect headphones

Author: charlesrocket

src/services/oss/oss.cpp

@@ -7,9 +7,14 @@
 #include <utility>
 
 #include <QFile>
+#include <QFileDevice>
+#include <QHash>
 #include <QProcess>
+#include <QRegularExpression>
 #include <QSocketNotifier>
 #include <QTextStream>
+#include <Qt>
+#include <QtTypes>
 #include <fcntl.h>
 #include <qalgorithms.h>
 #include <qlist.h>
@@ -19,7 +24,9 @@
 #include <qtimer.h>
 #include <qtmetamacros.h>
 #ifdef __FreeBSD__
+#include <sys/event.h>
 #include <sys/ioccom.h>
+#include <sys/queue.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
@@ -341,12 +348,30 @@ OSS::OSS(QObject* parent): QObject(parent), mRescanTimer(new QTimer(this)) {
 		});
 
 		this->connectToDevd();
+		this->initializeJackStates();
+		// clang-format off
+		#ifdef __FreeBSD__
+		this->setupJackDetection();
+		#endif
+		// clang-format on
 	} else {
 		qCWarning(logOSS) << "OSS sound system is not available";
 	}
 }
 
 OSS::~OSS() {
+	if (this->mKqueueNotifier) {
+		this->mKqueueNotifier->setEnabled(false);
+	}
+
+	if (this->mKqueue >= 0) {
+		close(this->mKqueue);
+	}
+
+	if (this->mLogFileDescriptor >= 0) {
+		close(this->mLogFileDescriptor);
+	}
+
 	if (this->mDevdSocket >= 0) {
 		close(this->mDevdSocket);
 	}
@@ -369,6 +394,7 @@ bool OSS::isAvailable() const { return this->mAvailable; }
 void OSS::connectToDevd() {
 	// clang-format off
 	#ifdef __FreeBSD__
+	// clang-format on
 	// Try seqpacket first
 	const char* pipePaths[] = {
 	    "/var/run/devd.seqpacket.pipe",
@@ -415,6 +441,7 @@ void OSS::connectToDevd() {
 	}
 
 	qCWarning(logOSS) << "Failed to connect to a devd pipe—device monitoring disabled";
+	// clang-format off
 	#else
 	qCInfo(logOSS) << "devd monitoring only available on FreeBSD";
 	#endif
@@ -473,6 +500,265 @@ void OSS::handleDevdEvent() {
 	}
 }
 
+#ifdef __FreeBSD__
+void OSS::handleKqueueEvent() {
+	struct kevent event;
+	struct timespec timeout = {.tv_sec = 0, .tv_nsec = 0};
+
+	auto nev = kevent(this->mKqueue, nullptr, 0, &event, 1, &timeout);
+
+	if (nev > 0 && (event.fflags & (NOTE_WRITE | NOTE_EXTEND))) {
+		this->readNewLogLines();
+	}
+}
+
+void OSS::setupJackDetection() {
+	this->mLogFileDescriptor = open("/var/log/messages", O_RDONLY);
+	if (this->mLogFileDescriptor < 0) {
+		qCWarning(logOSS) << "Failed to open /var/log/messages for jack detection";
+		return;
+	}
+
+	// Seek to end to only catch new messages
+	this->mLogFilePosition = lseek(this->mLogFileDescriptor, 0, SEEK_END); // NOLINT
+
+	this->mKqueue = kqueue(); // NOLINT
+	if (this->mKqueue < 0) {
+		qCWarning(logOSS) << "Failed to create kqueue for jack detection";
+		close(this->mLogFileDescriptor);
+		this->mLogFileDescriptor = -1;
+		return;
+	}
+
+	struct kevent change;
+	EV_SET(
+	    &change,
+	    this->mLogFileDescriptor,
+	    EVFILT_VNODE,
+	    EV_ADD | EV_ENABLE | EV_CLEAR,
+	    NOTE_WRITE | NOTE_EXTEND,
+	    0,
+	    nullptr
+	);
+
+	if (kevent(this->mKqueue, &change, 1, nullptr, 0, nullptr) < 0) {
+		qCWarning(logOSS) << "Failed to register kqueue event:" << qt_error_string(errno);
+		close(this->mKqueue);
+		close(this->mLogFileDescriptor);
+
+		this->mKqueue = -1;
+		this->mLogFileDescriptor = -1;
+		return;
+	}
+
+	this->mKqueueNotifier = new QSocketNotifier(this->mKqueue, QSocketNotifier::Read, this);
+	connect(this->mKqueueNotifier, &QSocketNotifier::activated, this, &OSS::handleKqueueEvent);
+	this->mKqueueNotifier->setEnabled(true);
+
+	qCInfo(logOSS) << "Jack detection monitoring enabled";
+}
+#endif
+
+void OSS::identifyJackType(int nid, bool connected) {
+	// Read sysctl to identify what this nid is
+	const QString sysctlPath = QString("dev.hdaa.0.nid%1").arg(nid);
+
+	QProcess process;
+	process.start("sysctl", QStringList() << "-n" << sysctlPath);
+	process.waitForFinished(100);
+
+	const QString output = QString::fromUtf8(process.readAllStandardOutput()).trimmed();
+
+	if (output.contains("Headphones", Qt::CaseInsensitive)) {
+		qCInfo(logOSS) << "Headphones" << (connected ? "connected" : "disconnected");
+		emit this->headphonesChanged(connected);
+	} else if (output.contains("Mic", Qt::CaseInsensitive)) {
+		qCInfo(logOSS) << "Microphone" << (connected ? "connected" : "disconnected");
+		emit this->microphoneChanged(connected);
+	}
+}
+
+void OSS::syncJackProperties() {
+	for (auto it = this->mJackStates.constBegin(); it != this->mJackStates.constEnd(); ++it) {
+		const int nid = it.key();
+		const bool connected = it.value();
+
+		// Identify what type of jack this is and update properties
+		const QString sysctlPath = QString("dev.hdaa.0.nid%1").arg(nid);
+
+		QProcess process;
+		process.start("sysctl", QStringList() << "-n" << sysctlPath);
+		process.waitForFinished(100);
+
+		const QString output = QString::fromUtf8(process.readAllStandardOutput()).trimmed();
+
+		if (output.contains("Headphones", Qt::CaseInsensitive)) {
+			if (this->mHeadphonesConnected != connected) {
+				this->mHeadphonesConnected = connected;
+				qCInfo(logOSS) << "Initial headphone state:" << (connected ? "connected" : "disconnected");
+				emit this->headphonesChanged(connected);
+			}
+		}
+	}
+}
+
+void OSS::initializeJackStates() {
+	QProcess sysctl;
+	sysctl.start("sysctl", QStringList() << "-a");
+	if (!sysctl.waitForFinished(500)) {
+		qCWarning(logOSS) << "sysctl timeout";
+		return;
+	}
+
+	const QString output = QString::fromUtf8(sysctl.readAllStandardOutput());
+	const QStringList lines = output.split('\n');
+
+	for (const QString& line: lines) {
+		// Look for jack pins
+		if (line.contains("dev.hdaa.") && line.contains(": pin:") && line.contains("Jack")) {
+			const QRegularExpression regex(R"(dev\.hdaa\.\d+\.nid(\d+):\s+pin:\s+(.+))");
+			auto match = regex.match(line);
+
+			if (match.hasMatch()) {
+				const int nid = match.captured(1).toInt();
+				const QString pinDesc = match.captured(2);
+
+				// Skip disabled or internal (Fixed/None) pins
+				if (pinDesc.contains("DISABLED") || pinDesc.contains("(None)")
+				    || pinDesc.contains("(Fixed)"))
+				{
+					continue;
+				}
+
+				qCDebug(logOSS) << "Found jack: nid=" << nid << "desc=" << pinDesc;
+
+				// Initialize as disconnected
+				this->mJackStates[nid] = false;
+
+				if (pinDesc.contains("Headphones", Qt::CaseInsensitive)) {
+					this->mHeadphonesConnected = false;
+					qCInfo(logOSS) << "Found headphone jack at nid" << nid;
+				}
+			}
+		}
+	}
+
+	qCDebug(logOSS) << "Initialized" << this->mJackStates.size() << "jacks";
+
+	this->readRecentLogMessages();
+	this->syncJackProperties();
+}
+
+void OSS::readNewLogLines() {
+	QFile logFile;
+	if (!logFile.open(
+	        this->mLogFileDescriptor,
+	        QIODevice::ReadOnly | QIODevice::Text,
+	        QFileDevice::DontCloseHandle
+	    ))
+	{
+		return;
+	}
+
+	logFile.seek(this->mLogFilePosition);
+
+	QTextStream in(&logFile);
+	while (!in.atEnd()) {
+		const QString line = in.readLine();
+		this->parseLogLine(line);
+	}
+
+	// Update position for the next read
+	this->mLogFilePosition = logFile.pos();
+}
+
+void OSS::parseLogLine(const QString& line) {
+	if (!line.contains("Pin sense:")) {
+		return;
+	}
+
+	// Extract nid number
+	const QRegularExpression nidRegex(R"(nid=(\d+))");
+	auto nidMatch = nidRegex.match(line);
+
+	if (!nidMatch.hasMatch()) {
+		return;
+	}
+
+	const int nid = nidMatch.captured(1).toInt();
+
+	bool connected = false;
+	if (line.contains("(connected)")) {
+		connected = true;
+	} else if (line.contains("(disconnected)")) {
+		connected = false;
+	} else {
+		return; // Unknown state
+	}
+
+	if (this->mJackStates.value(nid, !connected) != connected) {
+		this->mJackStates[nid] = connected;
+
+		qCInfo(logOSS) << "Jack state changed: nid=" << nid
+		               << (connected ? "connected" : "disconnected");
+
+		emit this->jackStateChanged(nid, connected);
+		this->identifyJackType(nid, connected);
+	}
+}
+
+void OSS::readRecentLogMessages() {
+	QFile logFile("/var/log/messages");
+	if (!logFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
+		qCWarning(logOSS) << "Cannot read /var/log/messages for initial state";
+		return;
+	}
+
+	// Read last 8KB for recent events
+	const qint64 size = logFile.size();
+	if (size > 8192) {
+		logFile.seek(size - 8192);
+	}
+
+	QTextStream in(&logFile);
+	const QString content = in.readAll();
+	logFile.close();
+
+	const QStringList lines = content.split('\n');
+	QHash<int, bool> lastLoggedState;
+
+	for (const QString& line: lines) {
+		if (!line.contains("Pin sense:")) {
+			continue;
+		}
+
+		const QRegularExpression nidRegex(R"(nid=(\d+))");
+		auto nidMatch = nidRegex.match(line);
+
+		if (!nidMatch.hasMatch()) {
+			continue;
+		}
+
+		const int nid = nidMatch.captured(1).toInt();
+		const bool connected = line.contains("(connected)");
+
+		lastLoggedState[nid] = connected;
+	}
+
+	for (auto it = lastLoggedState.constBegin(); it != lastLoggedState.constEnd(); ++it) {
+		const int nid = it.key();
+		const bool connected = it.value();
+
+		if (this->mJackStates.contains(nid)) {
+			this->mJackStates[nid] = connected;
+		}
+	}
+
+	qCDebug(logOSS) << "After reading log, jack states:" << this->mJackStates;
+}
+
+bool OSS::headphonesConnected() const { return this->mHeadphonesConnected; }
+
 void OSS::scanDevices() {
 	if (this->mDefaultDevice != nullptr) {
 		this->mDefaultDevice = nullptr;