From 27cf51f896d8d7c75da29ea8e185c2a75ed3d7a2 Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Sun, 15 Sep 2024 14:02:36 +0200
Subject: [PATCH 1/5] Add Illumination Light control interface for HID++ 2.0

Just the power on/off is implemented for now.

Documented in x1990_illumination_v1.pdf in:
https://drive.google.com/drive/folders/0BxbRzx7vEV7eWmgwazJ3NUFfQ28
---
 src/libhidpp/CMakeLists.txt                   |  1 +
 src/libhidpp/hidpp20/IIllumination.cpp        | 46 +++++++++
 src/libhidpp/hidpp20/IIllumination.h          | 67 +++++++++++++
 src/tools/CMakeLists.txt                      |  1 +
 src/tools/hidpp-list-features.cpp             |  1 +
 .../hidpp20-illumination-light-control.cpp    | 96 +++++++++++++++++++
 6 files changed, 212 insertions(+)
 create mode 100644 src/libhidpp/hidpp20/IIllumination.cpp
 create mode 100644 src/libhidpp/hidpp20/IIllumination.h
 create mode 100644 src/tools/hidpp20-illumination-light-control.cpp

diff --git a/src/libhidpp/CMakeLists.txt b/src/libhidpp/CMakeLists.txt
index c096cb1..10e2fa2 100644
--- a/src/libhidpp/CMakeLists.txt
+++ b/src/libhidpp/CMakeLists.txt
@@ -55,6 +55,7 @@ set(LIBHIDPP_SOURCES
 	hidpp20/ITouchpadRawXY.cpp
 	hidpp20/ILEDControl.cpp
 	hidpp20/IBatteryLevelStatus.cpp
+	hidpp20/IIllumination.cpp
 	hidpp20/ProfileDirectoryFormat.cpp
 	hidpp20/ProfileFormat.cpp
 	hidpp20/MemoryMapping.cpp
diff --git a/src/libhidpp/hidpp20/IIllumination.cpp b/src/libhidpp/hidpp20/IIllumination.cpp
new file mode 100644
index 0000000..957463f
--- /dev/null
+++ b/src/libhidpp/hidpp20/IIllumination.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 Bastien Nocera
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <hidpp20/IIllumination.h>
+
+#include <misc/Endian.h>
+
+#include <cassert>
+
+using namespace HIDPP20;
+
+constexpr uint16_t IIllumination::ID;
+
+IIllumination::IIllumination (Device *dev):
+	FeatureInterface (dev, ID, "Illumination")
+{
+}
+
+bool IIllumination::getIllumination(void)
+{
+	std::vector<uint8_t> params (16), results;
+	results = call (GetIllumination, params);
+	return readLE<uint8_t> (results, 0) != 0;
+}
+
+void IIllumination::setIllumination(bool state)
+{
+	std::vector<uint8_t> params (16);
+	writeLE<uint8_t> (params, 0, state);
+	call (SetIllumination, params);
+}
diff --git a/src/libhidpp/hidpp20/IIllumination.h b/src/libhidpp/hidpp20/IIllumination.h
new file mode 100644
index 0000000..9edb805
--- /dev/null
+++ b/src/libhidpp/hidpp20/IIllumination.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2024 Bastien Nocera
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef LIBHIDPP_HIDPP20_IILLUMINATION_H
+#define LIBHIDPP_HIDPP20_IILLUMINATION_H
+
+#include <hidpp20/FeatureInterface.h>
+
+namespace HIDPP20
+{
+
+/**
+ * Control non-RGB LED features.
+ */
+class IIllumination: public FeatureInterface
+{
+public:
+	static constexpr uint16_t ID = 0x1990;
+
+	enum Function {
+		GetIllumination = 0,
+		SetIllumination = 1,
+		GetBrightnessInfo = 2,
+		GetBrightness = 3,
+		SetBrightness = 4,
+		GetBrightnessLevels = 5,
+		SetBrightnessLevels = 6,
+		GetColorTemperatureInfo = 7,
+		GetColorTemperature = 8,
+		SetColorTemperature = 9,
+		GetColorTemperatureLevels = 10,
+		SetColorTemperatureLevels = 11,
+		GetBrightnessEffectiveMax = 12,
+	};
+
+	IIllumination (Device *dev);
+
+	/**
+	 * Get the current Illumination state.
+	 */
+	bool getIllumination(void);
+
+	/**
+	 * Set the current Illumination state.
+	 */
+	void setIllumination(bool state);
+};
+
+}
+
+#endif
+
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index ffda9de..b7c18fa 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -32,6 +32,7 @@ set(TOOLS
 	hidpp20-onboard-profiles-get-description
 	hidpp20-reprog-controls
 	hidpp20-led-control
+	hidpp20-illumination-light-control
 	hidpp20-dump-page
 	hidpp20-write-page
 	hidpp20-write-data
diff --git a/src/tools/hidpp-list-features.cpp b/src/tools/hidpp-list-features.cpp
index 8d36e97..658d370 100644
--- a/src/tools/hidpp-list-features.cpp
+++ b/src/tools/hidpp-list-features.cpp
@@ -59,6 +59,7 @@ static const std::map<uint16_t, const char *> HIDPP20Features = {
 	{ 0x1981, "Backlight" },
 	{ 0x1982, "Backlight" },
 	{ 0x1983, "Backlight" },
+	{ 0x1990, "Illumination Light control" },
 	{ 0x1a00, "Presenter control" },
 	{ 0x1a01, "3D sensor" },
 	{ 0x1b00, "Reprog controls" },
diff --git a/src/tools/hidpp20-illumination-light-control.cpp b/src/tools/hidpp20-illumination-light-control.cpp
new file mode 100644
index 0000000..5448bbc
--- /dev/null
+++ b/src/tools/hidpp20-illumination-light-control.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2024 Bastien Nocera
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <hidpp/SimpleDispatcher.h>
+#include <hidpp20/Device.h>
+#include <hidpp20/Error.h>
+#include <hidpp20/IIllumination.h>
+#include <cstdio>
+#include <iostream>
+#include <memory>
+
+#include "common/common.h"
+#include "common/Option.h"
+#include "common/CommonOptions.h"
+
+using namespace HIDPP20;
+
+int main (int argc, char *argv[])
+{
+	static const char *args = "device_path state|toggle [params...]";
+	HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;
+
+	std::vector<Option> options = {
+		DeviceIndexOption (device_index),
+		VerboseOption (),
+	};
+	Option help = HelpOption (argv[0], args, &options);
+	options.push_back (help);
+
+	int first_arg;
+	if (!Option::processOptions (argc, argv, options, first_arg))
+		return EXIT_FAILURE;
+
+	if (argc-first_arg < 2) {
+		std::cerr << "Too few arguments." << std::endl;
+		std::cerr << getUsage (argv[0], args, &options) << std::endl;
+		return EXIT_FAILURE;
+	}
+
+	const char *path = argv[first_arg];
+	std::string op = argv[first_arg+1];
+	first_arg += 2;
+
+	std::unique_ptr<HIDPP::Dispatcher> dispatcher;
+	try {
+		dispatcher = std::make_unique<HIDPP::SimpleDispatcher> (path);
+	}
+	catch (std::exception &e) {
+		std::cerr << "Failed to open device: " << e.what () << "." << std::endl;
+		return EXIT_FAILURE;
+	}
+	Device dev (dispatcher.get (), device_index);
+	try {
+		IIllumination ill (&dev);
+		if (op == "state") {
+			if (argc-first_arg < 1) {
+				bool state = ill.getIllumination();
+				std::cout << "\tstate: " << state << std::endl;
+			}
+			else {
+				char *endptr;
+				bool new_state = strtol (argv[first_arg], &endptr, 0) != 0;
+				ill.setIllumination(new_state);
+			}
+		}
+		else if (op == "toggle") {
+			bool state = ill.getIllumination();
+			ill.setIllumination(!state);
+		}
+		else {
+			std::cerr << "Invalid operation: " << op << "." << std::endl;
+			return EXIT_FAILURE;
+		}
+	}
+	catch (Error &e) {
+		std::cerr << "Error code " << e.errorCode () << ": " << e.what () << std::endl;
+		return e.errorCode ();
+	}
+
+	return EXIT_SUCCESS;
+}

From 70bceb9be793ed66f177aef1604fb2dffb36a463 Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Sun, 15 Sep 2024 18:13:07 +0200
Subject: [PATCH 2/5] Implement brightness and color temp controls for
 Illumination

---
 src/libhidpp/hidpp20/IIllumination.cpp        | 67 +++++++++++++++++++
 src/libhidpp/hidpp20/IIllumination.h          | 51 ++++++++++++++
 .../hidpp20-illumination-light-control.cpp    | 42 +++++++++++-
 3 files changed, 159 insertions(+), 1 deletion(-)

diff --git a/src/libhidpp/hidpp20/IIllumination.cpp b/src/libhidpp/hidpp20/IIllumination.cpp
index 957463f..59eb84b 100644
--- a/src/libhidpp/hidpp20/IIllumination.cpp
+++ b/src/libhidpp/hidpp20/IIllumination.cpp
@@ -44,3 +44,70 @@ void IIllumination::setIllumination(bool state)
 	writeLE<uint8_t> (params, 0, state);
 	call (SetIllumination, params);
 }
+
+IIllumination::Info IIllumination::getBrightnessInfo(void)
+{
+	std::vector<uint8_t> params (16), results;
+	results = call (GetBrightnessInfo, params);
+	return Info {
+		(uint8_t)(readLE<uint8_t> (results, 0) & 0x0f), // capabilities
+		readBE<uint16_t> (results, 1),      // min
+		readBE<uint16_t> (results, 3),      // max
+		readBE<uint16_t> (results, 5),      // res
+		(uint8_t)(readLE<uint8_t> (results, 7) & 0x0f), // maxLevels
+	};
+}
+
+uint16_t IIllumination::getBrightness(void)
+{
+	uint16_t value;
+	std::vector<uint8_t> params (16), results;
+	results = call (GetBrightness, params);
+	value = readBE<uint16_t> (results, 0);
+	return value;
+}
+
+uint16_t IIllumination::getBrightnessEffectiveMax(void)
+{
+	uint16_t value;
+	std::vector<uint8_t> params (16), results;
+	results = call (GetBrightnessEffectiveMax, params);
+	value = readBE<uint16_t> (results, 0);
+	return value;
+}
+
+void IIllumination::setBrightness(uint16_t value)
+{
+	std::vector<uint8_t> params (16);
+	writeBE<uint16_t> (params, 0, value);
+	call (SetBrightness, params);
+}
+
+IIllumination::Info IIllumination::getColorTemperatureInfo(void)
+{
+	std::vector<uint8_t> params (16), results;
+	results = call (GetColorTemperatureInfo, params);
+	return Info {
+		(uint8_t)(readLE<uint8_t> (results, 0) & 0x0f), // capabilities
+		readBE<uint16_t> (results, 1),      // min
+		readBE<uint16_t> (results, 3),      // max
+		readBE<uint16_t> (results, 5),      // res
+		(uint8_t)(readLE<uint8_t> (results, 7) & 0x0f), // maxLevels
+	};
+}
+
+uint16_t IIllumination::getColorTemperature(void)
+{
+	uint16_t value;
+	std::vector<uint8_t> params (16), results;
+	results = call (GetColorTemperature, params);
+	value = readBE<uint16_t> (results, 0);
+	return value;
+}
+
+void IIllumination::setColorTemperature(uint16_t value)
+{
+	std::vector<uint8_t> params (16);
+	writeBE<uint16_t> (params, 0, value);
+	call (SetColorTemperature, params);
+}
diff --git a/src/libhidpp/hidpp20/IIllumination.h b/src/libhidpp/hidpp20/IIllumination.h
index 9edb805..9a4171e 100644
--- a/src/libhidpp/hidpp20/IIllumination.h
+++ b/src/libhidpp/hidpp20/IIllumination.h
@@ -48,6 +48,21 @@ class IIllumination: public FeatureInterface
 		GetBrightnessEffectiveMax = 12,
 	};
 
+	enum Flags {
+		hasEvents = 1 << 0,
+		hasLinearLevels = 1 << 1,
+		hasNonLinearLevels = 1 << 2,
+		hasDynamicMaximum = 1 << 3,
+	};
+
+	struct Info {
+		uint8_t flags;
+		uint16_t min;
+		uint16_t max;
+		uint16_t res;
+		unsigned int maxLevels : 4;
+	};
+
 	IIllumination (Device *dev);
 
 	/**
@@ -59,6 +74,42 @@ class IIllumination: public FeatureInterface
 	 * Set the current Illumination state.
 	 */
 	void setIllumination(bool state);
+
+	/**
+	 * Get information about brightness.
+	 */
+	Info getBrightnessInfo(void);
+
+	/**
+	 * Get the current Illumination brightness.
+	 */
+	uint16_t getBrightness(void);
+
+	/**
+	 * Get the maximum brightness based on hardware limits,
+	 * 0 means the max value from getBrightnessInfo().
+	 */
+	uint16_t getBrightnessEffectiveMax(void);
+
+	/**
+	 * Set the Illumination brightness.
+	 */
+	void setBrightness(uint16_t value);
+
+	/**
+	 * Get information about color temperature.
+	 */
+	Info getColorTemperatureInfo(void);
+
+	/**
+	 * Get the current Illumination color temperature.
+	 */
+	uint16_t getColorTemperature(void);
+
+	/**
+	 * Set the Illumination color temperature.
+	 */
+	void setColorTemperature(uint16_t value);
 };
 
 }
