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

   1 /**
   2  * Copyright (c) 2010-2020 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.feed.internal.handler;
  14
  15 import static org.openhab.binding.feed.internal.FeedBindingConstants.*;
  16
  17 import java.io.BufferedReader;
  18 import java.io.IOException;
  19 import java.io.InputStreamReader;
  20 import java.math.BigDecimal;
  21 import java.net.MalformedURLException;
  22 import java.net.URL;
  23 import java.net.URLConnection;
  24 import java.time.ZoneId;
  25 import java.time.ZonedDateTime;
  26 import java.util.Date;
  27 import java.util.List;
  28 import java.util.concurrent.ScheduledFuture;
  29 import java.util.concurrent.TimeUnit;
  30 import java.util.zip.GZIPInputStream;
  31
  32 import org.eclipse.jdt.annotation.NonNullByDefault;
  33 import org.eclipse.jdt.annotation.Nullable;
  34 import org.openhab.core.config.core.Configuration;
  35 import org.openhab.core.library.types.DateTimeType;
  36 import org.openhab.core.library.types.DecimalType;
  37 import org.openhab.core.library.types.StringType;
  38 import org.openhab.core.thing.ChannelUID;
  39 import org.openhab.core.thing.Thing;
  40 import org.openhab.core.thing.ThingStatus;
  41 import org.openhab.core.thing.ThingStatusDetail;
  42 import org.openhab.core.thing.binding.BaseThingHandler;
  43 import org.openhab.core.types.Command;
  44 import org.openhab.core.types.RefreshType;
  45 import org.openhab.core.types.State;
  46 import org.openhab.core.types.UnDefType;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 import com.rometools.rome.feed.synd.SyndEntry;
  51 import com.rometools.rome.feed.synd.SyndFeed;
  52 import com.rometools.rome.io.FeedException;
  53 import com.rometools.rome.io.SyndFeedInput;
  54
  55 /**
  56  * The {@link FeedHandler } is responsible for handling commands, which are
  57  * sent to one of the channels and for the regular updates of the feed data.
  58  *
  59  * @author Svilen Valkanov - Initial contribution
  60  */
  61 @NonNullByDefault
  62 public class FeedHandler extends BaseThingHandler {
  63
  64     private final Logger logger = LoggerFactory.getLogger(FeedHandler.class);
  65
  66     private @Nullable URL url;
  67     private long refreshTime;
  68     private @Nullable ScheduledFuture<?> refreshTask;
  69     private @Nullable SyndFeed currentFeedState;
  70     private long lastRefreshTime;
  71
  72     public FeedHandler(Thing thing) {
  73         super(thing);
  74     }
  75
  76     @Override
  77     public void initialize() {
  78         if (checkConfiguration()) {
  79             updateStatus(ThingStatus.UNKNOWN);
  80             startAutomaticRefresh();
  81         }
  82     }
  83
  84     /**
  85      * This method checks if the provided configuration is valid.
  86      * When invalid parameter is found, default value is assigned.
  87      */
  88     private boolean checkConfiguration() {
  89         logger.debug("Start reading Feed Thing configuration.");
  90         Configuration configuration = getConfig();
  91
  92         // It is not necessary to check if the URL is valid, this will be done in fetchFeedData() method
  93         String urlString = (String) configuration.get(URL);
  94         try {
  95             url = new URL(urlString);
  96         } catch (MalformedURLException e) {
  97             logger.warn("Url '{}' is not valid: ", urlString, e);
  98             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR, e.getMessage());
  99             return false;
 100         }
 101
 102         BigDecimal localRefreshTime = null;
 103         try {
 104             localRefreshTime = (BigDecimal) configuration.get(REFRESH_TIME);
 105             if (localRefreshTime.intValue() <= 0) {
 106                 throw new IllegalArgumentException("Refresh time must be positive number!");
 107             }
 108             refreshTime = localRefreshTime.longValue();
 109         } catch (Exception e) {
 110             logger.warn("Refresh time [{}] is not valid. Falling back to default value: {}. {}", localRefreshTime,
 111                     DEFAULT_REFRESH_TIME, e.getMessage());
 112             refreshTime = DEFAULT_REFRESH_TIME;
 113         }
 114         return true;
 115     }
 116
 117     private void startAutomaticRefresh() {
 118         refreshTask = scheduler.scheduleWithFixedDelay(this::refreshFeedState, 0, refreshTime, TimeUnit.MINUTES);
 119         logger.debug("Start automatic refresh at {} minutes!", refreshTime);
 120     }
 121
 122     private void refreshFeedState() {
 123         SyndFeed feed = fetchFeedData();
 124         boolean feedUpdated = updateFeedIfChanged(feed);
 125         if (feedUpdated) {
 126             getThing().getChannels().forEach(channel -> publishChannelIfLinked(channel.getUID()));
 127         }
 128     }
 129
 130     private void publishChannelIfLinked(ChannelUID channelUID) {
 131         String channelID = channelUID.getId();
 132
 133         SyndFeed feedState = currentFeedState;
 134         if (feedState == null) {
 135             // This will happen if the binding could not download data from the server
 136             logger.trace("Cannot update channel with ID {}; no data has been downloaded from the server!", channelID);
 137             return;
 138         }
 139
 140         if (!isLinked(channelUID)) {
 141             logger.trace("Cannot update channel with ID {}; not linked!", channelID);
 142             return;
 143         }
 144
 145         State state = null;
 146         SyndEntry latestEntry = getLatestEntry(feedState);
 147
 148         switch (channelID) {
 149             case CHANNEL_LATEST_TITLE:
 150                 if (latestEntry == null || latestEntry.getTitle() == null) {
 151                     state = UnDefType.UNDEF;
 152                 } else {
 153                     String title = latestEntry.getTitle();
 154                     state = new StringType(getValueSafely(title));
 155                 }
 156                 break;
 157             case CHANNEL_LATEST_DESCRIPTION:
 158                 if (latestEntry == null || latestEntry.getDescription() == null) {
 159                     state = UnDefType.UNDEF;
 160                 } else {
 161                     String description = latestEntry.getDescription().getValue();
 162                     state = new StringType(getValueSafely(description));
 163                 }
 164                 break;
 165             case CHANNEL_LATEST_PUBLISHED_DATE:
 166             case CHANNEL_LAST_UPDATE:
 167                 if (latestEntry == null || latestEntry.getPublishedDate() == null) {
 168                     logger.debug("Cannot update date channel. No date found in feed.");
 169                     return;
 170                 } else {
 171                     Date date = latestEntry.getPublishedDate();
 172                     ZonedDateTime zdt = ZonedDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
 173                     state = new DateTimeType(zdt);
 174                 }
 175                 break;
 176             case CHANNEL_AUTHOR:
 177                 String author = feedState.getAuthor();
 178                 state = new StringType(getValueSafely(author));
 179                 break;
 180             case CHANNEL_DESCRIPTION:
 181                 String channelDescription = feedState.getDescription();
 182                 state = new StringType(getValueSafely(channelDescription));
 183                 break;
 184             case CHANNEL_TITLE:
 185                 String channelTitle = feedState.getTitle();
 186                 state = new StringType(getValueSafely(channelTitle));
 187                 break;
 188             case CHANNEL_NUMBER_OF_ENTRIES:
 189                 int numberOfEntries = feedState.getEntries().size();
 190                 state = new DecimalType(numberOfEntries);
 191                 break;
 192             default:
 193                 logger.debug("Unrecognized channel: {}", channelID);
 194         }
 195
 196         if (state != null) {
 197             updateState(channelID, state);
 198         } else {
 199             logger.debug("Cannot update channel with ID {}; state not defined!", channelID);
 200         }
 201     }
 202
 203     /**
 204      * This method updates the {@link #currentFeedState}, only if there are changes on the server, since the last check.
 205      * It compares the content on the server with the local
 206      * stored {@link #currentFeedState} in the {@link FeedHandler}.
 207      *
 208      * @return <code>true</code> if new content is available on the server since the last update or <code>false</code>
 209      *         otherwise
 210      */
 211     private synchronized boolean updateFeedIfChanged(@Nullable SyndFeed newFeedState) {
 212         // SyndFeed class has implementation of equals ()
 213         if (newFeedState != null && !newFeedState.equals(currentFeedState)) {
 214             currentFeedState = newFeedState;
 215             logger.debug("New content available!");
 216             return true;
 217         }
 218         logger.debug("Feed content has not changed!");
 219         return false;
 220     }
 221
 222     /**
 223      * This method tries to make connection with the server and fetch data from the feed.
 224      * The status of the feed thing is set to {@link ThingStatus#ONLINE}, if the fetching was successful.
 225      * Otherwise the status will be set to {@link ThingStatus#OFFLINE} with
 226      * {@link ThingStatusDetail#CONFIGURATION_ERROR} or
 227      * {@link ThingStatusDetail#COMMUNICATION_ERROR} and adequate message.
 228      *
 229      * @return {@link SyndFeed} instance with the feed data, if the connection attempt was successful and
 230      *         <code>null</code> otherwise
 231      */
 232     private @Nullable SyndFeed fetchFeedData() {
 233         URL localUrl = url;
 234         if (localUrl == null) {
 235             logger.trace("Url '{}' is not valid: ", localUrl);
 236             return null;
 237         }
 238
 239         try {
 240             URLConnection connection = localUrl.openConnection();
 241             connection.setRequestProperty("Accept-Encoding", "gzip");
 242
 243             BufferedReader in = null;
 244             if ("gzip".equals(connection.getContentEncoding())) {
 245                 in = new BufferedReader(new InputStreamReader(new GZIPInputStream(connection.getInputStream())));
 246             } else {
 247                 in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
 248             }
 249
 250             SyndFeedInput input = new SyndFeedInput();
 251             SyndFeed feed = input.build(in);
 252             in.close();
 253
 254             if (this.thing.getStatus() != ThingStatus.ONLINE) {
 255                 updateStatus(ThingStatus.ONLINE);
 256             }
 257
 258             return feed;
 259         } catch (IOException e) {
 260             logger.warn("Error accessing feed: {}", localUrl, e);
 261             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
 262             return null;
 263         } catch (IllegalArgumentException e) {
 264             logger.warn("Feed URL is null: {} ", localUrl, e);
 265             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR, e.getMessage());
 266             return null;
 267         } catch (FeedException e) {
 268             logger.warn("Feed content is not valid: {} ", localUrl, e);
 269             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR, e.getMessage());
 270             return null;
 271         }
 272     }
 273
 274     /**
 275      * Returns the most recent entry or null, if no entries are found.
 276      */
 277     private @Nullable SyndEntry getLatestEntry(SyndFeed feed) {
 278         List<SyndEntry> allEntries = feed.getEntries();
 279         if (!allEntries.isEmpty()) {
 280             /*
 281              * The entries are stored in the SyndFeed object in the following order -
 282              * the newest entry has index 0. The order is determined from the time the entry was posted, not the
 283              * published time of the entry.
 284              */
 285             return allEntries.get(0);
 286         } else {
 287             logger.debug("No entries found");
 288         }
 289         return null;
 290     }
 291
 292     @Override
 293     public void handleCommand(ChannelUID channelUID, Command command) {
 294         if (command instanceof RefreshType) {
 295             // safeguard for multiple REFRESH commands for different channels in a row
 296             if (isMinimumRefreshTimeExceeded()) {
 297                 SyndFeed feed = fetchFeedData();
 298                 updateFeedIfChanged(feed);
 299             }
 300             publishChannelIfLinked(channelUID);
 301         } else {
 302             logger.debug("Command {} is not supported for channel: {}. Supported command: REFRESH", command,
 303                     channelUID.getId());
 304         }
 305     }
 306
 307     @Override
 308     public void dispose() {
 309         if (refreshTask != null) {
 310             refreshTask.cancel(true);
 311         }
 312         lastRefreshTime = 0;
 313     }
 314
 315     private boolean isMinimumRefreshTimeExceeded() {
 316         long currentTime = System.currentTimeMillis();
 317         long timeSinceLastRefresh = currentTime - lastRefreshTime;
 318         if (timeSinceLastRefresh < MINIMUM_REFRESH_TIME) {
 319             return false;
 320         }
 321         lastRefreshTime = currentTime;
 322         return true;
 323     }
 324
 325     public String getValueSafely(@Nullable String value) {
 326         return value == null ? "" : value;
 327     }
 328 }