git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.pjlinkdevice.internal.device;
  14
  15 import java.io.BufferedReader;
  16 import java.io.IOException;
  17 import java.io.InputStreamReader;
  18 import java.net.ConnectException;
  19 import java.net.InetAddress;
  20 import java.net.InetSocketAddress;
  21 import java.net.NoRouteToHostException;
  22 import java.net.Socket;
  23 import java.net.SocketAddress;
  24 import java.net.SocketTimeoutException;
  25 import java.text.MessageFormat;
  26 import java.time.Duration;
  27 import java.time.Instant;
  28 import java.util.Arrays;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Set;
  32
  33 import org.eclipse.jdt.annotation.NonNullByDefault;
  34 import org.eclipse.jdt.annotation.Nullable;
  35 import org.openhab.binding.pjlinkdevice.internal.device.command.AuthenticationException;
  36 import org.openhab.binding.pjlinkdevice.internal.device.command.CachedCommand;
  37 import org.openhab.binding.pjlinkdevice.internal.device.command.ResponseException;
  38 import org.openhab.binding.pjlinkdevice.internal.device.command.authentication.AuthenticationCommand;
  39 import org.openhab.binding.pjlinkdevice.internal.device.command.errorstatus.ErrorStatusQueryCommand;
  40 import org.openhab.binding.pjlinkdevice.internal.device.command.errorstatus.ErrorStatusQueryResponse.ErrorStatusDevicePart;
  41 import org.openhab.binding.pjlinkdevice.internal.device.command.errorstatus.ErrorStatusQueryResponse.ErrorStatusQueryResponseState;
  42 import org.openhab.binding.pjlinkdevice.internal.device.command.identification.IdentificationCommand;
  43 import org.openhab.binding.pjlinkdevice.internal.device.command.input.Input;
  44 import org.openhab.binding.pjlinkdevice.internal.device.command.input.InputInstructionCommand;
  45 import org.openhab.binding.pjlinkdevice.internal.device.command.input.InputListQueryCommand;
  46 import org.openhab.binding.pjlinkdevice.internal.device.command.input.InputQueryCommand;
  47 import org.openhab.binding.pjlinkdevice.internal.device.command.input.InputQueryResponse;
  48 import org.openhab.binding.pjlinkdevice.internal.device.command.lampstatus.LampStatesCommand;
  49 import org.openhab.binding.pjlinkdevice.internal.device.command.lampstatus.LampStatesResponse;
  50 import org.openhab.binding.pjlinkdevice.internal.device.command.lampstatus.LampStatesResponse.LampState;
  51 import org.openhab.binding.pjlinkdevice.internal.device.command.mute.MuteInstructionCommand;
  52 import org.openhab.binding.pjlinkdevice.internal.device.command.mute.MuteInstructionCommand.MuteInstructionChannel;
  53 import org.openhab.binding.pjlinkdevice.internal.device.command.mute.MuteInstructionCommand.MuteInstructionState;
  54 import org.openhab.binding.pjlinkdevice.internal.device.command.mute.MuteQueryCommand;
  55 import org.openhab.binding.pjlinkdevice.internal.device.command.mute.MuteQueryResponse.MuteQueryResponseValue;
  56 import org.openhab.binding.pjlinkdevice.internal.device.command.power.PowerInstructionCommand;
  57 import org.openhab.binding.pjlinkdevice.internal.device.command.power.PowerQueryCommand;
  58 import org.openhab.binding.pjlinkdevice.internal.device.command.power.PowerQueryResponse;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 /**
  63  * Represents a PJLink device and takes care of managing the TCP connection, executing commands, and authentication.
  64  *
  65  * The central interface to get information about and set status on the device.
  66  *
  67  * @author Nils Schnabel - Initial contribution
  68  */
  69 @NonNullByDefault
  70 public class PJLinkDevice {
  71     private static final int TIMEOUT = 30000;
  72     protected int tcpPort;
  73     protected InetAddress ipAddress;
  74     protected @Nullable String adminPassword;
  75     protected boolean authenticationRequired;
  76     protected @Nullable BufferedReader reader;
  77     protected @Nullable Socket socket;
  78     protected int timeout = TIMEOUT;
  79     private final Logger logger = LoggerFactory.getLogger(PJLinkDevice.class);
  80     private String prefixForNextCommand = "";
  81     private @Nullable Instant socketCreatedOn;
  82     private CachedCommand<LampStatesResponse> cachedLampHoursCommand = new CachedCommand<>(new LampStatesCommand(this));
  83
  84     public PJLinkDevice(int tcpPort, InetAddress ipAddress, @Nullable String adminPassword, int timeout) {
  85         this.tcpPort = tcpPort;
  86         this.ipAddress = ipAddress;
  87         this.adminPassword = adminPassword;
  88         this.timeout = timeout;
  89     }
  90
  91     public PJLinkDevice(int tcpPort, InetAddress ipAddress, @Nullable String adminPassword) {
  92         this(tcpPort, ipAddress, adminPassword, TIMEOUT);
  93     }
  94
  95     @Override
  96     public String toString() {
  97         return "PJLink " + this.ipAddress + ":" + this.tcpPort;
  98     }
  99
 100     protected Socket connect() throws IOException, ResponseException, AuthenticationException {
 101         return connect(false);
 102     }
 103
 104     protected BufferedReader getReader() throws IOException, ResponseException, AuthenticationException {
 105         BufferedReader reader = this.reader;
 106         if (reader == null) {
 107             this.reader = reader = new BufferedReader(new InputStreamReader(connect().getInputStream()));
 108         }
 109         return reader;
 110     }
 111
 112     protected void closeSocket(@Nullable Socket socket) {
 113         if (socket != null) {
 114             try {
 115                 socket.close();
 116             } catch (IOException e) {
 117                 // okay then, at least we tried
 118                 logger.trace("closing of socket failed", e);
 119             }
 120         }
 121         this.socket = null;
 122         this.reader = null;
 123     }
 124
 125     protected Socket connect(boolean forceReconnect) throws IOException, ResponseException, AuthenticationException {
 126         Instant now = Instant.now();
 127         Socket socket = this.socket;
 128         boolean connectionTooOld = false;
 129         Instant socketCreatedOn = this.socketCreatedOn;
 130         if (socketCreatedOn != null) {
 131             long millisecondsSinceLastConnect = Duration.between(socketCreatedOn, now).toMillis();
 132             // according to the PJLink specification, the device closes the connection after 30s idle (without notice),
 133             // so to be on the safe side we do not reuse sockets older than 20s
 134             connectionTooOld = millisecondsSinceLastConnect > 20 * 1000;
 135         }
 136
 137         if (forceReconnect || connectionTooOld) {
 138             if (socket != null) {
 139                 closeSocket(socket);
 140             }
 141         }
 142
 143         this.socketCreatedOn = now;
 144         if (socket != null && socket.isConnected() && !socket.isClosed()) {
 145             return socket;
 146         }
 147
 148         SocketAddress socketAddress = new InetSocketAddress(ipAddress, tcpPort);
 149
 150         try {
 151             this.socket = socket = new Socket();
 152             socket.connect(socketAddress, timeout);
 153             socket.setSoTimeout(timeout);
 154             BufferedReader reader = getReader();
 155             String rawHeader = reader.readLine();
 156             if (rawHeader == null) {
 157                 throw new ResponseException("No PJLink header received from the device");
 158             }
 159             String header = rawHeader.toUpperCase();
 160             switch (header.substring(0, "PJLINK x".length())) {
 161                 case "PJLINK 0":
 162                     logger.debug("Authentication not needed");
 163                     this.authenticationRequired = false;
 164                     break;
 165                 case "PJLINK 1":
 166                     logger.debug("Authentication needed");
 167                     this.authenticationRequired = true;
 168                     if (this.adminPassword == null) {
 169                         closeSocket(socket);
 170                         throw new AuthenticationException("No password provided, but device requires authentication");
 171                     } else {
 172                         try {
 173                             authenticate(rawHeader.substring("PJLINK 1 ".length()));
 174                         } catch (ResponseException e) {
 175                             // maybe only the test command is broken on the device
 176                             // as long as we don't get an AuthenticationException, we'll just ignore it for now
 177                         }
 178                     }
 179                     break;
 180                 default:
 181                     logger.debug("Cannot handle introduction response {}", header);
 182                     throw new ResponseException("Invalid header: " + header);
 183             }
 184             return socket;
 185         } catch (ConnectException | SocketTimeoutException | NoRouteToHostException e) {
 186             // these exceptions indicate that there's no device at this address, just throw without logging
 187             throw e;
 188         } catch (IOException | ResponseException e) {
 189             // these exceptions seem to be more interesting in the log during a scan
 190             // This should not happen and might be a user configuration issue, we log a warning message therefore.
 191             logger.debug("Could not create a socket connection", e);
 192             throw e;
 193         }
 194     }
 195
 196     private void authenticate(String challenge) throws ResponseException, IOException, AuthenticationException {
 197         new AuthenticationCommand<>(this, challenge, new PowerQueryCommand(this)).execute();
 198     }
 199
 200     public PowerQueryResponse getPowerStatus() throws ResponseException, IOException, AuthenticationException {
 201         return new PowerQueryCommand(this).execute();
 202     }
 203
 204     public void addPrefixToNextCommand(String cmd) throws IOException, AuthenticationException {
 205         this.prefixForNextCommand = cmd;
 206     }
 207
 208     public static String preprocessResponse(String response) {
 209         // some devices send leading zero bytes, see https://github.com/openhab/openhab-addons/issues/6725
 210         return response.replaceAll("^\0*|\0*$", "");
 211     }
 212
 213     public synchronized String execute(String command) throws IOException, AuthenticationException, ResponseException {
 214         String fullCommand = this.prefixForNextCommand + command;
 215         this.prefixForNextCommand = "";
 216         for (int numberOfTries = 0; true; numberOfTries++) {
 217             try {
 218                 Socket socket = connect();
 219                 socket.getOutputStream().write((fullCommand).getBytes());
 220                 socket.getOutputStream().flush();
 221
 222                 // success, no further tries needed
 223                 break;
 224             } catch (java.net.SocketException e) {
 225                 closeSocket(socket);
 226                 if (numberOfTries >= 2) {
 227                     // do not retry endlessly
 228                     throw e;
 229                 }
 230             }
 231         }
 232
 233         String response = null;
 234         while ((response = getReader().readLine()) != null && preprocessResponse(response).isEmpty()) {
 235             logger.debug("Got empty string response for request '{}' from {}, waiting for another line", response,
 236                     fullCommand.replace("\r", "\\\\r"));
 237         }
 238         if (response == null) {
 239             throw new ResponseException(
 240                     MessageFormat.format("Response to request ''{0}'' was null", fullCommand.replace("\r", "\\\\r")));
 241         }
 242
 243         if (logger.isDebugEnabled()) {
 244             logger.debug("Got response '{}' ({}) for request '{}' from {}", response,
 245                     Arrays.toString(response.getBytes()), fullCommand.replace("\r", "\\\\r"), ipAddress);
 246         }
 247         return preprocessResponse(response);
 248     }
 249
 250     public void checkAvailability() throws IOException, AuthenticationException, ResponseException {
 251         connect();
 252     }
 253
 254     public String getName() throws IOException, ResponseException, AuthenticationException {
 255         return new IdentificationCommand(this, IdentificationCommand.IdentificationProperty.NAME).execute().getResult();
 256     }
 257
 258     public String getManufacturer() throws IOException, ResponseException, AuthenticationException {
 259         return new IdentificationCommand(this, IdentificationCommand.IdentificationProperty.MANUFACTURER).execute()
 260                 .getResult();
 261     }
 262
 263     public String getModel() throws IOException, ResponseException, AuthenticationException {
 264         return new IdentificationCommand(this, IdentificationCommand.IdentificationProperty.MODEL).execute()
 265                 .getResult();
 266     }
 267
 268     public String getFullDescription() throws AuthenticationException, ResponseException {
 269         StringBuilder sb = new StringBuilder();
 270         try {
 271             sb.append(getManufacturer());
 272             sb.append(" ");
 273         } catch (ResponseException | IOException e) {
 274             // okay, we'll try the other identification commands
 275         }
 276
 277         try {
 278             sb.append(getModel());
 279         } catch (ResponseException | IOException e1) {
 280             // okay, we'll try the other identification commands
 281         }
 282
 283         try {
 284             String name = getName();
 285             if (!name.isEmpty()) {
 286                 sb.append(": ");
 287                 sb.append(name);
 288             }
 289         } catch (ResponseException | IOException e2) {
 290             // okay, we'll try the other identification commands
 291         }
 292
 293         if (sb.length() == 0) {
 294             throw new ResponseException("None of the identification commands worked");
 295         }
 296
 297         return sb.toString();
 298     }
 299
 300     public String getPJLinkClass() throws IOException, AuthenticationException, ResponseException {
 301         return new IdentificationCommand(this, IdentificationCommand.IdentificationProperty.CLASS).execute()
 302                 .getResult();
 303     }
 304
 305     public void powerOn() throws ResponseException, IOException, AuthenticationException {
 306         new PowerInstructionCommand(this, PowerInstructionCommand.PowerInstructionState.ON).execute();
 307     }
 308
 309     public void powerOff() throws IOException, ResponseException, AuthenticationException {
 310         new PowerInstructionCommand(this, PowerInstructionCommand.PowerInstructionState.OFF).execute();
 311     }
 312
 313     public @Nullable String getAdminPassword() {
 314         return this.adminPassword;
 315     }
 316
 317     public Boolean getAuthenticationRequired() {
 318         return this.authenticationRequired;
 319     }
 320
 321     public InputQueryResponse getInputStatus() throws ResponseException, IOException, AuthenticationException {
 322         return new InputQueryCommand(this).execute();
 323     }
 324
 325     public void setInput(Input input) throws ResponseException, IOException, AuthenticationException {
 326         new InputInstructionCommand(this, input).execute();
 327     }
 328
 329     public MuteQueryResponseValue getMuteStatus() throws ResponseException, IOException, AuthenticationException {
 330         return new MuteQueryCommand(this).execute().getResult();
 331     }
 332
 333     public void setMute(MuteInstructionChannel channel, boolean muteOn)
 334             throws ResponseException, IOException, AuthenticationException {
 335         new MuteInstructionCommand(this, muteOn ? MuteInstructionState.ON : MuteInstructionState.OFF, channel)
 336                 .execute();
 337     }
 338
 339     public Map<ErrorStatusDevicePart, ErrorStatusQueryResponseState> getErrorStatus()
 340             throws ResponseException, IOException, AuthenticationException {
 341         return new ErrorStatusQueryCommand(this).execute().getResult();
 342     }
 343
 344     public List<LampState> getLampStates() throws ResponseException, IOException, AuthenticationException {
 345         return new LampStatesCommand(this).execute().getResult();
 346     }
 347
 348     public List<LampState> getLampStatesCached() throws ResponseException, IOException, AuthenticationException {
 349         return cachedLampHoursCommand.execute().getResult();
 350     }
 351
 352     public String getOtherInformation() throws ResponseException, IOException, AuthenticationException {
 353         return new IdentificationCommand(this, IdentificationCommand.IdentificationProperty.OTHER_INFORMATION).execute()
 354                 .getResult();
 355     }
 356
 357     public Set<Input> getAvailableInputs() throws ResponseException, IOException, AuthenticationException {
 358         return new InputListQueryCommand(this).execute().getResult();
 359     }
 360
 361     public void dispose() {
 362         final Socket socket = this.socket;
 363         if (socket != null) {
 364             closeSocket(socket);
 365         }
 366     }
 367 }