diff --git a/src/tools/hidpp20-illumination-light-control.cpp b/src/tools/hidpp20-illumination-light-control.cpp
index 5448bbc..a3cbcf0 100644
--- a/src/tools/hidpp20-illumination-light-control.cpp
+++ b/src/tools/hidpp20-illumination-light-control.cpp
@@ -32,7 +32,7 @@ using namespace HIDPP20;
 
 int main (int argc, char *argv[])
 {
-	static const char *args = "device_path state|toggle [params...]";
+	static const char *args = "device_path state|toggle|brightness|temp [params...]";
 	HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;
 
 	std::vector<Option> options = {
@@ -82,6 +82,46 @@ int main (int argc, char *argv[])
 			bool state = ill.getIllumination();
 			ill.setIllumination(!state);
 		}
+		else if (op == "brightness") {
+			if (argc-first_arg < 1) {
+				uint16_t value = ill.getBrightness();
+				std::cout << "\tbrightness: " << value << std::endl;
+				IIllumination::Info info = ill.getBrightnessInfo();
+				std::cout << "\tmin: " << info.min << std::endl;
+				std::cout << "\tmax: " << info.max << std::endl;
+				std::cout << "\tres: " << info.res << std::endl;
+				value = ill.getBrightnessEffectiveMax();
+				std::cout << "\teffective max: " << (value != 0 ? value : info.max)  << std::endl;
+			}
+			else {
+				char *endptr;
+				long new_value = strtol (argv[first_arg], &endptr, 0);
+				if (*endptr != '\0' || new_value < 0 || new_value > UINT16_MAX) {
+					std::cerr << "Invalid brightness value." << std::endl;
+					return EXIT_FAILURE;
+				}
+				ill.setBrightness(new_value);
+			}
+		}
+		else if (op == "temp") {
+			if (argc-first_arg < 1) {
+				uint16_t value = ill.getColorTemperature();
+				std::cout << "\ttemperature: " << value << std::endl;
+				IIllumination::Info info = ill.getColorTemperatureInfo();
+				std::cout << "\tmin: " << info.min << std::endl;
+				std::cout << "\tmax: " << info.max << std::endl;
+				std::cout << "\tres: " << info.res << std::endl;
+			}
+			else {
+				char *endptr;
+				long new_value = strtol (argv[first_arg], &endptr, 0);
+				if (*endptr != '\0' || new_value < 0 || new_value > UINT16_MAX) {
+					std::cerr << "Invalid color temperature value." << std::endl;
+					return EXIT_FAILURE;
+				}
+				ill.setColorTemperature(new_value);
+			}
+		}
 		else {
 			std::cerr << "Invalid operation: " << op << "." << std::endl;
 			return EXIT_FAILURE;

From 49598f1a1a99e10536db20aec47482a6a3a2a3a4 Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Mon, 16 Sep 2024 00:38:51 +0200
Subject: [PATCH 3/5] Add Illumination events parsing

---
 src/libhidpp/hidpp20/IIllumination.cpp | 35 ++++++++++++++++++++++++++
 src/libhidpp/hidpp20/IIllumination.h   | 35 ++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)

diff --git a/src/libhidpp/hidpp20/IIllumination.cpp b/src/libhidpp/hidpp20/IIllumination.cpp
index 59eb84b..4c4f4fc 100644
--- a/src/libhidpp/hidpp20/IIllumination.cpp
+++ b/src/libhidpp/hidpp20/IIllumination.cpp
@@ -111,3 +111,38 @@ void IIllumination::setColorTemperature(uint16_t value)
 	writeBE<uint16_t> (params, 0, value);
 	call (SetColorTemperature, params);
 }
