import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNullByDefault;
return response.getContentAsString();
} catch (DaikinCommunicationException e) {
throw e;
- } catch (Exception e) {
+ } catch (ExecutionException | TimeoutException e) {
throw new DaikinCommunicationException("Daikin HTTP error", e);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new DaikinCommunicationException("Daikin HTTP interrupted", e);
}
}
*/
@NonNullByDefault
public class BasicInfo {
- private static final Logger logger = LoggerFactory.getLogger(BasicInfo.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(BasicInfo.class);
public String mac = "";
public String ret = "";
}
public static BasicInfo parse(String response) {
- logger.debug("Parsing string: \"{}\"", response);
+ LOGGER.debug("Parsing string: \"{}\"", response);
Map<String, String> responseMap = InfoParser.parse(response);
public Optional<Double> energyCoolingThisWeek = Optional.empty();
public Optional<Double> energyCoolingLastWeek = Optional.empty();
- private static final Logger logger = LoggerFactory.getLogger(EnergyInfoDayAndWeek.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(EnergyInfoDayAndWeek.class);
private EnergyInfoDayAndWeek() {
}
public static EnergyInfoDayAndWeek parse(String response) {
EnergyInfoDayAndWeek info = new EnergyInfoDayAndWeek();
- logger.trace("Parsing string: \"{}\"", response);
+ LOGGER.trace("Parsing string: \"{}\"", response);
// /aircon/get_week_power_ex
// ret=OK,s_dayw=0,week_heat=1/1/1/1/1/5/2/1/1/1/1/2/1/1,week_cool=0/0/0/0/0/0/0/0/0/0/0/0/0/0
info.energyCoolingLastWeek = Optional.of(previousWeekEnergy / 10);
}
} else {
- logger.debug("did not receive 'ret=OK' from adapter");
+ LOGGER.debug("did not receive 'ret=OK' from adapter");
}
return info;
}
}
public static EnergyInfoYear parse(String response) {
-
LOGGER.trace("Parsing string: \"{}\"", response);
Map<String, String> responseMap = InfoParser.parse(response);
*/
@NonNullByDefault
public class AirbaseBasicInfo {
- private static final Logger logger = LoggerFactory.getLogger(AirbaseBasicInfo.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(AirbaseBasicInfo.class);
public String mac = "";
public String ret = "";
}
public static AirbaseBasicInfo parse(String response) {
- logger.debug("Parsing string: \"{}\"", response);
+ LOGGER.debug("Parsing string: \"{}\"", response);
Map<String, String> responseMap = InfoParser.parse(response);
* @author Paul Smedley - Modifications to support Airbase Controllers
* @author Lukas Agethen - Added support for Energy Year reading, compressor frequency and powerful mode
* @author Wouter Denayer - Added to support for weekly & daily energy reading
- *
+ *
*/
@NonNullByDefault
public class DaikinAcUnitHandler extends DaikinBaseHandler {
}
/**
- *
+ *
* @param channel
* @param maybePower
*/
return;
}
webTargets.registerUuid(key);
- } catch (Exception e) {
+ } catch (DaikinCommunicationException e) {
// suppress exceptions
logger.debug("registerUuid({}) error: {}", key, e.getMessage());
}
import java.time.Duration;
import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
throw new NumberFormatException();
} else {
String[] splittedConfigTime = time.split(TIME_SEPARATOR);
+ if (splittedConfigTime.length < 2) {
+ throw new NumberFormatException();
+ }
int hour = Integer.parseInt(splittedConfigTime[0]);
int minutes = Integer.parseInt(splittedConfigTime[1]);
return Duration.ofMinutes(minutes).plusHours(hour).toMinutes();
}
- } catch (Exception ex) {
+ } catch (PatternSyntaxException | NumberFormatException | ArithmeticException ex) {
logger.warn("Cannot parse channel configuration '{}' to hour and minutes, use pattern hh:mm, ignoring!",
time);
}
} else {
throw new DarkSkyCommunicationException(errorMessage, e.getCause());
}
- } catch (InterruptedException | TimeoutException e) {
+ } catch (TimeoutException e) {
logger.debug("Exception occurred during execution: {}", e.getLocalizedMessage(), e);
throw new DarkSkyCommunicationException(e.getLocalizedMessage(), e.getCause());
+ } catch (InterruptedException e) {
+ logger.debug("Execution interrupted: {}", e.getLocalizedMessage(), e);
+ Thread.currentThread().interrupt();
+ throw new DarkSkyCommunicationException(e.getLocalizedMessage(), e.getCause());
}
}
listener.telnetClientConnected(false);
} catch (InterruptedException e) {
logger.debug("Interrupted while connecting to {}", config.getHost(), e);
+ Thread.currentThread().interrupt();
}
delay = RECONNECT_DELAY;
}
Thread.sleep(300);
} catch (InterruptedException e) {
logger.trace("requestStateOverTelnet() - Interrupted while requesting state.");
+ Thread.currentThread().interrupt();
}
}
});
* Try to auto configure the connection type (Telnet or HTTP)
* for Things not added through Paper UI.
*/
- private void autoConfigure() {
+ private void autoConfigure() throws InterruptedException {
/*
* The isTelnet parameter has no default.
* When not set we will try to auto-detect the correct values
telnetEnable = false;
httpApiUsable = true;
}
- } catch (InterruptedException | TimeoutException | ExecutionException e) {
+ } catch (TimeoutException | ExecutionException e) {
logger.debug("Error when trying to access AVR using HTTP on port 80, reverting to Telnet mode.", e);
}
httpPort = 8080;
httpApiUsable = true;
}
- } catch (InterruptedException | TimeoutException | ExecutionException e) {
+ } catch (TimeoutException | ExecutionException e) {
logger.debug("Additionally tried to connect to port 8080, this also failed", e);
}
}
response = httpClient.newRequest("http://" + host + ":" + httpPort + "/goform/Deviceinfo.xml")
.timeout(3, TimeUnit.SECONDS).send();
status = response.getStatus();
- } catch (InterruptedException | TimeoutException | ExecutionException e) {
+ } catch (TimeoutException | ExecutionException e) {
logger.debug("Failed in fetching the Deviceinfo.xml to determine zone count", e);
}
// Configure Connection type (Telnet/HTTP) and number of zones
// Note: this only happens for discovered Things
- autoConfigure();
+ try {
+ autoConfigure();
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ return;
+ }
if (!checkConfiguration()) {
return;
} catch (final NoSuchAlgorithmException e) {
logger.debug("login - Internal error", e);
status = HNAPStatus.INTERNAL_ERROR;
+ } catch (final InterruptedException e) {
+ status = HNAPStatus.COMMUNICATION_ERROR;
+ Thread.currentThread().interrupt();
} catch (final Exception e) {
// Assume there has been some problem trying to send one of the messages
if (status != HNAPStatus.COMMUNICATION_ERROR) {
} else {
unexpectedResult("getLastDetection - Unexpected response", soapResponse);
}
+ } catch (final InterruptedException e) {
+ status = DeviceStatus.COMMUNICATION_ERROR;
+ Thread.currentThread().interrupt();
} catch (final Exception e) {
// Assume there has been some problem trying to send one of the messages
if (status != DeviceStatus.COMMUNICATION_ERROR) {
If you don't see the **Developer** option on the menu, then something went wrong with the previous step.
4. Finally, create a new application.
+
Give the application a name and fill in the application summary.
Select the **Ecobee PIN** Authorization Method, then press **Create**.
You now should see the **API key** for the application you just created.
}
} catch (InterruptedException e) {
logger.debug("InterruptedException on call to Ecobee authorization API: {}", e.getMessage());
+ Thread.currentThread().interrupt();
}
return null;
}
String errorMessage = e.getLocalizedMessage();
logger.debug("Exception occurred during execution: {}", errorMessage, e);
throw new EnturCommunicationException(errorMessage, e);
- } catch (InterruptedException | TimeoutException | IOException e) {
+ } catch (TimeoutException | IOException e) {
logger.debug("Exception occurred during execution: {}", e.getLocalizedMessage(), e);
throw new EnturCommunicationException(e.getLocalizedMessage(), e);
+ } catch (InterruptedException e) {
+ logger.debug("Execution interrupted: {}", e.getLocalizedMessage(), e);
+ Thread.currentThread().interrupt();
+ throw new EnturCommunicationException(e.getLocalizedMessage(), e);
}
}
logger.warn("Etherrain return status other than HTTP_OK : {}", response.getStatus());
return Collections.emptyList();
}
- } catch (InterruptedException | TimeoutException | ExecutionException e) {
+ } catch (TimeoutException | ExecutionException e) {
logger.warn("Could not connect to Etherrain with exception: {}", e.getMessage());
return Collections.emptyList();
+ } catch (InterruptedException e) {
+ logger.warn("Connect to Etherrain interrupted: {}", e.getMessage());
+ Thread.currentThread().interrupt();
+ return Collections.emptyList();
}
return new BufferedReader(new StringReader(response.getContentAsString())).lines().collect(Collectors.toList());
retVal = new Gson().fromJson(reply, outClass);
}
}
- } catch (InterruptedException | ExecutionException e) {
+ } catch (ExecutionException e) {
logger.debug("Error in handling request: ", e);
+ } catch (InterruptedException e) {
+ logger.debug("Handling request interrupted: ", e);
+ Thread.currentThread().interrupt();
}
return retVal;
private static final String CLIENT_SECRET = "1a15cdb8-42de-407b-add0-059f92c530cb";
private final Logger logger = LoggerFactory.getLogger(EvohomeApiClient.class);
- private final HttpClient httpClient;
private final EvohomeAccountConfiguration configuration;
private final ApiAccess apiAccess;
* Creates a new API client based on the V2 API interface
*
* @param configuration The configuration of the account to use
- * @throws Exception
*/
- public EvohomeApiClient(EvohomeAccountConfiguration configuration, HttpClient httpClient) throws Exception {
+ public EvohomeApiClient(EvohomeAccountConfiguration configuration, HttpClient httpClient) {
this.configuration = configuration;
- this.httpClient = httpClient;
-
- try {
- httpClient.start();
- } catch (Exception e) {
- logger.error("Could not start http client", e);
- throw new EvohomeApiClientException("Could not start http client", e);
- }
-
apiAccess = new ApiAccess(httpClient);
apiAccess.setApplicationId(APPLICATION_ID);
}
useraccount = null;
locations = null;
locationsStatus = null;
-
- if (httpClient.isStarted()) {
- try {
- httpClient.stop();
- } catch (Exception e) {
- logger.debug("Could not stop http client.", e);
- }
- }
}
public boolean login() {
configuration = getConfigAs(EvohomeAccountConfiguration.class);
if (checkConfig()) {
- try {
- apiClient = new EvohomeApiClient(configuration, this.httpClient);
- } catch (Exception e) {
- logger.error("Could not start API client", e);
- updateAccountStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
- "Could not create evohome API client");
- }
+ apiClient = new EvohomeApiClient(configuration, this.httpClient);
- if (apiClient != null) {
- // Initialization can take a while, so kick it off on a separate thread
- scheduler.schedule(() -> {
- if (apiClient.login()) {
- if (checkInstallationInfoHasDuplicateIds(apiClient.getInstallationInfo())) {
- startRefreshTask();
- } else {
- updateAccountStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
- "System Information Sanity Check failed");
- }
+ // Initialization can take a while, so kick it off on a separate thread
+ scheduler.schedule(() -> {
+ if (apiClient.login()) {
+ if (checkInstallationInfoHasDuplicateIds(apiClient.getInstallationInfo())) {
+ startRefreshTask();
} else {
updateAccountStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
- "Authentication failed");
+ "System Information Sanity Check failed");
}
- }, 0, TimeUnit.SECONDS);
- }
+ } else {
+ updateAccountStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+ "Authentication failed");
+ }
+ }, 0, TimeUnit.SECONDS);
}
}
projects / openhab-addons.git / commitdiff