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

   1 /**
   2  * Copyright (c) 2010-2022 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.chromecast.internal;
  14
  15 import static org.openhab.binding.chromecast.internal.ChromecastBindingConstants.*;
  16 import static su.litvak.chromecast.api.v2.MediaStatus.PlayerState.*;
  17
  18 import java.io.IOException;
  19 import java.time.Instant;
  20 import java.time.ZoneId;
  21 import java.time.ZonedDateTime;
  22 import java.util.Collections;
  23 import java.util.List;
  24 import java.util.Map;
  25
  26 import org.eclipse.jdt.annotation.NonNullByDefault;
  27 import org.eclipse.jdt.annotation.Nullable;
  28 import org.openhab.binding.chromecast.internal.handler.ChromecastHandler;
  29 import org.openhab.core.cache.ByteArrayFileCache;
  30 import org.openhab.core.io.net.http.HttpUtil;
  31 import org.openhab.core.library.types.DateTimeType;
  32 import org.openhab.core.library.types.DecimalType;
  33 import org.openhab.core.library.types.OnOffType;
  34 import org.openhab.core.library.types.PercentType;
  35 import org.openhab.core.library.types.PlayPauseType;
  36 import org.openhab.core.library.types.PointType;
  37 import org.openhab.core.library.types.QuantityType;
  38 import org.openhab.core.library.types.RawType;
  39 import org.openhab.core.library.types.StringType;
  40 import org.openhab.core.library.unit.Units;
  41 import org.openhab.core.thing.ChannelUID;
  42 import org.openhab.core.thing.Thing;
  43 import org.openhab.core.thing.ThingStatus;
  44 import org.openhab.core.thing.ThingStatusDetail;
  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 su.litvak.chromecast.api.v2.Application;
  51 import su.litvak.chromecast.api.v2.Media;
  52 import su.litvak.chromecast.api.v2.MediaStatus;
  53 import su.litvak.chromecast.api.v2.Status;
  54 import su.litvak.chromecast.api.v2.Volume;
  55
  56 /**
  57  * Responsible for updating the Thing status based on messages received from a ChromeCast. This doesn't query anything -
  58  * it just parses the messages and updates the Thing. Message handling/scheduling/receiving is done elsewhere.
  59  * <p>
  60  * This also maintains state of both volume and the appSessionId (only if we started playing media).
  61  *
  62  * @author Jason Holmes - Initial contribution
  63  */
  64 @NonNullByDefault
  65 public class ChromecastStatusUpdater {
  66
  67     private final Logger logger = LoggerFactory.getLogger(ChromecastStatusUpdater.class);
  68
  69     private final Thing thing;
  70     private final ChromecastHandler callback;
  71     private static final ByteArrayFileCache IMAGE_CACHE = new ByteArrayFileCache("org.openhab.binding.chromecast");
  72
  73     private @Nullable String appSessionId;
  74     private PercentType volume = PercentType.ZERO;
  75
  76     // Null is valid value for last duration
  77     private @Nullable Double lastDuration = null;
  78
  79     public ChromecastStatusUpdater(Thing thing, ChromecastHandler callback) {
  80         this.thing = thing;
  81         this.callback = callback;
  82     }
  83
  84     public PercentType getVolume() {
  85         return volume;
  86     }
  87
  88     public @Nullable Double getLastDuration() {
  89         return lastDuration;
  90     }
  91
  92     public @Nullable String getAppSessionId() {
  93         return appSessionId;
  94     }
  95
  96     public void setAppSessionId(String appSessionId) {
  97         this.appSessionId = appSessionId;
  98     }
  99
 100     public void processStatusUpdate(final @Nullable Status status) {
 101         if (status == null) {
 102             updateStatus(ThingStatus.OFFLINE);
 103             updateAppStatus(null);
 104             updateVolumeStatus(null);
 105             return;
 106         }
 107
 108         if (status.applications == null) {
 109             this.appSessionId = null;
 110         }
 111
 112         updateStatus(ThingStatus.ONLINE);
 113         updateAppStatus(status.getRunningApp());
 114         updateVolumeStatus(status.volume);
 115     }
 116
 117     public void updateAppStatus(final @Nullable Application application) {
 118         State name = UnDefType.UNDEF;
 119         State id = UnDefType.UNDEF;
 120         State statusText = UnDefType.UNDEF;
 121         OnOffType idling = OnOffType.ON;
 122
 123         if (application != null) {
 124             name = new StringType(application.name);
 125             id = new StringType(application.id);
 126             statusText = new StringType(application.statusText);
 127             idling = application.isIdleScreen ? OnOffType.ON : OnOffType.OFF;
 128         }
 129
 130         callback.updateState(CHANNEL_APP_NAME, name);
 131         callback.updateState(CHANNEL_APP_ID, id);
 132         callback.updateState(CHANNEL_STATUS_TEXT, statusText);
 133         callback.updateState(CHANNEL_IDLING, idling);
 134     }
 135
 136     public void updateVolumeStatus(final @Nullable Volume volume) {
 137         if (volume == null) {
 138             return;
 139         }
 140
 141         PercentType value = new PercentType((int) (volume.level * 100));
 142         this.volume = value;
 143
 144         callback.updateState(CHANNEL_VOLUME, value);
 145         callback.updateState(CHANNEL_MUTE, volume.muted ? OnOffType.ON : OnOffType.OFF);
 146     }
 147
 148     public void updateMediaStatus(final @Nullable MediaStatus mediaStatus) {
 149         logger.debug("MEDIA_STATUS {}", mediaStatus);
 150
 151         // In-between songs? It's thinking? It's not doing anything
 152         if (mediaStatus == null) {
 153             callback.updateState(CHANNEL_CONTROL, PlayPauseType.PAUSE);
 154             callback.updateState(CHANNEL_STOP, OnOffType.ON);
 155             callback.updateState(CHANNEL_CURRENT_TIME, UnDefType.UNDEF);
 156             updateMediaInfoStatus(null);
 157             return;
 158         }
 159
 160         switch (mediaStatus.playerState) {
 161             case IDLE:
 162                 break;
 163             case PAUSED:
 164                 callback.updateState(CHANNEL_CONTROL, PlayPauseType.PAUSE);
 165                 callback.updateState(CHANNEL_STOP, OnOffType.OFF);
 166                 break;
 167             case BUFFERING:
 168             case LOADING:
 169             case PLAYING:
 170                 callback.updateState(CHANNEL_CONTROL, PlayPauseType.PLAY);
 171                 callback.updateState(CHANNEL_STOP, OnOffType.OFF);
 172                 break;
 173             default:
 174                 logger.debug("Unknown media status: {}", mediaStatus.playerState);
 175                 break;
 176         }
 177
 178         callback.updateState(CHANNEL_CURRENT_TIME, new QuantityType<>(mediaStatus.currentTime, Units.SECOND));
 179
 180         // If we're playing, paused or buffering but don't have any MEDIA information don't null everything out.
 181         Media media = mediaStatus.media;
 182         if (media == null && (mediaStatus.playerState == PLAYING || mediaStatus.playerState == PAUSED
 183                 || mediaStatus.playerState == BUFFERING)) {
 184             return;
 185         }
 186
 187         updateMediaInfoStatus(media);
 188     }
 189
 190     private void updateMediaInfoStatus(final @Nullable Media media) {
 191         State duration = UnDefType.UNDEF;
 192         String metadataType = Media.MetadataType.GENERIC.name();
 193         if (media != null) {
 194             metadataType = media.getMetadataType().name();
 195
 196             lastDuration = media.duration;
 197             // duration can be null when a new song is about to play.
 198             if (media.duration != null) {
 199                 duration = new QuantityType<>(media.duration, Units.SECOND);
 200             }
 201         }
 202
 203         callback.updateState(CHANNEL_DURATION, duration);
 204         callback.updateState(CHANNEL_METADATA_TYPE, new StringType(metadataType));
 205
 206         updateMetadataStatus(media == null || media.metadata == null ? Collections.emptyMap() : media.metadata);
 207     }
 208
 209     private void updateMetadataStatus(Map<String, Object> metadata) {
 210         updateLocation(metadata);
 211         updateImage(metadata);
 212
 213         thing.getChannels().stream() //
 214                 .map(channel -> channel.getUID())
 215                 .filter(channelUID -> METADATA_SIMPLE_CHANNELS.contains(channelUID.getId()))
 216                 .forEach(channelUID -> updateChannel(channelUID, metadata));
 217     }
 218
 219     /** Lat/lon are combined into 1 channel so we have to handle them as a special case. */
 220     private void updateLocation(Map<String, Object> metadata) {
 221         if (!callback.isLinked(CHANNEL_LOCATION)) {
 222             return;
 223         }
 224
 225         Double lat = (Double) metadata.get(LOCATION_METADATA_LATITUDE);
 226         Double lon = (Double) metadata.get(LOCATION_METADATA_LONGITUDE);
 227         if (lat == null || lon == null) {
 228             callback.updateState(CHANNEL_LOCATION, UnDefType.UNDEF);
 229         } else {
 230             PointType pointType = new PointType(new DecimalType(lat), new DecimalType(lon));
 231             callback.updateState(CHANNEL_LOCATION, pointType);
 232         }
 233     }
 234
 235     private void updateImage(Map<String, Object> metadata) {
 236         if (!(callback.isLinked(CHANNEL_IMAGE) || (callback.isLinked(CHANNEL_IMAGE_SRC)))) {
 237             return;
 238         }
 239
 240         // Channel name and metadata key don't match.
 241         Object imagesValue = metadata.get("images");
 242         if (imagesValue == null) {
 243             callback.updateState(CHANNEL_IMAGE_SRC, UnDefType.UNDEF);
 244             return;
 245         }
 246
 247         String imageSrc = null;
 248         @SuppressWarnings("unchecked")
 249         List<Map<String, String>> strings = (List<Map<String, String>>) imagesValue;
 250         for (Map<String, String> stringMap : strings) {
 251             String url = stringMap.get("url");
 252             if (url != null) {
 253                 imageSrc = url;
 254                 break;
 255             }
 256         }
 257
 258         if (callback.isLinked(CHANNEL_IMAGE_SRC)) {
 259             callback.updateState(CHANNEL_IMAGE_SRC, imageSrc == null ? UnDefType.UNDEF : new StringType(imageSrc));
 260         }
 261
 262         if (callback.isLinked(CHANNEL_IMAGE)) {
 263             State image = imageSrc == null ? UnDefType.UNDEF : downloadImageFromCache(imageSrc);
 264             callback.updateState(CHANNEL_IMAGE, image == null ? UnDefType.UNDEF : image);
 265         }
 266     }
 267
 268     private @Nullable RawType downloadImage(String url) {
 269         logger.debug("Trying to download the content of URL '{}'", url);
 270         try {
 271             RawType downloadedImage = HttpUtil.downloadImage(url);
 272             if (downloadedImage == null) {
 273                 logger.debug("Failed to download the content of URL '{}'", url);
 274             }
 275             return downloadedImage;
 276         } catch (IllegalArgumentException e) {
 277             // we catch this exception to avoid confusion errors in the log file
 278             // see https://github.com/openhab/openhab-core/issues/2494#issuecomment-970162025
 279         }
 280         return null;
 281     }
 282
 283     private @Nullable RawType downloadImageFromCache(String url) {
 284         if (IMAGE_CACHE.containsKey(url)) {
 285             try {
 286                 byte[] bytes = IMAGE_CACHE.get(url);
 287                 String contentType = HttpUtil.guessContentTypeFromData(bytes);
 288                 return new RawType(bytes,
 289                         contentType == null || contentType.isEmpty() ? RawType.DEFAULT_MIME_TYPE : contentType);
 290             } catch (IOException e) {
 291                 logger.trace("Failed to download the content of URL '{}'", url, e);
 292             }
 293         } else {
 294             RawType image = downloadImage(url);
 295             if (image != null) {
 296                 IMAGE_CACHE.put(url, image.getBytes());
 297                 return image;
 298             }
 299         }
 300         return null;
 301     }
 302
 303     private void updateChannel(ChannelUID channelUID, Map<String, Object> metadata) {
 304         if (!callback.isLinked(channelUID)) {
 305             return;
 306         }
 307
 308         Object value = getValue(channelUID.getId(), metadata);
 309         State state;
 310
 311         if (value == null) {
 312             state = UnDefType.UNDEF;
 313         } else if (value instanceof Double) {
 314             state = new DecimalType((Double) value);
 315         } else if (value instanceof Integer) {
 316             state = new DecimalType(((Integer) value).longValue());
 317         } else if (value instanceof String) {
 318             state = new StringType(value.toString());
 319         } else if (value instanceof ZonedDateTime) {
 320             state = new DateTimeType((ZonedDateTime) value);
 321         } else {
 322             state = UnDefType.UNDEF;
 323             logger.warn("Update channel {}: Unsupported value type {}", channelUID, value.getClass().getSimpleName());
 324         }
 325
 326         callback.updateState(channelUID, state);
 327     }
 328
 329     private @Nullable Object getValue(String channelId, @Nullable Map<String, Object> metadata) {
 330         if (metadata == null) {
 331             return null;
 332         }
 333
 334         if (CHANNEL_BROADCAST_DATE.equals(channelId) || CHANNEL_RELEASE_DATE.equals(channelId)
 335                 || CHANNEL_CREATION_DATE.equals(channelId)) {
 336             String dateString = (String) metadata.get(channelId);
 337             return (dateString == null) ? null
 338                     : ZonedDateTime.ofInstant(Instant.parse(dateString), ZoneId.systemDefault());
 339         }
 340
 341         return metadata.get(channelId);
 342     }
 343
 344     public void updateStatus(ThingStatus status) {
 345         updateStatus(status, ThingStatusDetail.NONE, null);
 346     }
 347
 348     public void updateStatus(ThingStatus status, ThingStatusDetail statusDetail, @Nullable String description) {
 349         callback.updateStatus(status, statusDetail, description);
 350     }
 351 }