+
+bool IIllumination::illuminationChangeEvent (const HIDPP::Report &event)
+{
+	assert (event.function () == IIllumination::IlluminationChangeEvent);
+	auto params = event.parameterBegin ();
+	return readLE<uint8_t> (params) != 0;
+}
+
+uint16_t IIllumination::brightnessChangeEvent (const HIDPP::Report &event)
+{
+	assert (event.function () == IIllumination::BrightnessChangeEvent);
+	auto params = event.parameterBegin ();
+	return readBE<uint16_t> (params);
+}
+
+uint16_t IIllumination::colorTemperatureChangeEvent (const HIDPP::Report &event)
+{
+	assert (event.function () == IIllumination::ColorTemperatureChangeEvent);
+	auto params = event.parameterBegin ();
+	return readBE<uint16_t> (params);
+}
+
+uint16_t IIllumination::brightnessEffectiveMaxChangeEvent (const HIDPP::Report &event)
+{
+	assert (event.function () == IIllumination::BrightnessEffectiveMaxChangeEvent);
+	auto params = event.parameterBegin ();
+	return readBE<uint16_t> (params);
+}
+
+uint16_t IIllumination::brightnessClampedEvent (const HIDPP::Report &event)
+{
+	assert (event.function () == IIllumination::BrightnessClampedEvent);
+	auto params = event.parameterBegin ();
+	return readBE<uint16_t> (params);
+}
diff --git a/src/libhidpp/hidpp20/IIllumination.h b/src/libhidpp/hidpp20/IIllumination.h
index 9a4171e..2789847 100644
--- a/src/libhidpp/hidpp20/IIllumination.h
+++ b/src/libhidpp/hidpp20/IIllumination.h
@@ -48,6 +48,14 @@ class IIllumination: public FeatureInterface
 		GetBrightnessEffectiveMax = 12,
 	};
 
