CAP_DW_STATE = Map.ofEntries(entry("@DW_STATE_POWER_OFF_W", "Off"),
+ entry("@DW_STATE_INITIAL_W", "Initial"), entry("@DW_STATE_RUNNING_W", "Running"),
+ entry("@DW_STATE_PAUSE_W", "Paused"), entry("@DW_STATE_STANDBY_W", "Stand By"),
+ entry("@DW_STATE_COMPLETE_W", "Complete"), entry("@DW_STATE_POWER_FAIL_W", "Power Fail"));
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiClientService.java
new file mode 100644
index 00000000000..f2dfa868fb0
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiClientService.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACCanonicalSnapshot;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACTargetTmp;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ExtendedDeviceInfo;
+
+/**
+ * The {@link LGThinQACApiClientService} interface provides a common abstraction for handling AC-related
+ * API interactions with LG ThinQ devices. It supports both protocol versions V1 and V2.
+ *
+ * This interface allows external components to change various air conditioner settings, such as
+ * operation mode, fan speed, temperature, and additional features like Jet Mode and Energy Saving Mode.
+ *
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public interface LGThinQACApiClientService extends LGThinQApiClientService {
+
+ /**
+ * Changes the air conditioner's operation mode (e.g., Cool, Heat, Fan).
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param newOpMode The new operation mode to be set.
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void changeOperationMode(String bridgeName, String deviceId, int newOpMode) throws LGThinqApiException;
+
+ /**
+ * Adjusts the fan speed of the air conditioner.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param newFanSpeed The desired fan speed level.
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void changeFanSpeed(String bridgeName, String deviceId, int newFanSpeed) throws LGThinqApiException;
+
+ /**
+ * Adjusts the vertical orientation of the AC fan.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param currentSnap The current snapshot of AC device data.
+ * @param newStep The new vertical position.
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void changeStepUpDown(String bridgeName, String deviceId, ACCanonicalSnapshot currentSnap, int newStep)
+ throws LGThinqApiException;
+
+ /**
+ * Adjusts the horizontal orientation of the AC fan.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param currentSnap The current snapshot of AC device data.
+ * @param newStep The new horizontal position.
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void changeStepLeftRight(String bridgeName, String deviceId, ACCanonicalSnapshot currentSnap, int newStep)
+ throws LGThinqApiException;
+
+ /**
+ * Changes the target temperature of the air conditioner.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param newTargetTemp The new target temperature to be set.
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void changeTargetTemperature(String bridgeName, String deviceId, ACTargetTmp newTargetTemp)
+ throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Jet Mode feature.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param modeOnOff The desired state ("on" to enable, "off" to disable).
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void turnCoolJetMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Air Clean mode.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param modeOnOff The desired state ("on" to enable, "off" to disable).
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void turnAirCleanMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Auto Dry feature.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param modeOnOff The desired state ("on" to enable, "off" to disable).
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void turnAutoDryMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Energy Saving mode.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @param modeOnOff The desired state ("on" to enable, "off" to disable).
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ void turnEnergySavingMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException;
+
+ /**
+ * Retrieves extended device information, such as energy consumption and filter status.
+ *
+ * @param bridgeName The name of the bridge managing the device connection.
+ * @param deviceId The unique ID of the LG ThinQ AC device.
+ * @return An {@link ExtendedDeviceInfo} object containing the extended data of the device.
+ * @throws LGThinqApiException If an error occurs while invoking the LG API.
+ */
+ ExtendedDeviceInfo getExtendedDeviceInfo(String bridgeName, String deviceId) throws LGThinqApiException;
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiV1ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiV1ClientServiceImpl.java
new file mode 100644
index 00000000000..59929c4611f
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiV1ClientServiceImpl.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.*;
+
+import java.io.IOException;
+import java.util.Base64;
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACCanonicalSnapshot;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACTargetTmp;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ExtendedDeviceInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * The {@link LGThinQACApiV1ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQACApiV1ClientServiceImpl extends
+ LGThinQAbstractApiV1ClientService implements LGThinQACApiClientService {
+
+ private final Logger logger = LoggerFactory.getLogger(LGThinQACApiV1ClientServiceImpl.class);
+
+ protected LGThinQACApiV1ClientServiceImpl(HttpClient httpClient) {
+ super(ACCapability.class, ACCanonicalSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ // there's no before settings to send command
+ return false;
+ }
+
+ /**
+ * Get snapshot data from the device.
+ * It works only for API V2 device versions!
+ *
+ * @param deviceId device ID for de desired V2 LG Thinq.
+ * @param capDef
+ * @return return map containing metamodel of settings and snapshot
+ */
+ @Override
+ @Nullable
+ public ACCanonicalSnapshot getDeviceData(String bridgeName, String deviceId, CapabilityDefinition capDef) {
+ throw new UnsupportedOperationException("Method not supported in V1 API device.");
+ }
+
+ private void readDataResultNodeToObject(String jsonResult, Object obj) throws IOException {
+ JsonNode node = objectMapper.readTree(jsonResult);
+ JsonNode data = node.path(LG_ROOT_TAG_V1).path("returnData");
+ if (data.isTextual()) {
+ // analyses if its b64 or not
+ JsonNode format = node.path(LG_ROOT_TAG_V1).path("format");
+ if ("B64".equals(format.textValue())) {
+ String dataStr = new String(Base64.getDecoder().decode(data.textValue()));
+ objectMapper.readerForUpdating(obj).readValue(dataStr);
+ } else {
+ objectMapper.readerForUpdating(obj).readValue(data.textValue());
+ }
+ } else {
+ logger.warn("Data returned by LG API to get energy state is not present. Result:{}", node.toPrettyString());
+ }
+ }
+
+ @Override
+ public ExtendedDeviceInfo getExtendedDeviceInfo(String bridgeName, String deviceId) throws LGThinqApiException {
+ ExtendedDeviceInfo info = new ExtendedDeviceInfo();
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, LG_API_V1_CONTROL_OP, "Config", "Get", "",
+ "InOutInstantPower");
+ handleGenericErrorResult(resp);
+ readDataResultNodeToObject(resp.getJsonResponse(), info);
+
+ resp = sendCommand(bridgeName, deviceId, LG_API_V1_CONTROL_OP, "Config", "Get", "", "Filter");
+ handleGenericErrorResult(resp);
+ readDataResultNodeToObject(resp.getJsonResponse(), info);
+
+ return info;
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending command to LG API", e);
+ }
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", "Operation",
+ String.valueOf(newPowerState.commandValue()));
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting device power", e);
+ }
+ }
+
+ @Override
+ public void turnCoolJetMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "Jet", modeOnOff);
+ }
+
+ public void turnAirCleanMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "AirClean", modeOnOff);
+ }
+
+ public void turnAutoDryMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "AutoDry", modeOnOff);
+ }
+
+ public void turnEnergySavingMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "PowerSave", modeOnOff);
+ }
+
+ protected void turnGenericMode(String bridgeName, String deviceId, String modeName, String modeOnOff)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", modeName, modeOnOff);
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting " + modeName + " mode", e);
+ }
+ }
+
+ @Override
+ public void changeOperationMode(String bridgeName, String deviceId, int newOpMode) throws LGThinqApiException {
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", "OpMode", "" + newOpMode);
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting operation mode", e);
+ }
+ }
+
+ @Override
+ public void changeFanSpeed(String bridgeName, String deviceId, int newFanSpeed) throws LGThinqApiException {
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", "WindStrength",
+ String.valueOf(newFanSpeed));
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting fan speed", e);
+ }
+ }
+
+ @Override
+ public void changeStepUpDown(String bridgeName, String deviceId, ACCanonicalSnapshot currentSnap, int newStep)
+ throws LGThinqApiException {
+ Map<@Nullable String, @Nullable Object> subModeFeatures = Map.of("Jet", currentSnap.getCoolJetMode().intValue(),
+ "PowerSave", currentSnap.getEnergySavingMode().intValue(), "WDirVStep", newStep, "WDirHStep",
+ (int) currentSnap.getStepLeftRightMode());
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", subModeFeatures, null);
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error stepUpDown", e);
+ }
+ }
+
+ @Override
+ public void changeStepLeftRight(String bridgeName, String deviceId, ACCanonicalSnapshot currentSnap, int newStep)
+ throws LGThinqApiException {
+ Map<@Nullable String, @Nullable Object> subModeFeatures = Map.of("Jet", currentSnap.getCoolJetMode().intValue(),
+ "PowerSave", currentSnap.getEnergySavingMode().intValue(), "WDirVStep",
+ (int) currentSnap.getStepUpDownMode(), "WDirHStep", newStep);
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", subModeFeatures, null);
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error stepUpDown", e);
+ }
+ }
+
+ @Override
+ public void changeTargetTemperature(String bridgeName, String deviceId, ACTargetTmp newTargetTemp)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "", "Control", "Set", "TempCfg",
+ String.valueOf(newTargetTemp.commandValue()));
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting target temperature", e);
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiV2ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiV2ClientServiceImpl.java
new file mode 100644
index 00000000000..d0fadbb0dec
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQACApiV2ClientServiceImpl.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.io.IOException;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.DeviceTypes;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACCanonicalSnapshot;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ACTargetTmp;
+import org.openhab.binding.lgthinq.lgservices.model.devices.ac.ExtendedDeviceInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * The {@link LGThinQACApiV2ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQACApiV2ClientServiceImpl extends
+ LGThinQAbstractApiV2ClientService implements LGThinQACApiClientService {
+
+ private final Logger logger = LoggerFactory.getLogger(LGThinQACApiV2ClientServiceImpl.class);
+
+ protected LGThinQACApiV2ClientServiceImpl(HttpClient httpClient) {
+ super(ACCapability.class, ACCanonicalSnapshot.class, httpClient);
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Operation", "airState.operation",
+ newPowerState.commandValue());
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting device power", e);
+ }
+ }
+
+ @Override
+ public void turnCoolJetMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "airState.wMode.jet", modeOnOff);
+ }
+
+ public void turnAirCleanMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "airState.wMode.airClean", modeOnOff);
+ }
+
+ public void turnAutoDryMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "airState.miscFuncState.autoDry", modeOnOff);
+ }
+
+ public void turnEnergySavingMode(String bridgeName, String deviceId, String modeOnOff) throws LGThinqApiException {
+ turnGenericMode(bridgeName, deviceId, "airState.powerSave.basic", modeOnOff);
+ }
+
+ protected void turnGenericMode(String bridgeName, String deviceId, String modeName, String modeOnOff)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Operation", modeName,
+ Integer.parseInt(modeOnOff));
+ handleGenericErrorResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting cool jet mode", e);
+ }
+ }
+
+ @Override
+ public void changeOperationMode(String bridgeName, String deviceId, int newOpMode) throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Set", "airState.opMode", newOpMode);
+ handleGenericErrorResult(resp);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting operation mode", e);
+ }
+ }
+
+ @Override
+ public void changeFanSpeed(String bridgeName, String deviceId, int newFanSpeed) throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Set", "airState.windStrength",
+ newFanSpeed);
+ handleGenericErrorResult(resp);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting operation mode", e);
+ }
+ }
+
+ @Override
+ public void changeStepUpDown(String bridgeName, String deviceId, ACCanonicalSnapshot currentSnap, int newStep)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Set", "airState.wDir.vStep", newStep);
+ handleGenericErrorResult(resp);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting operation mode", e);
+ }
+ }
+
+ @Override
+ public void changeStepLeftRight(String bridgeName, String deviceId, ACCanonicalSnapshot currentSnap, int newStep)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Set", "airState.wDir.hStep", newStep);
+ handleGenericErrorResult(resp);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting operation mode", e);
+ }
+ }
+
+ @Override
+ public void changeTargetTemperature(String bridgeName, String deviceId, ACTargetTmp newTargetTemp)
+ throws LGThinqApiException {
+ try {
+ RestResult resp = sendBasicControlCommands(bridgeName, deviceId, "Set", "airState.tempState.target",
+ newTargetTemp.commandValue());
+ handleGenericErrorResult(resp);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error adjusting operation mode", e);
+ }
+ }
+
+ /**
+ * Start monitor data form specific device. This is old one, works only on V1 API supported devices.
+ *
+ * @param deviceId Device ID
+ * @return Work1 to be uses to grab data during monitoring.
+ */
+ @Override
+ public String startMonitor(String bridgeName, String deviceId) {
+ throw new UnsupportedOperationException("Not supported in V2 API.");
+ }
+
+ @Override
+ public void stopMonitor(String bridgeName, String deviceId, String workId) {
+ throw new UnsupportedOperationException("Not supported in V2 API.");
+ }
+
+ @Override
+ public @Nullable ACCanonicalSnapshot getMonitorData(String bridgeName, String deviceId, String workId,
+ DeviceTypes deviceType, ACCapability deviceCapability) {
+ throw new UnsupportedOperationException("Not supported in V2 API.");
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ try {
+ RestResult resp = sendCommand(bridgeName, deviceId, "control", "allEventEnable", "Set",
+ "airState.mon.timeout", "70");
+ handleGenericErrorResult(resp);
+ if (resp.getStatusCode() == 400) {
+ // Access Denied. Return false to indicate user don't have access to this functionality
+ return false;
+ }
+ } catch (Exception e) {
+ logger.debug("Can't execute Before Update command", e);
+ }
+ return true;
+ }
+
+ /**
+ * Expect receiving json of format: {
+ * ...
+ * result: {
+ * data: {
+ * ...
+ * }
+ * ...
+ * }
+ * }
+ * Data node will be deserialized into the object informed
+ *
+ * @param jsonResult json result
+ * @param obj object to be updated
+ * @throws IOException if there are errors deserialization the jsonResult
+ */
+ private void readDataResultNodeToObject(String jsonResult, Object obj) throws IOException {
+ JsonNode node = objectMapper.readTree(jsonResult);
+ JsonNode data = node.path("result").path("data");
+ if (data.isObject()) {
+ objectMapper.readerForUpdating(obj).readValue(data);
+ } else {
+ logger.warn("Data returned by LG API to get energy state is not present. Result:{}", node.toPrettyString());
+ }
+ }
+
+ @Override
+ public ExtendedDeviceInfo getExtendedDeviceInfo(String bridgeName, String deviceId) throws LGThinqApiException {
+ ExtendedDeviceInfo info = new ExtendedDeviceInfo();
+ try {
+ ObjectNode dataList = JsonNodeFactory.instance.objectNode();
+ dataList.put("dataGetList", (Integer) null);
+ dataList.put("dataSetList", (Integer) null);
+
+ RestResult resp = sendCommand(bridgeName, deviceId, "control-sync", "energyStateCtrl", "Get",
+ "airState.energy.totalCurrent", "null", dataList);
+ handleGenericErrorResult(resp);
+ readDataResultNodeToObject(resp.getJsonResponse(), info);
+
+ ObjectNode dataGetList = JsonNodeFactory.instance.objectNode();
+ dataGetList.putArray("dataGetList").add("airState.filterMngStates.useTime")
+ .add("airState.filterMngStates.maxTime");
+ resp = sendCommand(bridgeName, deviceId, "control-sync", "filterMngStateCtrl", "Get", null, null,
+ dataGetList);
+ handleGenericErrorResult(resp);
+ readDataResultNodeToObject(resp.getJsonResponse(), info);
+
+ return info;
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending command to LG API: " + e.getMessage(), e);
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiClientService.java
new file mode 100644
index 00000000000..dab0cecd97b
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiClientService.java
@@ -0,0 +1,525 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.internal.LGThinQBindingConstants.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.Instant;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.internal.LGThinQBindingConstants;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.api.RestUtils;
+import org.openhab.binding.lgthinq.lgservices.api.TokenManager;
+import org.openhab.binding.lgthinq.lgservices.api.TokenResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqAccessException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqDeviceV1MonitorExpiredException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqDeviceV1OfflineException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqUnmarshallException;
+import org.openhab.binding.lgthinq.lgservices.model.AbstractSnapshotDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityFactory;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.DeviceTypes;
+import org.openhab.binding.lgthinq.lgservices.model.LGDevice;
+import org.openhab.binding.lgthinq.lgservices.model.MonitoringResultFormat;
+import org.openhab.binding.lgthinq.lgservices.model.ResultCodes;
+import org.openhab.binding.lgthinq.lgservices.model.SnapshotBuilderFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * The {@link LGThinQAbstractApiClientService} - base class for all LG API client service. It's provide commons methods
+ * to communicate to the LG Cloud and exchange basic data.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+@SuppressWarnings("unchecked")
+public abstract class LGThinQAbstractApiClientService
+ implements LGThinQApiClientService {
+ protected final ObjectMapper objectMapper = new ObjectMapper();
+ protected final TokenManager tokenManager;
+ protected final Class capabilityClass;
+ protected final Class snapshotClass;
+ protected final HttpClient httpClient;
+ private final Logger logger = LoggerFactory.getLogger(LGThinQAbstractApiClientService.class);
+ private final String clientId = "";
+
+ protected LGThinQAbstractApiClientService(Class capabilityClass, Class snapshotClass, HttpClient httpClient) {
+ this.httpClient = httpClient;
+ this.tokenManager = new TokenManager(httpClient);
+ this.capabilityClass = capabilityClass;
+ this.snapshotClass = snapshotClass;
+ }
+
+ protected static String getErrorCodeMessage(@Nullable String code) {
+ if (code == null) {
+ return "";
+ }
+ ResultCodes resultCode = ResultCodes.fromCode(code);
+ return resultCode.getDescription();
+ }
+
+ /**
+ * Retrieves the client ID based on the provided user number.
+ *
+ * @param userNumber the user number to generate the client ID
+ * @return the generated client ID
+ */
+ private String getClientId(String userNumber) {
+ if (!clientId.isEmpty()) {
+ return clientId;
+ }
+ try {
+ MessageDigest digest = MessageDigest.getInstance("SHA-256");
+ String data = userNumber + Instant.now().toString();
+ byte[] hash = digest.digest(data.getBytes(StandardCharsets.UTF_8));
+ return bytesToHex(hash);
+ } catch (NoSuchAlgorithmException e) {
+ throw new IllegalArgumentException("SHA-256 algorithm not found", e);
+ }
+ }
+
+ private String bytesToHex(byte[] bytes) {
+ StringBuilder hexString = new StringBuilder();
+ for (byte b : bytes) {
+ hexString.append(String.format("%02x", b));
+ }
+ return hexString.toString();
+ }
+
+ Map getCommonHeaders(String language, String country, String accessToken, String userNumber) {
+ Map headers = new HashMap<>();
+ headers.put("Accept", "application/json");
+ headers.put("Content-type", "application/json;charset=UTF-8");
+ headers.put("x-api-key", LG_API_V2_API_KEY);
+ headers.put("x-app-version", "LG ThinQ/5.0.28271");
+ headers.put("x-client-id", getClientId(userNumber));
+ headers.put("x-country-code", country);
+ headers.put("x-language-code", language);
+ headers.put("x-message-id", UUID.randomUUID().toString());
+ headers.put("x-service-code", LG_API_SVC_CODE);
+ headers.put("x-service-phase", LG_API_V2_SVC_PHASE);
+ headers.put("x-thinq-app-level", LG_API_V2_APP_LEVEL);
+ headers.put("x-thinq-app-os", LG_API_V2_APP_OS);
+ headers.put("x-thinq-app-type", LG_API_V2_APP_TYPE);
+ headers.put("x-thinq-app-ver", LG_API_V2_APP_VER);
+ headers.put("x-thinq-app-logintype", "LGE");
+ headers.put("x-origin", "app-native");
+ headers.put("x-device-type", "601");
+
+ if (!accessToken.isBlank()) {
+ headers.put("x-emp-token", accessToken);
+ }
+ if (!userNumber.isBlank()) {
+ headers.put("x-user-no", userNumber);
+ }
+ return headers;
+ }
+
+ /**
+ * Even using V2 URL, this endpoint support grab information about account devices from V1 and V2.
+ *
+ * @return list os LG Devices.
+ * @throws LGThinqApiException if some communication error occur.
+ */
+ @Override
+ public List listAccountDevices(String bridgeName) throws LGThinqApiException {
+ try {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV2()).path(LG_API_V2_LS_PATH);
+ Map headers = getCommonHeaders(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ RestResult resp = RestUtils.getCall(httpClient, builder.build().toURL().toString(), headers, null);
+ return handleListAccountDevicesResult(resp);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error listing account devices from LG Server API", e);
+ }
+ }
+
+ @Override
+ public File loadDeviceCapability(String deviceId, String uri, boolean forceRecreate) throws LGThinqApiException {
+ File regFile = new File(String.format(getBaseCapConfigDataFile(), deviceId));
+ try {
+ if (!regFile.isFile() || forceRecreate) {
+ try (InputStream in = new URI(uri).toURL().openStream()) {
+ Files.copy(in, regFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+ }
+ }
+ } catch (IOException | URISyntaxException e) {
+ throw new LGThinqApiException("Error reading IO interface", e);
+ }
+ return regFile;
+ }
+
+ /**
+ * Get device settings and snapshot for a specific device.
+ * It works only for API V2 device versions!
+ *
+ * @param deviceId device ID for de desired V2 LG Thinq.
+ * @return return map containing metamodel of settings and snapshot
+ * @throws LGThinqApiException if some communication error occur.
+ */
+ @Override
+ public Map getDeviceSettings(String bridgeName, String deviceId) throws LGThinqApiException {
+ try {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV2())
+ .path(String.format("%s/%s", LG_API_V2_DEVICE_CONFIG_PATH, deviceId));
+ Map headers = getCommonHeaders(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ RestResult resp = RestUtils.getCall(httpClient, builder.build().toURL().toString(), headers, null);
+ return handleDeviceSettingsResult(resp);
+ } catch (LGThinqException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Errors list account devices from LG Server API", e);
+ }
+ }
+
+ private Map handleDeviceSettingsResult(RestResult resp) throws LGThinqApiException {
+ return genericHandleDeviceSettingsResult(resp, objectMapper);
+ }
+
+ /**
+ * Handles the result of device settings retrieved from an API call.
+ *
+ * @param resp The RestResult object containing the API response
+ * @param objectMapper The ObjectMapper to convert JSON to Java objects
+ * @return A Map containing the device settings
+ * @throws LGThinqApiException If an error occurs during handling the device settings result
+ */
+ protected Map genericHandleDeviceSettingsResult(RestResult resp, ObjectMapper objectMapper)
+ throws LGThinqApiException {
+ Map deviceSettings;
+ Map respMap;
+ String resultCode;
+ if (resp.getStatusCode() != 200) {
+ if (resp.getStatusCode() == 400) {
+ logger.warn("Error calling device settings from LG Server API. HTTP Status: {}. The reason is: {}",
+ resp.getStatusCode(), ResultCodes.getReasonResponse(resp.getJsonResponse()));
+ throw new LGThinqAccessException(String.format(
+ "Error calling device settings from LG Server API. HTTP Status: %d. The reason is: %s",
+ resp.getStatusCode(), ResultCodes.getReasonResponse(resp.getJsonResponse())));
+ }
+ try {
+ respMap = objectMapper.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ resultCode = respMap.get("resultCode");
+ if (resultCode != null) {
+ throw new LGThinqApiException(String.format(
+ "Error calling device settings from LG Server API. The code is: %s and The reason is: %s",
+ resultCode, ResultCodes.fromCode(resultCode)));
+ }
+ } catch (JsonProcessingException e) {
+ // This exception doesn't matter, it's because response is not in json format. Logging raw response.
+ logger.trace(
+ "Error calling device settings from LG Server API. Response is not in json format. Ignoring...",
+ e);
+ }
+ throw new LGThinqApiException(String.format(
+ "Error calling device settings from LG Server API. The reason is:%s", resp.getJsonResponse()));
+ } else {
+ try {
+ deviceSettings = objectMapper.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ String code = Objects.requireNonNullElse((String) deviceSettings.get("resultCode"), "");
+ if (!ResultCodes.OK.containsResultCode(code)) {
+ throw new LGThinqApiException(String.format(
+ "LG API report error processing the request -> resultCode=[{%s], message=[%s]", code,
+ getErrorCodeMessage(code)));
+ }
+ } catch (JsonProcessingException e) {
+ throw new IllegalStateException("Unknown error occurred deserializing json stream", e);
+ }
+ }
+ return Objects.requireNonNull((Map) deviceSettings.get("result"),
+ "Unexpected json result asking for Device Settings. Node 'result' no present");
+ }
+
+ private List handleListAccountDevicesResult(RestResult resp) throws LGThinqApiException {
+ Map devicesResult;
+ List devices;
+ if (resp.getStatusCode() != 200) {
+ if (resp.getStatusCode() == 400) {
+ logger.warn("Error calling device list from LG Server API. HTTP Status: {}. The reason is: {}",
+ resp.getStatusCode(), ResultCodes.getReasonResponse(resp.getJsonResponse()));
+ return Collections.emptyList();
+ }
+ throw new LGThinqApiException(
+ String.format("Error calling device list from LG Server API. HTTP Status: %s. The reason is: %s",
+ resp.getStatusCode(), ResultCodes.getReasonResponse(resp.getJsonResponse())));
+ } else {
+ try {
+ devicesResult = objectMapper.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ String code = Objects.requireNonNullElse((String) devicesResult.get("resultCode"), "");
+ if (!ResultCodes.OK.containsResultCode(code)) {
+ throw new LGThinqApiException(
+ String.format("LG API report error processing the request -> resultCode=[%s], message=[%s]",
+ code, getErrorCodeMessage(code)));
+ }
+ List> items = (List>) ((Map) Objects
+ .requireNonNull(devicesResult.get("result"), "Not expected null here")).get("item");
+ devices = objectMapper.convertValue(items, new TypeReference<>() {
+ });
+ } catch (JsonProcessingException e) {
+ throw new IllegalStateException("Unknown error occurred deserializing json stream.", e);
+ }
+ }
+
+ return devices;
+ }
+
+ /**
+ * Get capability em registry/cache on file for next consult
+ *
+ * @param deviceId ID of the device
+ * @param uri URI of the config capability
+ * @return return simplified capability
+ * @throws LGThinqApiException If some error occurr
+ */
+ public C getCapability(String deviceId, String uri, boolean forceRecreate) throws LGThinqApiException {
+ try {
+ File regFile = loadDeviceCapability(deviceId, uri, forceRecreate);
+ JsonNode rootNode = objectMapper.readTree(regFile);
+ return CapabilityFactory.getInstance().create(rootNode, capabilityClass);
+ } catch (IOException e) {
+ throw new LGThinqApiException("Error reading IO interface", e);
+ } catch (LGThinqException e) {
+ throw new LGThinqApiException("Error parsing capability registry", e);
+ }
+ }
+
+ public S buildDefaultOfflineSnapshot() {
+ try {
+ // As I don't know the current device status, then I reset to default values.
+
+ S shot = snapshotClass.getDeclaredConstructor().newInstance();
+ shot.setPowerStatus(DevicePowerState.DV_POWER_OFF);
+ shot.setOnline(false);
+ return shot;
+ } catch (Exception ex) {
+ throw new IllegalStateException("Unexpected Error. The default constructor of this Snapshot wasn't found",
+ ex);
+ }
+ }
+
+ public @Nullable S getMonitorData(String bridgeName, String deviceId, String workId, DeviceTypes deviceType,
+ C deviceCapability) throws LGThinqApiException, LGThinqDeviceV1MonitorExpiredException, IOException,
+ LGThinqUnmarshallException {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV1()).path(LG_API_V1_MON_DATA_PATH);
+ Map headers = getCommonHeaders(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ String jsonData = String.format("{\n" + " \"lgedmRoot\":{\n" + " \"workList\":[\n" + " {\n"
+ + " \"deviceId\":\"%s\",\n" + " \"workId\":\"%s\"\n" + " }\n"
+ + " ]\n" + " }\n" + "}", deviceId, workId);
+ RestResult resp = RestUtils.postCall(httpClient, builder.build().toURL().toString(), headers, jsonData);
+ Map envelop;
+ // to unify the same behaviour then V2, this method handle Offline Exception and return a dummy shot with
+ // offline flag.
+ try {
+ envelop = handleGenericErrorResult(resp);
+ } catch (LGThinqDeviceV1OfflineException e) {
+ return buildDefaultOfflineSnapshot();
+ }
+ Map workList = objectMapper
+ .convertValue(envelop.getOrDefault("workList", Collections.emptyMap()), new TypeReference<>() {
+ });
+ if (workList.get("returnData") != null) {
+ if (logger.isDebugEnabled()) {
+ try {
+ objectMapper.writeValue(new File(String.format(LGThinQBindingConstants.getThinqUserDataFolder()
+ + File.separator + "thinq-%s-datatrace.json", deviceId)), workList);
+ } catch (IOException e) {
+ // Only debug since datatrace is a trace data.
+ logger.debug("Unexpected error saving data trace", e);
+ }
+ }
+
+ if (!ResultCodes.OK.containsResultCode("" + workList.get("returnCode"))) {
+ String code = Objects.requireNonNullElse((String) workList.get("returnCode"), "");
+ logger.debug("LG API report error processing the request -> resultCode=[{}], message=[{}]", code,
+ getErrorCodeMessage(code));
+ LGThinqDeviceV1MonitorExpiredException e = new LGThinqDeviceV1MonitorExpiredException(
+ String.format("Monitor for device %s has expired. Please, refresh the monitor.", deviceId));
+ logger.warn("{}", e.getMessage());
+ throw e;
+ }
+
+ String monDataB64 = (String) workList.get("returnData");
+ String monData = new String(Base64.getDecoder().decode(monDataB64));
+ S shot;
+ try {
+ if (MonitoringResultFormat.JSON_FORMAT.equals(deviceCapability.getMonitoringDataFormat())) {
+ shot = (S) SnapshotBuilderFactory.getInstance().getBuilder(snapshotClass).createFromJson(monData,
+ deviceType, deviceCapability);
+ } else if (MonitoringResultFormat.BINARY_FORMAT.equals(deviceCapability.getMonitoringDataFormat())) {
+ shot = (S) SnapshotBuilderFactory.getInstance().getBuilder(snapshotClass).createFromBinary(monData,
+ deviceCapability.getMonitoringBinaryProtocol(), deviceCapability);
+ } else {
+ throw new LGThinqApiException(String.format("Returned data format not supported: %s",
+ deviceCapability.getMonitoringDataFormat()));
+ }
+ shot.setOnline("E".equals(workList.get("deviceState")));
+ } catch (LGThinqUnmarshallException ex) {
+ // error in the monitor Data returned. Device is irresponsible
+ logger.debug("Monitored data returned for the device {} is unreadable. Device is not connected",
+ deviceId);
+ throw ex;
+ }
+ return shot;
+ } else {
+ // no data available yet
+ return null;
+ }
+ }
+
+ @Override
+ public void initializeDevice(String bridgeName, String deviceId) throws LGThinqApiException {
+ logger.debug("Initializing device [{}] from bridge [{}]", deviceId, bridgeName);
+ }
+
+ /**
+ * Perform some routine before getting data device. Depending on the kind of the device, this is needed
+ * to update or prepare some informations before go to get the data.
+ *
+ * @return false if the device doesn't support pre-condition commands
+ */
+ protected abstract boolean beforeGetDataDevice(String bridgeName, String deviceId);
+
+ /**
+ * Get snapshot data from the device.
+ * It works only for API V2 device versions!
+ *
+ * @param deviceId device ID for de desired V2 LG Thinq.
+ * @param capDef
+ * @return return map containing metamodel of settings and snapshot
+ * @throws LGThinqApiException if some communication error occur.
+ */
+ @Override
+ @Nullable
+ public S getDeviceData(String bridgeName, String deviceId, CapabilityDefinition capDef) throws LGThinqApiException {
+ // Exec pre-conditions (normally ask for update monitoring sensors of the device - temp and power) before call
+ // for data
+ if (capDef.isBeforeCommandSupported() && !beforeGetDataDevice(bridgeName, deviceId)) {
+ capDef.setBeforeCommandSupported(false);
+ }
+
+ Map deviceSettings = getDeviceSettings(bridgeName, deviceId);
+ if (deviceSettings.get("snapshot") != null) {
+ Map snapMap = (Map) deviceSettings.get("snapshot");
+ if (logger.isDebugEnabled()) {
+ try {
+ objectMapper.writeValue(new File(String.format(LGThinQBindingConstants.getThinqUserDataFolder()
+ + File.separator + "thinq-%s-datatrace.json", deviceId)), deviceSettings);
+ } catch (IOException e) {
+ logger.debug("Error saving data trace", e);
+ }
+ }
+ if (snapMap == null) {
+ // No snapshot value provided
+ return null;
+ }
+ S shot = (S) SnapshotBuilderFactory.getInstance().getBuilder(snapshotClass).createFromJson(deviceSettings,
+ capDef);
+ shot.setOnline((Boolean) snapMap.getOrDefault("online", Boolean.FALSE));
+ return shot;
+ }
+ return null;
+ }
+
+ /**
+ * Start monitor data form specific device. This is old one, works only on V1 API supported devices.
+ *
+ * @param deviceId Device ID
+ * @return Work1 to be uses to grab data during monitoring.
+ * @throws LGThinqApiException If some communication error occur.
+ */
+ @Override
+ public String startMonitor(String bridgeName, String deviceId) throws LGThinqApiException, IOException {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV1()).path(LG_API_V1_START_MON_PATH);
+ Map headers = getCommonHeaders(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ String workerId = UUID.randomUUID().toString();
+ String jsonData = String.format(" { \"lgedmRoot\" : {" + "\"cmd\": \"Mon\"," + "\"cmdOpt\": \"Start\","
+ + "\"deviceId\": \"%s\"," + "\"workId\": \"%s\"" + "} }", deviceId, workerId);
+ RestResult resp = RestUtils.postCall(httpClient, builder.build().toURL().toString(), headers, jsonData);
+ Map respMap = handleGenericErrorResult(resp);
+ if (respMap.isEmpty()) {
+ logger.debug(
+ "Unexpected StartMonitor json null result. Possible causes: 1) you are monitoring the device in LG App at same time, 2) temporary problems in the server. Try again later");
+ }
+ return Objects.requireNonNull((String) handleGenericErrorResult(resp).get("workId"),
+ "Unexpected StartMonitor json result. Node 'workId' not present");
+ }
+
+ @Override
+ public void stopMonitor(String bridgeName, String deviceId, String workId) throws LGThinqApiException, IOException {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV1()).path(LG_API_V1_START_MON_PATH);
+ Map headers = getCommonHeaders(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ String jsonData = String.format(" { \"lgedmRoot\" : {" + "\"cmd\": \"Mon\"," + "\"cmdOpt\": \"Stop\","
+ + "\"deviceId\": \"%s\"," + "\"workId\": \"%s\"" + "} }", deviceId, workId);
+ RestResult resp = RestUtils.postCall(httpClient, builder.build().toURL().toString(), headers, jsonData);
+ handleGenericErrorResult(resp);
+ }
+
+ protected Map getCommonV2Headers(String language, String country, String accessToken,
+ String userNumber) {
+ return getCommonHeaders(language, country, accessToken, userNumber);
+ }
+
+ protected abstract RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, String keyName, String value) throws Exception;
+
+ protected abstract RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, @Nullable String keyName, @Nullable String value, @Nullable ObjectNode extraNode)
+ throws Exception;
+
+ protected abstract Map handleGenericErrorResult(@Nullable RestResult resp)
+ throws LGThinqApiException;
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiV1ClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiV1ClientService.java
new file mode 100644
index 00000000000..13b78598c80
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiV1ClientService.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.LG_API_V1_CONTROL_OP;
+
+import java.util.Base64;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.api.RestUtils;
+import org.openhab.binding.lgthinq.lgservices.api.TokenResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqDeviceV1OfflineException;
+import org.openhab.binding.lgthinq.lgservices.model.AbstractSnapshotDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CommandDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.ResultCodes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * The {@link LGThinQAbstractApiV1ClientService} - Specialized abstract class that implements methods and services to
+ * handle LG API V1 communication and convention.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public abstract class LGThinQAbstractApiV1ClientService
+ extends LGThinQAbstractApiClientService {
+ private final Logger logger = LoggerFactory.getLogger(LGThinQAbstractApiV1ClientService.class);
+
+ protected LGThinQAbstractApiV1ClientService(Class capabilityClass, Class snapshotClass,
+ HttpClient httpClient) {
+ super(capabilityClass, snapshotClass, httpClient);
+ }
+
+ @Override
+ protected RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, String keyName, String value) throws Exception {
+ return sendCommand(bridgeName, deviceId, controlPath, controlKey, command, keyName, value, null);
+ }
+
+ protected RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, Map<@Nullable String, @Nullable Object> keyValue, @Nullable ObjectNode extraNode)
+ throws Exception {
+ ObjectNode payloadNode = JsonNodeFactory.instance.objectNode();
+ payloadNode.put("cmd", controlKey).put("cmdOpt", command);
+ keyValue.forEach((k, v) -> {
+ if (k == null || k.isEmpty()) {
+ // value is a simple text
+ if (v instanceof Integer i) {
+ payloadNode.put("value", i);
+ } else if (v instanceof Double d) {
+ payloadNode.put("value", d);
+ } else {
+ payloadNode.put("value", "" + v);
+ }
+ } else {
+ JsonNode valueNode = payloadNode.path("value");
+ if (valueNode.isMissingNode()) {
+ valueNode = payloadNode.putObject("value");
+ }
+ if (v instanceof Integer i) {
+ ((ObjectNode) valueNode).put(k, i);
+ } else if (v instanceof Double d) {
+ ((ObjectNode) valueNode).put(k, d);
+ } else {
+ ((ObjectNode) valueNode).put(k, "" + v);
+ }
+ }
+ });
+ if (extraNode != null) {
+ payloadNode.setAll(extraNode);
+ }
+ return sendCommand(bridgeName, deviceId, payloadNode);
+ }
+
+ protected RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, @Nullable String keyName, @Nullable String value, @Nullable ObjectNode extraNode)
+ throws Exception {
+ Map<@Nullable String, @Nullable Object> values = new HashMap<>(1);
+ values.put(keyName, value);
+ return sendCommand(bridgeName, deviceId, controlPath, controlKey, command, values, extraNode);
+ }
+
+ protected RestResult sendCommand(String bridgeName, String deviceId, Object cmdPayload) throws Exception {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV1()).path(LG_API_V1_CONTROL_OP);
+ Map headers = getCommonHeaders(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ ObjectNode payloadNode;
+ if (cmdPayload instanceof ObjectNode oNode) {
+ payloadNode = oNode.deepCopy();
+ } else {
+ payloadNode = objectMapper.convertValue(cmdPayload, new TypeReference<>() {
+ });
+ }
+ ObjectNode rootNode = JsonNodeFactory.instance.objectNode();
+ ObjectNode bodyNode = JsonNodeFactory.instance.objectNode();
+ bodyNode.put("deviceId", deviceId);
+ bodyNode.put("workId", UUID.randomUUID().toString());
+ bodyNode.setAll(payloadNode);
+ rootNode.set("lgedmRoot", bodyNode);
+ String url = builder.build().toURL().toString();
+ logger.debug("URL: {}, Post Payload:[{}]", url, rootNode.toPrettyString());
+ RestResult resp = RestUtils.postCall(httpClient, url, headers, rootNode.toPrettyString());
+ if (resp == null) {
+ logger.warn("Null result returned sending command to LG API V1");
+ throw new LGThinqApiException("Null result returned sending command to LG API V1");
+ }
+ return resp;
+ }
+
+ @Override
+ protected Map handleGenericErrorResult(@Nullable RestResult resp) throws LGThinqApiException {
+ Map metaResult;
+ Map envelope = Collections.emptyMap();
+ if (resp == null) {
+ return envelope;
+ }
+ if (resp.getStatusCode() != 200) {
+ if (resp.getStatusCode() == 400) {
+ logger.warn("Error returned by LG Server API. HTTP Status: {}. The reason is: {}", resp.getStatusCode(),
+ resp.getJsonResponse());
+ } else {
+ throw new LGThinqApiException(
+ String.format("Error returned by LG Server API. HTTP Status: %s. The reason is: %s",
+ resp.getStatusCode(), resp.getJsonResponse()));
+ }
+ } else {
+ try {
+ metaResult = objectMapper.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ envelope = objectMapper.convertValue(metaResult.get("lgedmRoot"), new TypeReference<>() {
+ });
+ String code = String.valueOf(envelope.get("returnCd"));
+ if (envelope.isEmpty()) {
+ throw new LGThinqApiException(String.format(
+ "Unexpected json body returned (without root node lgedmRoot): %s", resp.getJsonResponse()));
+ } else if (!ResultCodes.OK.containsResultCode(code)) {
+ if (ResultCodes.DEVICE_NOT_RESPONSE.containsResultCode("" + envelope.get("returnCd"))
+ || "D".equals(envelope.get("deviceState"))) {
+ logger.debug("LG API report error processing the request -> resultCode=[{}], message=[{}]",
+ code, getErrorCodeMessage(code));
+ // Disconnected Device
+ throw new LGThinqDeviceV1OfflineException("Device is offline. No data available");
+ }
+ throw new LGThinqApiException(String
+ .format("Status error executing endpoint. resultCode must be 0000, but was:%s", code));
+ }
+ } catch (JsonProcessingException e) {
+ throw new IllegalStateException("Unknown error occurred deserializing json stream", e);
+ }
+ }
+ return envelope;
+ }
+
+ /**
+ * Principal method to prepare the command to be sent to V1 Devices mainly when the command is generic,
+ * i.e, you can send a command structure to redefine any changeable feature of the device
+ *
+ * @param cmdDef command definition with template of the payload and data (binary or not)
+ * @param snapData snapshot data with features to be set in the device
+ * @return return the command structure.
+ * @throws JsonProcessingException unmarshall error.
+ */
+ protected Map prepareCommandV1(CommandDefinition cmdDef, Map snapData)
+ throws JsonProcessingException {
+ // expected map ordered here
+ String dataStr = cmdDef.getDataTemplate();
+ // Keep the order
+ for (Map.Entry e : snapData.entrySet()) {
+ String value = String.valueOf(e.getValue());
+ dataStr = dataStr.replace("{{" + e.getKey() + "}}", value);
+ }
+
+ return completeCommandDataNodeV1(cmdDef, dataStr);
+ }
+
+ protected LinkedHashMap completeCommandDataNodeV1(CommandDefinition cmdDef, String dataStr)
+ throws JsonProcessingException {
+ LinkedHashMap data = objectMapper.readValue(cmdDef.getRawCommand(), new TypeReference<>() {
+ });
+ logger.debug("Prepare command v1: {}", dataStr);
+ if (cmdDef.isBinary()) {
+ data.put("format", "B64");
+ List list = objectMapper.readValue(dataStr, new TypeReference<>() {
+ });
+ // convert the list of integer to a bytearray
+
+ byte[] byteArray = new byte[list.size()];
+ for (int i = 0; i < list.size(); i++) {
+ byteArray[i] = list.get(i).byteValue(); // Converte Integer para byte
+ }
+ data.put("data", new String(Base64.getEncoder().encode(byteArray)));
+ } else {
+ data.put("data", dataStr);
+ }
+ return data;
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiV2ClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiV2ClientService.java
new file mode 100644
index 00000000000..19891513bac
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQAbstractApiV2ClientService.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.LG_API_V2_CTRL_DEVICE_CONFIG_PATH;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.api.RestUtils;
+import org.openhab.binding.lgthinq.lgservices.api.TokenResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.AbstractSnapshotDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.ResultCodes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * The {@link LGThinQAbstractApiV2ClientService} - Specialized abstract class that implements methods and services to
+ * * handle LG API V2 communication and convention.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public abstract class LGThinQAbstractApiV2ClientService
+ extends LGThinQAbstractApiClientService {
+ private final Logger logger = LoggerFactory.getLogger(LGThinQAbstractApiV2ClientService.class);
+
+ protected LGThinQAbstractApiV2ClientService(Class capabilityClass, Class snapshotClass,
+ HttpClient httpClient) {
+ super(capabilityClass, snapshotClass, httpClient);
+ }
+
+ @Override
+ protected RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, String keyName, String value) throws Exception {
+ return sendCommand(bridgeName, deviceId, controlPath, controlKey, command, keyName, value, null);
+ }
+
+ protected RestResult postCall(String bridgeName, String deviceId, String controlPath, String payload)
+ throws LGThinqApiException, IOException {
+ TokenResult token = tokenManager.getValidRegisteredToken(bridgeName);
+ UriBuilder builder = UriBuilder.fromUri(token.getGatewayInfo().getApiRootV2())
+ .path(String.format(LG_API_V2_CTRL_DEVICE_CONFIG_PATH, deviceId, controlPath));
+ Map headers = getCommonV2Headers(token.getGatewayInfo().getLanguage(),
+ token.getGatewayInfo().getCountry(), token.getAccessToken(), token.getUserInfo().getUserNumber());
+ RestResult resp = RestUtils.postCall(httpClient, builder.build().toURL().toString(), headers, payload);
+ if (resp == null) {
+ logger.warn("Null result returned sending command to LG API V2: {}, {}, {}", deviceId, controlPath,
+ payload);
+ throw new LGThinqApiException("Null result returned sending command to LG API V2");
+ }
+ return resp;
+ }
+
+ @Override
+ public RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, @Nullable String keyName, @Nullable String value, @Nullable ObjectNode extraNode)
+ throws Exception {
+ ObjectNode payload = JsonNodeFactory.instance.objectNode();
+ payload.put("ctrlKey", controlKey).put("command", command).put("dataKey", keyName).put("dataValue", value);
+ if (extraNode != null) {
+ payload.setAll(extraNode);
+ }
+ return postCall(bridgeName, deviceId, controlPath, payload.toPrettyString());
+ }
+
+ protected RestResult sendBasicControlCommands(String bridgeName, String deviceId, String command, String keyName,
+ int value) throws Exception {
+ return sendCommand(bridgeName, deviceId, "control-sync", "basicCtrl", command, keyName, String.valueOf(value));
+ }
+
+ @Override
+ protected Map handleGenericErrorResult(@Nullable RestResult resp) throws LGThinqApiException {
+ Map metaResult;
+ if (resp == null) {
+ return Collections.emptyMap();
+ }
+ if (resp.getStatusCode() != 200) {
+ if (resp.getStatusCode() == 400) {
+ if (logger.isDebugEnabled()) {
+ logger.warn("Error returned by LG Server API. HTTP Status: {}. The reason is: {}\n {}",
+ resp.getStatusCode(), resp.getJsonResponse(), Thread.currentThread().getStackTrace());
+ } else {
+ logger.warn("Error returned by LG Server API. HTTP Status: {}. The reason is: {}",
+ resp.getStatusCode(), resp.getJsonResponse());
+ }
+ return Collections.emptyMap();
+ } else {
+ throw new LGThinqApiException(
+ String.format("Error returned by LG Server API. HTTP Status: %s. The reason is: %s",
+ resp.getStatusCode(), resp.getJsonResponse()));
+ }
+ } else {
+ try {
+ metaResult = objectMapper.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ String code = (String) metaResult.get("resultCode");
+ if (!ResultCodes.OK.containsResultCode(String.valueOf(metaResult.get("resultCode")))) {
+ throw new LGThinqApiException(
+ String.format("LG API report error processing the request -> resultCode=[%s], message=[%s]",
+ code, getErrorCodeMessage(code)));
+ }
+ return metaResult;
+ } catch (JsonProcessingException e) {
+ throw new IllegalStateException("Unknown error occurred deserializing json stream", e);
+ }
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQApiClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQApiClientService.java
new file mode 100644
index 00000000000..2ca398ff205
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQApiClientService.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqDeviceV1MonitorExpiredException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqUnmarshallException;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.DeviceTypes;
+import org.openhab.binding.lgthinq.lgservices.model.LGDevice;
+import org.openhab.binding.lgthinq.lgservices.model.SnapshotDefinition;
+
+/**
+ * The {@link LGThinQApiClientService} interface defines the core methods for managing LG ThinQ devices
+ * via the LG Cloud API. It provides functionalities for retrieving device metadata, controlling power states,
+ * monitoring device status, and handling device capabilities.
+ *
+ * @param The type representing the capability definition for a device.
+ * @param The type representing a snapshot definition of device data.
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public interface LGThinQApiClientService {
+
+ /**
+ * Retrieves a list of all devices registered under the LG account.
+ *
+ * @param bridgeName The name of the bridge managing the devices.
+ * @return A list of {@link LGDevice} representing the registered devices.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ List listAccountDevices(String bridgeName) throws LGThinqApiException;
+
+ /**
+ * Retrieves device metadata, including settings and capabilities.
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @return A map containing device settings and metadata.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ Map getDeviceSettings(String bridgeName, String deviceId) throws LGThinqApiException;
+
+ /**
+ * Initializes a device, preparing it for interaction.
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ void initializeDevice(String bridgeName, String deviceId) throws LGThinqApiException;
+
+ /**
+ * Retrieves the latest data snapshot from the device, including sensor readings and state values.
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @param capDef The capability definition of the device.
+ * @return A snapshot containing the device's current data.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ @Nullable
+ S getDeviceData(String bridgeName, String deviceId, CapabilityDefinition capDef) throws LGThinqApiException;
+
+ /**
+ * Toggles the power state of the device (on/off).
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @param newPowerState The desired power state.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) throws LGThinqApiException;
+
+ /**
+ * Starts a monitoring session for data collection (only applicable for protocol V1).
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @return The monitor session ID.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ * @throws IOException If an error occurs while handling device configuration files.
+ */
+ String startMonitor(String bridgeName, String deviceId) throws LGThinqApiException, IOException;
+
+ /**
+ * Retrieves the capability definition of the device.
+ *
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @param uri The URI containing the XML descriptor of the device.
+ * @param forceRecreate Whether to force recreation of the cached capability file.
+ * @return The capability definition of the device.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ C getCapability(String deviceId, String uri, boolean forceRecreate) throws LGThinqApiException;
+
+ /**
+ * Builds a default snapshot to maintain data integrity when the device is offline.
+ *
+ * @return A default snapshot representing offline device data.
+ */
+ S buildDefaultOfflineSnapshot();
+
+ /**
+ * Loads device capabilities from a cached file or retrieves them from the API if necessary.
+ *
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @param uri The URI used to retrieve capability data if the file is missing.
+ * @param forceRecreate Whether to force recreation of the cached file.
+ * @return A file containing the device capability data.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ */
+ File loadDeviceCapability(String deviceId, String uri, boolean forceRecreate) throws LGThinqApiException;
+
+ /**
+ * Stops a previously started monitoring session.
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @param workId The monitor session ID.
+ * @throws LGThinqException If an error occurs while stopping the monitor.
+ * @throws IOException If an error occurs while handling device configuration files.
+ */
+ void stopMonitor(String bridgeName, String deviceId, String workId) throws LGThinqException, IOException;
+
+ /**
+ * Retrieves data collected from an active monitoring session.
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param deviceId The unique ID of the LG ThinQ device.
+ * @param workerId The monitoring session ID.
+ * @param deviceType The type of device being monitored.
+ * @param deviceCapability The capability definition of the device.
+ * @return A snapshot containing the collected data.
+ * @throws LGThinqApiException If an error occurs while accessing the LG API.
+ * @throws LGThinqDeviceV1MonitorExpiredException If the monitoring session has expired.
+ * @throws IOException If an error occurs while accessing cached token files.
+ * @throws LGThinqUnmarshallException If an error occurs while parsing collected data.
+ */
+ @Nullable
+ S getMonitorData(String bridgeName, String deviceId, String workerId, DeviceTypes deviceType, C deviceCapability)
+ throws LGThinqApiException, LGThinqDeviceV1MonitorExpiredException, IOException, LGThinqUnmarshallException;
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQApiClientServiceFactory.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQApiClientServiceFactory.java
new file mode 100644
index 00000000000..d81cbe03bc1
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQApiClientServiceFactory.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.LG_API_PLATFORM_TYPE_V1;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.model.AbstractCapability;
+import org.openhab.binding.lgthinq.lgservices.model.AbstractSnapshotDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.core.io.net.http.HttpClientFactory;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Creates specialized API clients.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQApiClientServiceFactory {
+
+ public static LGThinQGeneralApiClientService newGeneralApiClientService(HttpClientFactory httpClientFactory) {
+ return new LGThinQGeneralApiClientService(httpClientFactory.getCommonHttpClient());
+ }
+
+ public static LGThinQACApiClientService newACApiClientService(String lgPlatformType,
+ HttpClientFactory httpClientFactory) {
+ return lgPlatformType.equals(LG_API_PLATFORM_TYPE_V1)
+ ? new LGThinQACApiV1ClientServiceImpl(httpClientFactory.getCommonHttpClient())
+ : new LGThinQACApiV2ClientServiceImpl(httpClientFactory.getCommonHttpClient());
+ }
+
+ public static LGThinQFridgeApiClientService newFridgeApiClientService(String lgPlatformType,
+ HttpClientFactory httpClientFactory) {
+ return lgPlatformType.equals(LG_API_PLATFORM_TYPE_V1)
+ ? new LGThinQFridgeApiV1ClientServiceImpl(httpClientFactory.getCommonHttpClient())
+ : new LGThinQFridgeApiV2ClientServiceImpl(httpClientFactory.getCommonHttpClient());
+ }
+
+ public static LGThinQWMApiClientService newWMApiClientService(String lgPlatformType,
+ HttpClientFactory httpClientFactory) {
+ return lgPlatformType.equals(LG_API_PLATFORM_TYPE_V1)
+ ? new LGThinQWMApiV1ClientServiceImpl(httpClientFactory.getCommonHttpClient())
+ : new LGThinQWMApiV2ClientServiceImpl(httpClientFactory.getCommonHttpClient());
+ }
+
+ public static LGThinQDishWasherApiClientService newDishWasherApiClientService(String lgPlatformType,
+ HttpClientFactory httpClientFactory) {
+ return lgPlatformType.equals(LG_API_PLATFORM_TYPE_V1)
+ ? new LGThinQDishWasherApiV1ClientServiceImpl(httpClientFactory.getCommonHttpClient())
+ : new LGThinQDishWasherApiV2ClientServiceImpl(httpClientFactory.getCommonHttpClient());
+ }
+
+ public static final class LGThinQGeneralApiClientService
+ extends LGThinQAbstractApiClientService {
+
+ private LGThinQGeneralApiClientService(HttpClient httpClient) {
+ super(GenericCapability.class, AbstractSnapshotDefinition.class, httpClient);
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ protected RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, String keyName, String value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ protected RestResult sendCommand(String bridgeName, String deviceId, String controlPath, String controlKey,
+ String command, @Nullable String keyName, @Nullable String value, @Nullable ObjectNode extraNode) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ protected Map handleGenericErrorResult(@Nullable RestResult resp) {
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ private static final class GenericCapability extends AbstractCapability {
+
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiClientService.java
new file mode 100644
index 00000000000..9bdc38eb002
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiClientService.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.lgthinq.lgservices.model.devices.dishwasher.DishWasherCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.dishwasher.DishWasherSnapshot;
+
+/**
+ * {@link LGThinQDishWasherApiClientService} provides specific methods for interacting with LG ThinQ dishwashers.
+ * It extends the {@link LGThinQApiClientService} to inherit core functionalities while adding specialized methods
+ * for dishwashers.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public interface LGThinQDishWasherApiClientService
+ extends LGThinQApiClientService {
+
+ /**
+ * Initiates a remote start operation for the dishwasher.
+ *
+ * @param bridgeName The name of the bridge managing the device.
+ * @param cap The capability definition of the dishwasher.
+ * @param deviceId The unique identifier of the LG ThinQ dishwasher.
+ * @param data A map containing the required parameters for remote start.
+ */
+ void remoteStart(String bridgeName, DishWasherCapability cap, String deviceId, Map data);
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiV1ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiV1ClientServiceImpl.java
new file mode 100644
index 00000000000..b41ba0879a3
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiV1ClientServiceImpl.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.dishwasher.DishWasherCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.dishwasher.DishWasherSnapshot;
+
+/**
+ * The {@link LGThinQDishWasherApiV1ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQDishWasherApiV1ClientServiceImpl
+ extends LGThinQAbstractApiV1ClientService
+ implements LGThinQDishWasherApiClientService {
+
+ protected LGThinQDishWasherApiV1ClientServiceImpl(HttpClient httpClient) {
+ super(DishWasherCapability.class, DishWasherSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ // there's no before settings to send command
+ return false;
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException("Not Supported for this device");
+ }
+
+ @Override
+ @Nullable
+ public DishWasherSnapshot getDeviceData(String bridgeName, String deviceId, CapabilityDefinition capDef) {
+ throw new UnsupportedOperationException("Method not supported in V1 API device.");
+ }
+
+ @Override
+ public void remoteStart(String bridgeName, DishWasherCapability cap, String deviceId, Map data) {
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiV2ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiV2ClientServiceImpl.java
new file mode 100644
index 00000000000..bad3ff26d84
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQDishWasherApiV2ClientServiceImpl.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.dishwasher.DishWasherCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.dishwasher.DishWasherSnapshot;
+
+/**
+ * The {@link LGThinQDishWasherApiV2ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQDishWasherApiV2ClientServiceImpl
+ extends LGThinQAbstractApiV2ClientService
+ implements LGThinQDishWasherApiClientService {
+
+ protected LGThinQDishWasherApiV2ClientServiceImpl(HttpClient httpClient) {
+ super(DishWasherCapability.class, DishWasherSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ // there's no before settings to send command
+ return false;
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException("Unsupported for this device");
+ }
+
+ @Override
+ public void remoteStart(String bridgeName, DishWasherCapability cap, String deviceId, Map data) {
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiClientService.java
new file mode 100644
index 00000000000..af5732f3d8d
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiClientService.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.devices.fridge.FridgeCanonicalSnapshot;
+import org.openhab.binding.lgthinq.lgservices.model.devices.fridge.FridgeCapability;
+
+/**
+ * {@link LGThinQFridgeApiClientService} defines methods for interacting with LG ThinQ refrigerator devices.
+ * It extends {@link LGThinQApiClientService} to provide core functionalities while adding refrigerator-specific
+ * operations.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public interface LGThinQFridgeApiClientService
+ extends LGThinQApiClientService {
+
+ /**
+ * Sets the refrigerator temperature.
+ *
+ * @param bridgeId The bridge ID managing the device.
+ * @param deviceId The unique identifier of the LG refrigerator.
+ * @param fridgeCapability The capabilities definition of the refrigerator.
+ * @param targetTemperatureIndex The desired temperature index.
+ * @param tempUnit The unit of temperature measurement.
+ * @param snapCmdData Optional snapshot template for the temperature command.
+ * @throws LGThinqApiException If an error occurs while communicating with the LG API.
+ */
+ void setFridgeTemperature(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ Integer targetTemperatureIndex, String tempUnit, @Nullable Map snapCmdData)
+ throws LGThinqApiException;
+
+ /**
+ * Sets the freezer temperature.
+ *
+ * @param bridgeId The bridge ID managing the device.
+ * @param deviceId The unique identifier of the LG freezer.
+ * @param fridgeCapability The capabilities definition of the freezer.
+ * @param targetTemperatureIndex The desired temperature index.
+ * @param tempUnit The unit of temperature measurement.
+ * @param snapCmdData Optional snapshot template for the temperature command.
+ * @throws LGThinqApiException If an error occurs while communicating with the LG API.
+ */
+ void setFreezerTemperature(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ Integer targetTemperatureIndex, String tempUnit, @Nullable Map snapCmdData)
+ throws LGThinqApiException;
+
+ /**
+ * Activates or deactivates the Express Mode.
+ *
+ * @param bridgeId The bridge ID managing the device.
+ * @param deviceId The unique identifier of the LG refrigerator.
+ * @param expressModeIndex The desired express mode setting.
+ * @throws LGThinqApiException If an error occurs while communicating with the LG API.
+ */
+ void setExpressMode(String bridgeId, String deviceId, String expressModeIndex) throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Express Cool Mode.
+ *
+ * @param bridgeId The bridge ID managing the device.
+ * @param deviceId The unique identifier of the LG refrigerator.
+ * @param enable {@code true} to enable Express Cool Mode, {@code false} to disable.
+ * @throws LGThinqApiException If an error occurs while communicating with the LG API.
+ */
+ void setExpressCoolMode(String bridgeId, String deviceId, boolean enable) throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Eco-Friendly Mode.
+ *
+ * @param bridgeId The bridge ID managing the device.
+ * @param deviceId The unique identifier of the LG refrigerator.
+ * @param enable {@code true} to enable Eco Mode, {@code false} to disable.
+ * @throws LGThinqApiException If an error occurs while communicating with the LG API.
+ */
+ void setEcoFriendlyMode(String bridgeId, String deviceId, boolean enable) throws LGThinqApiException;
+
+ /**
+ * Enables or disables the Ice Plus feature.
+ *
+ * @param bridgeId The bridge ID managing the device.
+ * @param deviceId The unique identifier of the LG refrigerator.
+ * @param fridgeCapability The capabilities definition of the refrigerator.
+ * @param enable {@code true} to enable Ice Plus, {@code false} to disable.
+ * @param snapCmdData A map containing the snapshot template for the Ice Plus command.
+ * @throws LGThinqApiException If an error occurs while communicating with the LG API.
+ */
+ void setIcePlus(String bridgeId, String deviceId, FridgeCapability fridgeCapability, boolean enable,
+ Map snapCmdData) throws LGThinqApiException;
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiV1ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiV1ClientServiceImpl.java
new file mode 100644
index 00000000000..8f3df31eab4
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiV1ClientServiceImpl.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.RE_SET_CONTROL_COMMAND_NAME_V1;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CommandDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.fridge.FridgeCanonicalSnapshot;
+import org.openhab.binding.lgthinq.lgservices.model.devices.fridge.FridgeCapability;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link LGThinQFridgeApiV1ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQFridgeApiV1ClientServiceImpl
+ extends LGThinQAbstractApiV1ClientService
+ implements LGThinQFridgeApiClientService {
+ private final Logger logger = LoggerFactory.getLogger(LGThinQFridgeApiV1ClientServiceImpl.class);
+
+ protected LGThinQFridgeApiV1ClientServiceImpl(HttpClient httpClient) {
+ super(FridgeCapability.class, FridgeCanonicalSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ // there's no before settings to send command
+ return false;
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException("Not implemented yet.");
+ }
+
+ @Override
+ @Nullable
+ public FridgeCanonicalSnapshot getDeviceData(String bridgeName, String deviceId, CapabilityDefinition capDef) {
+ throw new UnsupportedOperationException("Method not supported in V1 API device.");
+ }
+
+ @Override
+ public void setFridgeTemperature(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ Integer targetTemperatureIndex, String tempUnit, @Nullable Map snapCmdData)
+ throws LGThinqApiException {
+ if (snapCmdData != null) {
+ snapCmdData.put("TempRefrigerator", targetTemperatureIndex);
+ setControlCommand(bridgeId, deviceId, fridgeCapability, snapCmdData);
+ } else {
+ logger.warn("Snapshot Command Data is null");
+ }
+ }
+
+ @Override
+ public void setFreezerTemperature(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ Integer targetTemperatureIndex, String tempUnit, @Nullable Map snapCmdData)
+ throws LGThinqApiException {
+ if (snapCmdData != null) {
+ snapCmdData.put("TempFreezer", targetTemperatureIndex);
+ setControlCommand(bridgeId, deviceId, fridgeCapability, snapCmdData);
+ } else {
+ logger.warn("Snapshot command is null");
+ }
+ }
+
+ @Override
+ public void setExpressMode(String bridgeId, String deviceId, String expressModeIndex) {
+ throw new UnsupportedOperationException("V1 Fridge doesn't support ExpressMode feature. It mostly like a bug");
+ }
+
+ @Override
+ public void setExpressCoolMode(String bridgeId, String deviceId, boolean trueOnFalseOff) {
+ throw new UnsupportedOperationException(
+ "V1 Fridge doesn't support ExpressCoolMode feature. It mostly like a bug");
+ }
+
+ @Override
+ public void setEcoFriendlyMode(String bridgeId, String deviceId, boolean trueOnFalseOff) {
+ throw new UnsupportedOperationException(
+ "V1 Fridge doesn't support ExpressCoolMode feature. It mostly like a bug");
+ }
+
+ @Override
+ public void setIcePlus(String bridgeId, String deviceId, FridgeCapability fridgeCapability, boolean trueOnFalseOff,
+ Map snapCmdData) throws LGThinqApiException {
+ snapCmdData.put("IcePlus", trueOnFalseOff ? 1 : 0);
+ setControlCommand(bridgeId, deviceId, fridgeCapability, snapCmdData);
+ }
+
+ private void setControlCommand(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ @Nullable Map snapCmdData) throws LGThinqApiException {
+ try {
+ CommandDefinition cmdSetControlDef = fridgeCapability.getCommandsDefinition()
+ .get(RE_SET_CONTROL_COMMAND_NAME_V1);
+ if (cmdSetControlDef == null) {
+ logger.warn("No command definition found for set control command. Ignoring command");
+ return;
+ }
+ if (snapCmdData == null) {
+ logger.error("Snapshot to complete command was not send. It's mostly like a bug");
+ return;
+ }
+ Map cmdPayload = prepareCommandV1(cmdSetControlDef, snapCmdData);
+ logger.debug("setControl Payload:[{}]", cmdPayload);
+ RestResult result = sendCommand(bridgeId, deviceId, cmdPayload);
+ handleGenericErrorResult(result);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending remote start", e);
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiV2ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiV2ClientServiceImpl.java
new file mode 100644
index 00000000000..b99fbb7b302
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQFridgeApiV2ClientServiceImpl.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.fridge.FridgeCanonicalSnapshot;
+import org.openhab.binding.lgthinq.lgservices.model.devices.fridge.FridgeCapability;
+
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * The {@link LGThinQFridgeApiV2ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQFridgeApiV2ClientServiceImpl
+ extends LGThinQAbstractApiV2ClientService
+ implements LGThinQFridgeApiClientService {
+
+ protected LGThinQFridgeApiV2ClientServiceImpl(HttpClient httpClient) {
+ super(FridgeCapability.class, FridgeCanonicalSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ // there's no before settings to send command
+ return false;
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException("Not implemented yet.");
+ }
+
+ @Override
+ public void setFridgeTemperature(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ Integer targetTemperatureIndex, String tempUnit, @Nullable Map snapCmdData)
+ throws LGThinqApiException {
+ setTemperature("fridgeTemp", bridgeId, deviceId, targetTemperatureIndex, tempUnit);
+ }
+
+ @Override
+ public void setFreezerTemperature(String bridgeId, String deviceId, FridgeCapability fridgeCapability,
+ Integer targetTemperatureIndex, String tempUnit, @Nullable Map snapCmdData)
+ throws LGThinqApiException {
+ setTemperature("freezerTemp", bridgeId, deviceId, targetTemperatureIndex, tempUnit);
+ }
+
+ @Override
+ public void setExpressMode(String bridgeId, String deviceId, String expressMode) throws LGThinqApiException {
+ sendSimpleDataSetListCommand(bridgeId, deviceId, "expressMode", expressMode);
+ }
+
+ private void sendSimpleDataSetListCommand(String bridgeId, String deviceId, String feature, String value)
+ throws LGThinqApiException {
+ ObjectNode dataSetList = JsonNodeFactory.instance.objectNode();
+ ObjectNode nodeData = dataSetList.putObject("dataSetList").putObject("refState");
+ nodeData.put(feature, value);
+ try {
+ RestResult result = sendCommand(bridgeId, deviceId, "control-sync", "basicCtrl", "Set", null, null,
+ dataSetList);
+ handleGenericErrorResult(result);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending command", e);
+ }
+ }
+
+ @Override
+ public void setExpressCoolMode(String bridgeId, String deviceId, boolean trueOnFalseOff)
+ throws LGThinqApiException {
+ sendSimpleDataSetListCommand(bridgeId, deviceId, "expressFridge", trueOnFalseOff ? "ON" : "OFF");
+ }
+
+ @Override
+ public void setEcoFriendlyMode(String bridgeId, String deviceId, boolean trueOnFalseOff)
+ throws LGThinqApiException {
+ sendSimpleDataSetListCommand(bridgeId, deviceId, "ecoFriendly", trueOnFalseOff ? "ON" : "OFF");
+ }
+
+ @Override
+ public void setIcePlus(String bridgeId, String deviceId, FridgeCapability fridgeCapability, boolean trueOnFalseOff,
+ Map snapCmdData) {
+ throw new UnsupportedOperationException("V2 Fridge doesn't support IcePlus feature. It mostly like a bug");
+ }
+
+ private void setTemperature(String tempFeature, String bridgeId, String deviceId, Integer targetTemperature,
+ String tempUnit) throws LGThinqApiException {
+ ObjectNode dataSetList = JsonNodeFactory.instance.objectNode();
+ ObjectNode nodeData = dataSetList.putObject("dataSetList").putObject("refState");
+ nodeData.put(tempFeature, targetTemperature).put("tempUnit", tempUnit);
+ try {
+ RestResult result = sendCommand(bridgeId, deviceId, "control-sync", "basicCtrl", "Set", null, null,
+ dataSetList);
+ handleGenericErrorResult(result);
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending command", e);
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiClientService.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiClientService.java
new file mode 100644
index 00000000000..01e5957f372
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiClientService.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.devices.washerdryer.WasherDryerCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.washerdryer.WasherDryerSnapshot;
+
+/**
+ * Represents an API client service for LG ThinQ Washer/Dryer devices.
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public interface LGThinQWMApiClientService extends LGThinQApiClientService {
+ /**
+ * Start the LG ThinQ Washer/Dryer device remotely using the specified capability and data.
+ *
+ * @param bridgeName The name of the bridge connected to the device
+ * @param cap The WasherDryerCapability object representing the capabilities of the device
+ * @param deviceId The ID of the LG ThinQ device
+ * @param data A Map containing key-value pairs of data to be used for starting the device
+ * @throws LGThinqApiException if an error occurs while trying to start the device remotely
+ */
+ void remoteStart(String bridgeName, WasherDryerCapability cap, String deviceId, Map data)
+ throws LGThinqApiException;
+
+ /**
+ * Controls the wake-up feature of the LG ThinQ Washer/Dryer device.
+ *
+ * @param bridgeName The name of the bridge connected to the device
+ * @param deviceId The ID of the LG device
+ * @param wakeUp Boolean value indicating whether to wake up the device
+ * @throws LGThinqApiException if an error occurs while trying to wake up the device
+ */
+ void wakeUp(String bridgeName, String deviceId, Boolean wakeUp) throws LGThinqApiException;
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiV1ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiV1ClientServiceImpl.java
new file mode 100644
index 00000000000..28c6d1ef5af
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiV1ClientServiceImpl.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.CapabilityDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.CommandDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.washerdryer.WasherDryerCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.washerdryer.WasherDryerSnapshot;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+/**
+ * The {@link LGThinQWMApiV1ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQWMApiV1ClientServiceImpl
+ extends LGThinQAbstractApiV1ClientService
+ implements LGThinQWMApiClientService {
+ private final Logger logger = LoggerFactory.getLogger(LGThinQWMApiV1ClientServiceImpl.class);
+
+ protected LGThinQWMApiV1ClientServiceImpl(HttpClient httpClient) {
+ super(WasherDryerCapability.class, WasherDryerSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ // there's no before settings to send command
+ return false;
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException("Not implemented yet.");
+ }
+
+ @Override
+ @Nullable
+ public WasherDryerSnapshot getDeviceData(String bridgeName, String deviceId, CapabilityDefinition capDef) {
+ throw new UnsupportedOperationException("Method not supported in V1 API device.");
+ }
+
+ @Override
+ public void remoteStart(String bridgeName, WasherDryerCapability cap, String deviceId, Map data)
+ throws LGThinqApiException {
+ try {
+ CommandDefinition cmdStartDef = cap.getCommandsDefinition().get(cap.getCommandRemoteStart());
+ if (cmdStartDef == null) {
+ logger.warn("No command definition found for remote start v1. Ignoring command");
+ return;
+ }
+ Map cmdPayload = prepareCommandV1(cmdStartDef, data);
+ logger.debug("token Payload:[{}]", cmdPayload);
+ RestResult result = sendCommand(bridgeName, deviceId, cmdPayload);
+ handleGenericErrorResult(result);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending remote start", e);
+ }
+ }
+
+ @Override
+ public void wakeUp(String bridgeName, String deviceId, Boolean wakeUp) throws LGThinqApiException {
+ try {
+ RestResult result = sendCommand(bridgeName, deviceId, "", "Control", "Operation", "", "WakeUp");
+ handleGenericErrorResult(result);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending remote start", e);
+ }
+ }
+
+ @Override
+ protected Map prepareCommandV1(CommandDefinition cmdDef, Map snapData)
+ throws JsonProcessingException {
+ // expected map ordered here
+ String dataStr = cmdDef.getDataTemplate();
+ for (Map.Entry e : snapData.entrySet()) {
+ String value = String.valueOf(e.getValue());
+ if ("Start".equals(cmdDef.getCmdOptValue()) && e.getKey().equals("Option2")) {
+ // For some reason, option2 fills only InitialBit with 1.
+ value = "1";
+ }
+ dataStr = dataStr.replace("{{" + e.getKey() + "}}", value);
+ }
+ // Keep the order
+ LinkedHashMap cmd = completeCommandDataNodeV1(cmdDef, dataStr);
+ cmd.remove("encode");
+
+ return cmd;
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiV2ClientServiceImpl.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiV2ClientServiceImpl.java
new file mode 100644
index 00000000000..719c5365d12
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/LGThinQWMApiV2ClientServiceImpl.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.WMD_COMMAND_REMOTE_START_V2;
+
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.RestResult;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqApiException;
+import org.openhab.binding.lgthinq.lgservices.model.CommandDefinition;
+import org.openhab.binding.lgthinq.lgservices.model.DevicePowerState;
+import org.openhab.binding.lgthinq.lgservices.model.devices.washerdryer.WasherDryerCapability;
+import org.openhab.binding.lgthinq.lgservices.model.devices.washerdryer.WasherDryerSnapshot;
+
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * The {@link LGThinQWMApiV2ClientServiceImpl}
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinQWMApiV2ClientServiceImpl
+ extends LGThinQAbstractApiV2ClientService
+ implements LGThinQWMApiClientService {
+
+ protected LGThinQWMApiV2ClientServiceImpl(HttpClient httpClient) {
+ super(WasherDryerCapability.class, WasherDryerSnapshot.class, httpClient);
+ }
+
+ @Override
+ protected boolean beforeGetDataDevice(String bridgeName, String deviceId) {
+ return false;
+ }
+
+ @Override
+ public void turnDevicePower(String bridgeName, String deviceId, DevicePowerState newPowerState) {
+ throw new UnsupportedOperationException("Not implemented yet.");
+ }
+
+ @Override
+ public void remoteStart(String bridgeName, WasherDryerCapability cap, String deviceId, Map data)
+ throws LGThinqApiException {
+ try {
+ ObjectNode dataSetList = JsonNodeFactory.instance.objectNode();
+ ObjectNode nodeData = dataSetList.putObject("dataSetList").putObject("washerDryer");
+ // 1 - mount nodeData template
+ CommandDefinition cdStart = cap.getCommandsDefinition().get(WMD_COMMAND_REMOTE_START_V2);
+ if (cdStart == null) {
+ throw new LGThinqApiException(
+ "Command WMStart doesn't defined in cap. Do the Device support Remote Start ?");
+ }
+ // remove data values (based on command template values) that it's not the real name
+ data.remove("course");
+ data.remove("SmartCourse");
+ for (Map.Entry value : data.entrySet()) {
+ Object v = value.getValue();
+ if (v instanceof Double d) {
+ nodeData.put(value.getKey(), d);
+ } else if (v instanceof Integer i) {
+ nodeData.put(value.getKey(), i);
+ } else {
+ nodeData.put(value.getKey(), value.getValue().toString());
+ }
+ }
+
+ RestResult result = sendCommand(bridgeName, deviceId, "control-sync", WMD_COMMAND_REMOTE_START_V2, "Set",
+ null, null, dataSetList);
+ handleGenericErrorResult(result);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending remote start", e);
+ }
+ }
+
+ @Override
+ public void wakeUp(String bridgeName, String deviceId, Boolean wakeUp) throws LGThinqApiException {
+ try {
+ ObjectNode dataSetList = JsonNodeFactory.instance.objectNode();
+ dataSetList.putObject("dataSetList").putObject("washerDryer").put("controlDataType", "WAKEUP")
+ .put("controlDataValueLength", wakeUp ? "1" : "0");
+
+ RestResult result = sendCommand(bridgeName, deviceId, "control-sync", "WMWakeup", "Set", null, null,
+ dataSetList);
+ handleGenericErrorResult(result);
+ } catch (LGThinqApiException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new LGThinqApiException("Error sending remote start", e);
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqCanonicalModelUtil.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqCanonicalModelUtil.java
new file mode 100644
index 00000000000..8f89cda7ce8
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqCanonicalModelUtil.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices.api;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Objects;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.lgthinq.lgservices.api.model.GatewayResult;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * The {@link LGThinqCanonicalModelUtil} class - Utilities to help communication with LG API
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinqCanonicalModelUtil {
+ public static ObjectMapper mapper = new ObjectMapper();
+
+ /**
+ * Get structured result from the LG Authentication Gateway
+ *
+ * @param rawJson RAW Json to process
+ * @return Structured Object returned from the API
+ * @throws IOException If some error happen procession token from file.
+ */
+ public static GatewayResult getGatewayResult(String rawJson) throws IOException {
+ Map map = mapper.readValue(rawJson, new TypeReference<>() {
+ });
+ @SuppressWarnings("unchecked")
+ Map content = (Map) map.get("result");
+ String resultCode = (String) map.get("resultCode");
+ if (content == null || content.isEmpty()) {
+ throw new IllegalArgumentException("Unexpected result. Gateway Content Result is null");
+ } else if (resultCode == null) {
+ throw new IllegalArgumentException("Unexpected result. resultCode code is null");
+ }
+
+ return new GatewayResult(Objects.requireNonNull(resultCode, "Expected resultCode field in json"), "",
+ Objects.requireNonNull(content.get("rtiUri"), "Expected rtiUri field in json"),
+ Objects.requireNonNull(content.get("thinq1Uri"), "Expected thinq1Uri field in json"),
+ Objects.requireNonNull(content.get("thinq2Uri"), "Expected thinq2Uri field in json"),
+ Objects.requireNonNull(content.get("empUri"), "Expected empUri field in json"),
+ Objects.requireNonNull(content.get("empTermsUri"), "Expected empTermsUri field in json"), "",
+ Objects.requireNonNull(content.get("empSpxUri"), "Expected empSpxUri field in json"));
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqGateway.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqGateway.java
new file mode 100644
index 00000000000..d9ae680000c
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqGateway.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices.api;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.*;
+
+import java.io.Serial;
+import java.io.Serializable;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.lgthinq.lgservices.api.model.GatewayResult;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+/**
+ * The {@link LGThinqGateway} hold information about the LG Gateway
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinqGateway implements Serializable {
+ @Serial
+ private static final long serialVersionUID = 202409261421L;
+ private String empBaseUri = "";
+ private String loginBaseUri = "";
+ private String apiRootV1 = "";
+ private String apiRootV2 = "";
+ private String authBase = "";
+ private String language = "";
+ private String country = "";
+ private String username = "";
+ private String password = "";
+ private String alternativeEmpServer = "";
+ private int accountVersion;
+
+ public LGThinqGateway() {
+ }
+
+ public LGThinqGateway(GatewayResult gwResult, String language, String country, String alternativeEmpServer) {
+ this.apiRootV2 = gwResult.getThinq2Uri();
+ this.apiRootV1 = gwResult.getThinq1Uri();
+ this.loginBaseUri = gwResult.getEmpSpxUri();
+ this.authBase = gwResult.getEmpUri();
+ this.empBaseUri = gwResult.getEmpTermsUri();
+ this.language = language;
+ this.country = country;
+ this.alternativeEmpServer = alternativeEmpServer;
+ }
+
+ @JsonIgnore
+ public String getTokenSessionEmpUrl() {
+ return alternativeEmpServer.isBlank() ? LG_API_V2_EMP_SESS_URL : alternativeEmpServer + LG_API_V2_EMP_SESS_PATH;
+ }
+
+ public String getEmpBaseUri() {
+ return empBaseUri;
+ }
+
+ public void setEmpBaseUri(String empBaseUri) {
+ this.empBaseUri = empBaseUri;
+ }
+
+ public int getAccountVersion() {
+ return accountVersion;
+ }
+
+ public String getApiRootV2() {
+ return apiRootV2;
+ }
+
+ public void setApiRootV2(String apiRootV2) {
+ this.apiRootV2 = apiRootV2;
+ }
+
+ public String getAuthBase() {
+ return authBase;
+ }
+
+ public void setAuthBase(String authBase) {
+ this.authBase = authBase;
+ }
+
+ public String getLanguage() {
+ return language;
+ }
+
+ public void setLanguage(String language) {
+ this.language = language;
+ }
+
+ public String getCountry() {
+ return country;
+ }
+
+ public void setCountry(String country) {
+ this.country = country;
+ }
+
+ public String getLoginBaseUri() {
+ return loginBaseUri;
+ }
+
+ public void setLoginBaseUri(String loginBaseUri) {
+ this.loginBaseUri = loginBaseUri;
+ }
+
+ public String getApiRootV1() {
+ return apiRootV1;
+ }
+
+ public void setApiRootV1(String apiRootV1) {
+ this.apiRootV1 = apiRootV1;
+ }
+
+ public String getUsername() {
+ return username;
+ }
+
+ public void setUsername(String username) {
+ this.username = username;
+ }
+
+ public String getPassword() {
+ return password;
+ }
+
+ public void setPassword(String password) {
+ this.password = password;
+ }
+
+ @Override
+ public String toString() {
+ return "LGThinqGateway{" + "empBaseUri='" + empBaseUri + '\'' + ", loginBaseUri='" + loginBaseUri + '\''
+ + ", apiRootV1='" + apiRootV1 + '\'' + ", apiRootV2='" + apiRootV2 + '\'' + ", authBase='" + authBase
+ + '\'' + ", language='" + language + '\'' + ", country='" + country + '\'' + ", username='" + username
+ + '\'' + ", password='" + (!password.isEmpty() ? "******" : "") + '\''
+ + ", alternativeEmpServer='" + alternativeEmpServer + '\'' + ", accountVersion=" + accountVersion + '}';
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqOauthEmpAuthenticator.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqOauthEmpAuthenticator.java
new file mode 100644
index 00000000000..e777abd5dfb
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/LGThinqOauthEmpAuthenticator.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices.api;
+
+import static org.openhab.binding.lgthinq.lgservices.LGServicesConstants.*;
+
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.text.SimpleDateFormat;
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.TimeZone;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.api.model.GatewayResult;
+import org.openhab.binding.lgthinq.lgservices.errors.RefreshTokenException;
+import org.openhab.binding.lgthinq.lgservices.model.ResultCodes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * The {@link LGThinqOauthEmpAuthenticator} main service to authenticate against LG Emp Server via Oauth
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class LGThinqOauthEmpAuthenticator {
+
+ private static final Map OAUTH_SEARCH_KEY_QUERY_PARAMS = new LinkedHashMap<>();
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ static {
+ OAUTH_SEARCH_KEY_QUERY_PARAMS.put("key_name", "OAUTH_SECRETKEY");
+ OAUTH_SEARCH_KEY_QUERY_PARAMS.put("sever_type", "OP");
+ }
+
+ private final Logger logger = LoggerFactory.getLogger(LGThinqOauthEmpAuthenticator.class);
+ private final HttpClient httpClient;
+
+ public LGThinqOauthEmpAuthenticator(HttpClient httpClient) {
+ this.httpClient = httpClient;
+ }
+
+ private Map getGatewayRestHeader(String language, String country) {
+ return Map.ofEntries(new AbstractMap.SimpleEntry("Accept", "application/json"),
+ new AbstractMap.SimpleEntry<>("x-api-key", LG_API_API_KEY_V2),
+ new AbstractMap.SimpleEntry<>("x-country-code", country),
+ new AbstractMap.SimpleEntry<>("x-client-id", LG_API_CLIENT_ID),
+ new AbstractMap.SimpleEntry<>("x-language-code", language),
+ new AbstractMap.SimpleEntry<>("x-message-id", LG_API_MESSAGE_ID),
+ new AbstractMap.SimpleEntry<>("x-service-code", LG_API_SVC_CODE),
+ new AbstractMap.SimpleEntry<>("x-service-phase", LG_API_SVC_PHASE),
+ new AbstractMap.SimpleEntry<>("x-thinq-app-level", LG_API_APP_LEVEL),
+ new AbstractMap.SimpleEntry<>("x-thinq-app-os", LG_API_APP_OS),
+ new AbstractMap.SimpleEntry<>("x-thinq-app-type", LG_API_APP_TYPE),
+ new AbstractMap.SimpleEntry<>("x-thinq-app-ver", LG_API_APP_VER));
+ }
+
+ private Map getLoginHeader(LGThinqGateway gw) {
+ Map headers = new HashMap<>();
+ headers.put("Connection", "keep-alive");
+ headers.put("X-Device-Language-Type", "IETF");
+ headers.put("X-Application-Key", "6V1V8H2BN5P9ZQGOI5DAQ92YZBDO3EK9");
+ headers.put("X-Client-App-Key", "LGAO221A02");
+ headers.put("X-Lge-Svccode", "SVC709");
+ headers.put("X-Device-Type", "M01");
+ headers.put("X-Device-Platform", "ADR");
+ headers.put("X-Device-Publish-Flag", "Y");
+ headers.put("X-Device-Country", gw.getCountry());
+ headers.put("X-Device-Language", gw.getLanguage());
+ headers.put("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
+ headers.put("Access-Control-Allow-Origin", "*");
+ headers.put("Accept-Encoding", "gzip, deflate, br");
+ headers.put("Accept-Language", "en-US,en;q=0.9,pt-BR;q=0.8,pt;q=0.7");
+ headers.put("Accept", "application/json");
+ return headers;
+ }
+
+ LGThinqGateway discoverGatewayConfiguration(String gwUrl, String language, String country,
+ String alternativeEmpServer) throws IOException {
+ Map header = getGatewayRestHeader(language, country);
+ RestResult result;
+ result = RestUtils.getCall(httpClient, gwUrl, header, null);
+
+ if (result.getStatusCode() != 200) {
+ throw new IllegalStateException(
+ String.format("Expected HTTP OK return, but received result core:[%s] - error message:[%s]",
+ result.getJsonResponse(), ResultCodes.getReasonResponse(result.getJsonResponse())));
+ } else {
+ GatewayResult gwResult = LGThinqCanonicalModelUtil.getGatewayResult(result.getJsonResponse());
+ ResultCodes resultCode = ResultCodes.fromCode(gwResult.getReturnedCode());
+ if (ResultCodes.OK != resultCode) {
+ throw new IllegalStateException(String.format(
+ "Result from LGThinq Gateway from Authentication URL was unexpected. ResultCode: %s, with message:%s, Error Description:%s",
+ gwResult.getReturnedCode(), gwResult.getReturnedMessage(), resultCode.getDescription()));
+ }
+
+ return new LGThinqGateway(gwResult, language, country, alternativeEmpServer);
+ }
+ }
+
+ PreLoginResult preLoginUser(LGThinqGateway gw, String username, String password) throws IOException {
+ String encPwd = RestUtils.getPreLoginEncPwd(password);
+ Map headers = getLoginHeader(gw);
+ // 1) Doing preLogin -> getting the password key
+ String preLoginUrl = gw.getLoginBaseUri() + LG_API_PRE_LOGIN_PATH;
+ Map formData = Map.of("user_auth2", encPwd, "log_param", String.format(
+ "login request / user_id : %s / " + "third_party : null / svc_list : SVC202,SVC710 / 3rd_service : ",
+ username));
+ RestResult resp = RestUtils.postCall(httpClient, preLoginUrl, headers, formData);
+ if (resp == null) {
+ throw new IllegalStateException("Error login into account. Null data returned");
+ } else if (resp.getStatusCode() != 200) {
+ throw new IllegalStateException(
+ String.format("Error preLogin into account: The reason is: %s", resp.getJsonResponse()));
+ }
+
+ Map preLoginResult = MAPPER.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ logger.debug("encrypted_pw={}, signature={}, tStamp={}", preLoginResult.get("encrypted_pw"),
+ preLoginResult.get("signature"), preLoginResult.get("tStamp"));
+ return new PreLoginResult(username,
+ Objects.requireNonNull(preLoginResult.get("signature"),
+ "Unexpected login json result. Node 'signature' not found"),
+ Objects.requireNonNull(preLoginResult.get("tStamp"),
+ "Unexpected login json result. Node 'signature' not found"),
+ Objects.requireNonNull(preLoginResult.get("encrypted_pw"),
+ "Unexpected login json result. Node 'signature' not found"));
+ }
+
+ LoginAccountResult loginUser(LGThinqGateway gw, PreLoginResult preLoginResult) throws IOException {
+ // 2 - Login with username and hashed password
+ Map headers = getLoginHeader(gw);
+ headers.put("X-Signature", preLoginResult.signature());
+ headers.put("X-Timestamp", preLoginResult.timestamp());
+ Map formData = Map.of("user_auth2", preLoginResult.encryptedPwd(),
+ "password_hash_prameter_flag", "Y", "svc_list", "SVC202,SVC710"); // SVC202=LG SmartHome, SVC710=EMP
+ // OAuth
+ String loginUrl = gw.getEmpBaseUri() + LG_API_V2_SESSION_LOGIN_PATH
+ + URLEncoder.encode(preLoginResult.username(), StandardCharsets.UTF_8);
+ RestResult resp = RestUtils.postCall(httpClient, loginUrl, headers, formData);
+ if (resp == null) {
+ throw new IllegalStateException("Error loggin into acccount. Null data returned");
+ } else if (resp.getStatusCode() != 200) {
+ throw new IllegalStateException(
+ String.format("Error login into account. The reason is: %s", resp.getJsonResponse()));
+ }
+ Map loginResult = MAPPER.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ @SuppressWarnings("unchecked")
+ Map accountResult = (Map) loginResult.get("account");
+ if (accountResult == null) {
+ throw new IllegalStateException("Error getting account from Login");
+ }
+ return new LoginAccountResult(
+ Objects.requireNonNull(accountResult.get("userIDType"),
+ "Unexpected account json result. 'userIDType' not found"),
+ Objects.requireNonNull(accountResult.get("userID"),
+ "Unexpected account json result. 'userID' not found"),
+ Objects.requireNonNull(accountResult.get("country"),
+ "Unexpected account json result. 'country' not found"),
+ Objects.requireNonNull(accountResult.get("loginSessionID"),
+ "Unexpected account json result. 'loginSessionID' not found"));
+ }
+
+ private String getCurrentTimestamp() {
+ SimpleDateFormat sdf = new SimpleDateFormat(LG_API_DATE_FORMAT, Locale.US);
+ sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
+ return sdf.format(new Date());
+ }
+
+ TokenResult getToken(LGThinqGateway gw, LoginAccountResult accountResult) throws IOException {
+ // 3 - get secret key from emp signature
+ String empSearchKeyUrl = gw.getLoginBaseUri() + LG_API_OAUTH_SEARCH_KEY_PATH;
+
+ RestResult resp = RestUtils.getCall(httpClient, empSearchKeyUrl, null, OAUTH_SEARCH_KEY_QUERY_PARAMS);
+ if (resp.getStatusCode() != 200) {
+ throw new IllegalStateException(
+ String.format("Error loggin into acccount. The reason is:%s", resp.getJsonResponse()));
+ }
+ Map secretResult = MAPPER.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ String secretKey = Objects.requireNonNull(secretResult.get("returnData"),
+ "Unexpected json returned. Expected 'returnData' node here");
+ logger.debug("Secret found:{}", secretResult.get("returnData"));
+
+ // 4 - get OAuth Token Key from EMP API
+ Map empData = new LinkedHashMap<>();
+ empData.put("account_type", accountResult.userIdType());
+ empData.put("client_id", LG_API_CLIENT_ID);
+ empData.put("country_code", accountResult.country());
+ empData.put("username", accountResult.userId());
+ String timestamp = getCurrentTimestamp();
+
+ byte[] oauthSig = RestUtils.getTokenSignature(gw.getTokenSessionEmpUrl(), secretKey, empData, timestamp);
+
+ Map oauthEmpHeaders = getOauthEmpHeaders(accountResult, timestamp, oauthSig);
+ logger.debug("===> Localized timestamp used: [{}]", timestamp);
+ logger.debug("===> signature created: [{}]", new String(oauthSig));
+ resp = RestUtils.postCall(httpClient, gw.getTokenSessionEmpUrl(), oauthEmpHeaders, empData);
+ return handleTokenResult(resp);
+ }
+
+ private Map getOauthEmpHeaders(LoginAccountResult accountResult, String timestamp,
+ byte[] oauthSig) {
+ Map oauthEmpHeaders = new LinkedHashMap<>();
+ oauthEmpHeaders.put("lgemp-x-app-key", LG_API_OAUTH_CLIENT_KEY);
+ oauthEmpHeaders.put("lgemp-x-date", timestamp);
+ oauthEmpHeaders.put("lgemp-x-session-key", accountResult.loginSessionId());
+ oauthEmpHeaders.put("lgemp-x-signature", new String(oauthSig));
+ oauthEmpHeaders.put("Accept", "application/json");
+ oauthEmpHeaders.put("X-Device-Type", "M01");
+ oauthEmpHeaders.put("X-Device-Platform", "ADR");
+ oauthEmpHeaders.put("Content-Type", "application/x-www-form-urlencoded");
+ oauthEmpHeaders.put("Access-Control-Allow-Origin", "*");
+ oauthEmpHeaders.put("Accept-Encoding", "gzip, deflate, br");
+ oauthEmpHeaders.put("Accept-Language", "en-US,en;q=0.9");
+ oauthEmpHeaders.put("User-Agent",
+ "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36 Edg/93.0.961.44");
+ return oauthEmpHeaders;
+ }
+
+ UserInfo getUserInfo(TokenResult token) throws IOException {
+ UriBuilder builder = UriBuilder.fromUri(token.getOauthBackendUrl()).path(LG_API_V2_USER_INFO);
+ String oauthUrl = builder.build().toURL().toString();
+ String timestamp = getCurrentTimestamp();
+ byte[] oauthSig = RestUtils.getTokenSignature(oauthUrl, LG_API_OAUTH_SECRET_KEY, Collections.emptyMap(),
+ timestamp);
+ Map headers = Map.of("Accept", "application/json", "Authorization",
+ String.format("Bearer %s", token.getAccessToken()), "X-Lge-Svccode", LG_API_SVC_CODE,
+ "X-Application-Key", LG_API_APPLICATION_KEY, "lgemp-x-app-key", LG_API_CLIENT_ID, "X-Device-Type",
+ "M01", "X-Device-Platform", "ADR", "x-lge-oauth-date", timestamp, "x-lge-oauth-signature",
+ new String(oauthSig));
+ RestResult resp = RestUtils.getCall(httpClient, oauthUrl, headers, null);
+
+ return handleAccountInfoResult(resp);
+ }
+
+ private UserInfo handleAccountInfoResult(RestResult resp) throws IOException {
+ Map result = MAPPER.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ if (resp.getStatusCode() != 200) {
+ throw new IllegalStateException(
+ String.format("LG API returned error when trying to get user account information. The reason is:%s",
+ resp.getJsonResponse()));
+ } else if (result.get("account") == null
+ || ((Map) result.getOrDefault("account", Collections.emptyMap())).get("userNo") == null) {
+ throw new IllegalStateException("Error retrieving the account user information from access token");
+ }
+ @SuppressWarnings("unchecked")
+ Map accountInfo = (Map) result.getOrDefault("account", Collections.emptyMap());
+
+ return new UserInfo(
+ Objects.requireNonNullElse(accountInfo.get("userNo"),
+ "Unexpected result. userID must be present in json result"),
+ Objects.requireNonNull(accountInfo.get("userID"),
+ "Unexpected result. userID must be present in json result"),
+ Objects.requireNonNull(accountInfo.get("userIDType"),
+ "Unexpected result. userIDType must be present in json result"),
+ Objects.requireNonNullElse(accountInfo.get("displayUserID"), ""));
+ }
+
+ TokenResult doRefreshToken(TokenResult currentToken) throws IOException, RefreshTokenException {
+ UriBuilder builder = UriBuilder.fromUri(currentToken.getOauthBackendUrl()).path(LG_API_V2_AUTH_PATH);
+ String oauthUrl = builder.build().toURL().toString();
+ String timestamp = getCurrentTimestamp();
+
+ Map formData = new LinkedHashMap<>();
+ formData.put("grant_type", "refresh_token");
+ formData.put("refresh_token", currentToken.getRefreshToken());
+
+ byte[] oauthSig = RestUtils.getTokenSignature(oauthUrl, LG_API_OAUTH_SECRET_KEY, formData, timestamp);
+
+ Map headers = Map.of("x-lge-appkey", LG_API_CLIENT_ID, "x-lge-oauth-signature",
+ new String(oauthSig), "x-lge-oauth-date", timestamp, "Accept", "application/json");
+
+ RestResult resp = RestUtils.postCall(httpClient, oauthUrl, headers, formData);
+ return handleRefreshTokenResult(resp, currentToken);
+ }
+
+ private TokenResult handleTokenResult(@Nullable RestResult resp) throws IOException {
+ Map tokenResult;
+ if (resp == null) {
+ throw new IllegalStateException("Error getting oauth token. Null data returned");
+ }
+ if (resp.getStatusCode() != 200) {
+ throw new IllegalStateException(
+ String.format("Error getting oauth token. HTTP Status Code is:%s, The reason is:%s",
+ resp.getStatusCode(), resp.getJsonResponse()));
+ } else {
+ tokenResult = MAPPER.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ Integer status = (Integer) tokenResult.get("status");
+ if ((status != null && !"1".equals("" + status)) || tokenResult.get("expires_in") == null) {
+ throw new IllegalStateException(String.format("Status error getting token:%s", tokenResult));
+ }
+ }
+
+ return new TokenResult(
+ Objects.requireNonNull((String) tokenResult.get("access_token"),
+ "Unexpected result. access_token must be present in json result"),
+ Objects.requireNonNull((String) tokenResult.get("refresh_token"),
+ "Unexpected result. refresh_token must be present in json result"),
+ Integer.parseInt(Objects.requireNonNull((String) tokenResult.get("expires_in"),
+ "Unexpected result. expires_in must be present in json result")),
+ new Date(), Objects.requireNonNull((String) tokenResult.get("oauth2_backend_url"),
+ "Unexpected result. oauth2_backend_url must be present in json result"));
+ }
+
+ private TokenResult handleRefreshTokenResult(@Nullable RestResult resp, TokenResult currentToken)
+ throws IOException, RefreshTokenException {
+ Map tokenResult;
+ if (resp == null) {
+ throw new RefreshTokenException("Error getting oauth token. Null data returned");
+ }
+ if (resp.getStatusCode() != 200) {
+ throw new RefreshTokenException(
+ String.format("Error getting oauth token. HTTP Status Code is:%s, The reason is:%s",
+ resp.getStatusCode(), resp.getJsonResponse()));
+ } else {
+ tokenResult = MAPPER.readValue(resp.getJsonResponse(), new TypeReference<>() {
+ });
+ if (tokenResult.get("access_token") == null || tokenResult.get("expires_in") == null) {
+ throw new RefreshTokenException(String.format("Status error get refresh token info:%s", tokenResult));
+ }
+ }
+
+ currentToken.setAccessToken(Objects.requireNonNull(tokenResult.get("access_token"),
+ "Unexpected error. Access Token must ever been provided by LG API"));
+ currentToken.setGeneratedTime(new Date());
+ currentToken.setExpiresIn(Integer.parseInt(Objects.requireNonNull(tokenResult.get("expires_in"),
+ "Unexpected error. Access Token must ever been provided by LG API")));
+ return currentToken;
+ }
+
+ record PreLoginResult(String username, String signature, String timestamp, String encryptedPwd) {
+ }
+
+ record LoginAccountResult(String userIdType, String userId, String country, String loginSessionId) {
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/RestResult.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/RestResult.java
new file mode 100644
index 00000000000..72d051746cf
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/RestResult.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices.api;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link RestResult} result from rest calls
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class RestResult {
+ private final String jsonResponse;
+ private final int resultCode;
+
+ public RestResult(String jsonResponse, int resultCode) {
+ this.jsonResponse = jsonResponse;
+ this.resultCode = resultCode;
+ }
+
+ public String getJsonResponse() {
+ return jsonResponse;
+ }
+
+ public int getStatusCode() {
+ return resultCode;
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/RestUtils.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/RestUtils.java
new file mode 100644
index 00000000000..dd8bb910477
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/RestUtils.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices.api;
+
+import static org.openhab.binding.lgthinq.internal.LGThinQBindingConstants.*;
+
+import java.math.BigInteger;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Base64;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import javax.ws.rs.core.UriBuilder;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.api.ContentProvider;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Request;
+import org.eclipse.jetty.client.util.FormContentProvider;
+import org.eclipse.jetty.client.util.StringContentProvider;
+import org.eclipse.jetty.util.Fields;
+import org.openhab.core.i18n.CommunicationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link RestUtils} rest utilities
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class RestUtils {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(RestUtils.class);
+
+ public static String getPreLoginEncPwd(String pwdToEnc) {
+ MessageDigest digest;
+ try {
+ digest = MessageDigest.getInstance(MESSAGE_DIGEST_ALGORITHM);
+ } catch (NoSuchAlgorithmException e) {
+ LOGGER.warn("The required algorithm is not available.", e);
+ throw new IllegalStateException("Unexpected error. SHA-512 algorithm must exists in JDK distribution", e);
+ }
+ digest.reset();
+ digest.update(pwdToEnc.getBytes(StandardCharsets.UTF_8));
+
+ return String.format("%0128x", new BigInteger(1, digest.digest()));
+ }
+
+ public static byte[] getOauth2Sig(String messageSign, String secret) {
+ byte[] secretBytes = secret.getBytes(StandardCharsets.UTF_8);
+ SecretKeySpec signingKey = new SecretKeySpec(secretBytes, HMAC_SHA1_ALGORITHM);
+
+ try {
+ Mac mac = Mac.getInstance(HMAC_SHA1_ALGORITHM);
+ mac.init(signingKey);
+ return Base64.getEncoder().encode(mac.doFinal(messageSign.getBytes(StandardCharsets.UTF_8)));
+ } catch (NoSuchAlgorithmException e) {
+ LOGGER.debug("Unexpected error. SHA1 algorithm must exists in JDK distribution.", e);
+ throw new IllegalStateException("Unexpected error. SHA1 algorithm must exists in JDK distribution", e);
+ } catch (InvalidKeyException e) {
+ LOGGER.debug("Unexpected error.", e);
+ throw new IllegalStateException("Unexpected error.", e);
+ }
+ }
+
+ public static byte[] getTokenSignature(String authUrl, String secretKey, Map empData,
+ String timestamp) {
+ UriBuilder builder = UriBuilder.fromUri(authUrl);
+ empData.forEach(builder::queryParam);
+
+ URI reqUri = builder.build();
+ String signUrl = !empData.isEmpty() ? reqUri.getPath() + "?" + reqUri.getRawQuery() : reqUri.getPath();
+ String messageToSign = String.format("%s\n%s", signUrl, timestamp);
+ return getOauth2Sig(messageToSign, secretKey);
+ }
+
+ public static RestResult getCall(HttpClient httpClient, String encodedUrl, @Nullable Map headers,
+ @Nullable Map params) {
+ Request request = httpClient.newRequest(encodedUrl).method("GET");
+ if (params != null) {
+ params.forEach(request::param);
+ }
+ if (headers != null) {
+ headers.forEach(request::header);
+ }
+
+ if (LOGGER.isTraceEnabled()) {
+ LOGGER.trace("GET request: {}", request.getURI());
+ }
+ try {
+ ContentResponse response = request.send();
+
+ LOGGER.trace("GET response: {}", response.getContentAsString());
+
+ return new RestResult(response.getContentAsString(), response.getStatus());
+ } catch (InterruptedException | TimeoutException | ExecutionException e) {
+ LOGGER.debug("Exception occurred during GET execution: {}", e.getMessage(), e);
+ throw new CommunicationException(e);
+ }
+ }
+
+ @Nullable
+ public static RestResult postCall(HttpClient httpClient, String encodedUrl, Map headers,
+ String jsonData) {
+ return postCall(httpClient, encodedUrl, headers, new StringContentProvider(jsonData));
+ }
+
+ @Nullable
+ public static RestResult postCall(HttpClient httpClient, String encodedUrl, Map headers,
+ Map formParams) {
+ Fields fields = new Fields();
+ formParams.forEach(fields::put);
+ return postCall(httpClient, encodedUrl, headers, new FormContentProvider(fields));
+ }
+
+ @Nullable
+ private static RestResult postCall(HttpClient httpClient, String encodedUrl, Map headers,
+ ContentProvider contentProvider) {
+ try {
+ Request request = httpClient.newRequest(encodedUrl).method("POST").content(contentProvider).timeout(10,
+ TimeUnit.SECONDS);
+ headers.forEach(request::header);
+ LOGGER.trace("POST request to URI: {}", request.getURI());
+
+ ContentResponse response = request.content(contentProvider).timeout(10, TimeUnit.SECONDS).send();
+
+ LOGGER.trace("POST response: {}", response.getContentAsString());
+
+ return new RestResult(response.getContentAsString(), response.getStatus());
+ } catch (TimeoutException e) {
+ LOGGER.warn("Timeout reading post call result from LG API", e); // In SocketTimeout cases I'm considering
+ // that I have no response on time. Then, I
+ // return null data
+ // forcing caller to retry.
+ return null;
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new CommunicationException(e);
+ } catch (ExecutionException e) {
+ throw new CommunicationException(e);
+ }
+ }
+}
diff --git a/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/TokenManager.java b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/TokenManager.java
new file mode 100644
index 00000000000..c221388f5b6
--- /dev/null
+++ b/bundles/org.openhab.binding.lgthinq/src/main/java/org/openhab/binding/lgthinq/lgservices/api/TokenManager.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2010-2025 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.lgthinq.lgservices.api;
+
+import static org.openhab.binding.lgthinq.internal.LGThinQBindingConstants.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.lgthinq.lgservices.errors.AccountLoginException;
+import org.openhab.binding.lgthinq.lgservices.errors.LGThinqGatewayException;
+import org.openhab.binding.lgthinq.lgservices.errors.PreLoginException;
+import org.openhab.binding.lgthinq.lgservices.errors.RefreshTokenException;
+import org.openhab.binding.lgthinq.lgservices.errors.TokenException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * The {@link TokenManager} Principal facade to manage all token handles
+ *
+ * @author Nemer Daud - Initial contribution
+ */
+@NonNullByDefault
+public class TokenManager {
+ private static final int EXPIRICY_TOLERANCE_SEC = 60;
+ private final Logger logger = LoggerFactory.getLogger(TokenManager.class);
+ private final LGThinqOauthEmpAuthenticator authenticator;
+ private final ObjectMapper objectMapper = new ObjectMapper();
+ private final Map