+	enum Event {
+		IlluminationChangeEvent = 0,
+		BrightnessChangeEvent = 1,
+		ColorTemperatureChangeEvent = 2,
+		BrightnessEffectiveMaxChangeEvent = 3,
+		BrightnessClampedEvent = 4,
+	};
+
 	enum Flags {
 		hasEvents = 1 << 0,
 		hasLinearLevels = 1 << 1,
@@ -110,6 +118,33 @@ class IIllumination: public FeatureInterface
 	 * Set the Illumination color temperature.
 	 */
 	void setColorTemperature(uint16_t value);
+
+	/**
+	 * Parse an illumination change event.
+	 */
+	static bool illuminationChangeEvent (const HIDPP::Report &event);
+
+	/**
+	 * Parse a brightness change event.
+	 */
+	static uint16_t brightnessChangeEvent (const HIDPP::Report &event);
+
+	/**
+	 * Parse a color temperature change event.
+	 */
+	static uint16_t colorTemperatureChangeEvent (const HIDPP::Report &event);
+
+	/**
+	 * Parse a change in the effective maximum brightness.
+	 */
+	static uint16_t brightnessEffectiveMaxChangeEvent (const HIDPP::Report &event);
+
+	/**
+	 * Parse a notification of a recent request to set the
+	 * brightness to a value larger than the current effective
+	 * maximum brightness.
+	 */
+	static uint16_t brightnessClampedEvent (const HIDPP::Report &event);
 };
 
 }

From cd0a7fddc9a88c0363c7781be0a9f48e1b89ba20 Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Mon, 16 Sep 2024 10:57:30 +0200
Subject: [PATCH 4/5] Add monitor function to Illumination tool

---
 .../hidpp20-illumination-light-control.cpp    | 185 +++++++++++++++++-
 1 file changed, 183 insertions(+), 2 deletions(-)

diff --git a/src/tools/hidpp20-illumination-light-control.cpp b/src/tools/hidpp20-illumination-light-control.cpp
index a3cbcf0..0a2fdfe 100644
--- a/src/tools/hidpp20-illumination-light-control.cpp
+++ b/src/tools/hidpp20-illumination-light-control.cpp
@@ -20,6 +20,7 @@
 #include <hidpp20/Device.h>
 #include <hidpp20/Error.h>
 #include <hidpp20/IIllumination.h>
+#include <hidpp20/UnsupportedFeature.h>
 #include <cstdio>
 #include <iostream>
 #include <memory>
@@ -27,9 +28,170 @@
 #include "common/common.h"
 #include "common/Option.h"
 #include "common/CommonOptions.h"
+#include "common/EventQueue.h"
+
+extern "C" {
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+}
 
 using namespace HIDPP20;
 
+class EventHandler
+{
+public:
+	virtual const HIDPP20::FeatureInterface *feature () const = 0;
+	virtual void handleEvent (const HIDPP::Report &event) = 0;
+};
+
+class IlluminationEventHandler: public EventHandler
+{
+	HIDPP20::IIllumination _ill;
+	bool _state;
+	uint16_t _brightness;
+	uint16_t _temperature;
+	uint16_t _eff_max;
+public:
+	IlluminationEventHandler (HIDPP20::Device *dev):
+		_ill (dev),
+		_state (_ill.getIllumination ()),
+		_brightness (_ill.getBrightness()),
+		_temperature (_ill.getColorTemperature()),
+		_eff_max (_ill.getBrightnessEffectiveMax())
+	{
+		printf ("Light is %s\n", _state ? "on" : "off");
+	}
+
+	const HIDPP20::FeatureInterface *feature () const
+	{
+		return &_ill;
+	}
+
+	void handleEvent (const HIDPP::Report &event)
+	{
+		bool new_state;
+		uint16_t value;
+
+		switch (event.function ()) {
+		case IIllumination::IlluminationChangeEvent:
+			new_state = IIllumination::illuminationChangeEvent (event);
+			if (new_state != _state) {
+				printf ("Light turned %s\n", new_state ? "on" : "off");
+				_state = new_state;
+			}
+			break;
+		case IIllumination::BrightnessChangeEvent:
+			value = IIllumination::brightnessChangeEvent (event);
+			if (value != _brightness) {
+				printf ("Brightness changed from %u to %u\n", _brightness, value);
+				_brightness = value;
+			}
+			break;
+		case IIllumination::ColorTemperatureChangeEvent:
+			value = IIllumination::colorTemperatureChangeEvent (event);
+			if (value != _temperature) {
+				printf ("Color temperature changed from %u to %u\n", _temperature, value);
+				_temperature = value;
+			}
+			break;
+		case IIllumination::BrightnessEffectiveMaxChangeEvent:
+			value = IIllumination::brightnessEffectiveMaxChangeEvent (event);
+			if (value != _eff_max) {
+				printf ("Effective max brightness changed from %u to %u\n", _eff_max, value);
+				_eff_max = value;
+			}
+			break;
+		case IIllumination::BrightnessClampedEvent:
+			value = IIllumination::brightnessClampedEvent (event);
+			printf ("Brightness clamped to %u\n", value);
+			break;
+		}
+	}
+};
+
+class EventListener
+{
+	HIDPP::Dispatcher *dispatcher;
+	HIDPP::DeviceIndex index;
+	std::map<uint8_t, std::unique_ptr<EventHandler>> handlers;
+	std::map<uint8_t, HIDPP::Dispatcher::listener_iterator> iterators;
+public:
+	EventListener (HIDPP::Dispatcher *dispatcher, HIDPP::DeviceIndex index):
+		dispatcher (dispatcher),
+		index (index)
+	{
+	}
+
+	virtual ~EventListener ()
+	{
+		removeEventHandlers ();
+	}
+
+	virtual void addEventHandler (std::unique_ptr<EventHandler> &&handler)
+	{
+		uint8_t feature = handler->feature ()->index ();
+		EventHandler *ptr = handler.get ();
+		handlers.emplace (feature, std::move (handler));
+		auto it = dispatcher->registerEventHandler (index, feature, [ptr] (const HIDPP::Report &report) {
+			ptr->handleEvent (report);
+			return true;
+		});
+		iterators.emplace (feature, it);
+	}
+
+	virtual void removeEventHandlers ()
+	{
+		for (const auto &p: iterators)
+			dispatcher->unregisterEventHandler (p.second);
+		handlers.clear ();
+		iterators.clear ();
+	}
+
+	virtual void start () = 0;
+	virtual void stop () = 0;
+
+protected:
+	virtual bool event (EventHandler *handler, const HIDPP::Report &report) = 0;
+};
+
+class SimpleListener: public EventListener
+{
+	HIDPP::SimpleDispatcher *dispatcher;
+public:
+	SimpleListener (HIDPP::SimpleDispatcher *dispatcher, HIDPP::DeviceIndex index):
+		EventListener (dispatcher, index),
+		dispatcher (dispatcher)
+	{
+	}
+
+	virtual void start ()
+	{
+		dispatcher->listen ();
+	}
+
+	virtual void stop ()
+	{
+		dispatcher->stop ();
+	}
+
+protected:
+	virtual bool event (EventHandler *handler, const HIDPP::Report &report)
+	{
+		handler->handleEvent (report);
+		return true;
+	}
+};
+
+EventListener *listener;
+
+void sigint (int)
+{
+	listener->stop ();
+}
+
+
+
 int main (int argc, char *argv[])
 {
 	static const char *args = "device_path state|toggle|brightness|temp [params...]";
@@ -56,7 +218,7 @@ int main (int argc, char *argv[])
 	std::string op = argv[first_arg+1];
 	first_arg += 2;
 
-	std::unique_ptr<HIDPP::Dispatcher> dispatcher;
+	std::unique_ptr<HIDPP::SimpleDispatcher> dispatcher;
 	try {
 		dispatcher = std::make_unique<HIDPP::SimpleDispatcher> (path);
 	}
@@ -64,7 +226,7 @@ int main (int argc, char *argv[])
 		std::cerr << "Failed to open device: " << e.what () << "." << std::endl;
 		return EXIT_FAILURE;
 	}
-	Device dev (dispatcher.get (), device_index);
+	HIDPP20::Device dev (dispatcher.get (), device_index);
 	try {
 		IIllumination ill (&dev);
 		if (op == "state") {
@@ -122,6 +284,25 @@ int main (int argc, char *argv[])
 				ill.setColorTemperature(new_value);
 			}
 		}
+		else if (op == "monitor") {
+			struct sigaction sa, oldsa;
+			memset (&sa, 0, sizeof (struct sigaction));
+			sa.sa_handler = sigint;
+			sigaction (SIGINT, &sa, &oldsa);
+
+			listener = new SimpleListener (dispatcher.get (), device_index);
+			try {
+				listener->addEventHandler (std::make_unique<IlluminationEventHandler> (&dev));
+			}
+			catch (HIDPP20::UnsupportedFeature &e) {
+				printf ("%s\n", e.what ());
+			}
+
+			listener->start();
+			listener->removeEventHandlers ();
+			sigaction (SIGINT, &oldsa, nullptr);
+			delete listener;
+		}
 		else {
 			std::cerr << "Invalid operation: " << op << "." << std::endl;
 			return EXIT_FAILURE;

From f8d09b920110afa59e4098905bf98c96ed4669b3 Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Wed, 23 Oct 2024 00:20:28 +0200
Subject: [PATCH 5/5] Handle missing getBrightnessEffectiveMax() function
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Litra Glow doesn't support a different effective maximum brightness,
so return 0 as the value for that variable as it “[signifies] that there
is no effective maximum brightness in effect”.
---
 src/libhidpp/hidpp20/IIllumination.cpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/libhidpp/hidpp20/IIllumination.cpp b/src/libhidpp/hidpp20/IIllumination.cpp
index 4c4f4fc..7b8b944 100644
--- a/src/libhidpp/hidpp20/IIllumination.cpp
+++ b/src/libhidpp/hidpp20/IIllumination.cpp
@@ -17,6 +17,7 @@
  */
 
 #include <hidpp20/IIllumination.h>
+#include <hidpp20/Error.h>
 
 #include <misc/Endian.h>
 
@@ -71,8 +72,15 @@ uint16_t IIllumination::getBrightnessEffectiveMax(void)
 {
 	uint16_t value;
 	std::vector<uint8_t> params (16), results;
-	results = call (GetBrightnessEffectiveMax, params);
-	value = readBE<uint16_t> (results, 0);
+	try {
+		results = call (GetBrightnessEffectiveMax, params);
+		value = readBE<uint16_t> (results, 0);
+	}
+	catch (HIDPP20::Error &e) {
+		if (e.errorCode () == HIDPP20::Error::InvalidFunctionID)
+			value = 0;
+		else throw e;
+	}
 	return value;
 }