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.amazonechocontrol.internal.handler;
  14
  15 import static org.openhab.binding.amazonechocontrol.internal.AmazonEchoControlBindingConstants.*;
  16
  17 import java.io.IOException;
  18 import java.net.URISyntaxException;
  19 import java.time.Instant;
  20 import java.time.ZoneId;
  21 import java.time.ZonedDateTime;
  22 import java.time.format.DateTimeFormatter;
  23 import java.time.temporal.ChronoUnit;
  24 import java.util.ArrayList;
  25 import java.util.HashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Objects;
  29 import java.util.Set;
  30 import java.util.concurrent.ScheduledFuture;
  31 import java.util.concurrent.TimeUnit;
  32
  33 import org.eclipse.jdt.annotation.NonNullByDefault;
  34 import org.eclipse.jdt.annotation.Nullable;
  35 import org.openhab.binding.amazonechocontrol.internal.Connection;
  36 import org.openhab.binding.amazonechocontrol.internal.ConnectionException;
  37 import org.openhab.binding.amazonechocontrol.internal.HttpException;
  38 import org.openhab.binding.amazonechocontrol.internal.channelhandler.ChannelHandler;
  39 import org.openhab.binding.amazonechocontrol.internal.channelhandler.ChannelHandlerAnnouncement;
  40 import org.openhab.binding.amazonechocontrol.internal.channelhandler.IEchoThingHandler;
  41 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonActivities.Activity;
  42 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonActivities.Activity.Description;
  43 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonAscendingAlarm.AscendingAlarmModel;
  44 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonBluetoothStates;
  45 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonBluetoothStates.BluetoothState;
  46 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonBluetoothStates.PairedDevice;
  47 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonCommandPayloadPushNotificationChange;
  48 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonCommandPayloadPushVolumeChange;
  49 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonDeviceNotificationState.DeviceNotificationState;
  50 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonDevices.Device;
  51 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonEqualizer;
  52 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonMediaState;
  53 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonMediaState.QueueEntry;
  54 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonMusicProvider;
  55 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonNotificationResponse;
  56 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonNotificationSound;
  57 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState;
  58 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState.PlayerInfo;
  59 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState.PlayerInfo.InfoText;
  60 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState.PlayerInfo.MainArt;
  61 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState.PlayerInfo.Progress;
  62 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState.PlayerInfo.Provider;
  63 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlayerState.PlayerInfo.Volume;
  64 import org.openhab.binding.amazonechocontrol.internal.jsons.JsonPlaylists;
  65 import org.openhab.core.library.types.DateTimeType;
  66 import org.openhab.core.library.types.DecimalType;
  67 import org.openhab.core.library.types.IncreaseDecreaseType;
  68 import org.openhab.core.library.types.NextPreviousType;
  69 import org.openhab.core.library.types.OnOffType;
  70 import org.openhab.core.library.types.PercentType;
  71 import org.openhab.core.library.types.PlayPauseType;
  72 import org.openhab.core.library.types.QuantityType;
  73 import org.openhab.core.library.types.RewindFastforwardType;
  74 import org.openhab.core.library.types.StringType;
  75 import org.openhab.core.library.unit.Units;
  76 import org.openhab.core.thing.Bridge;
  77 import org.openhab.core.thing.ChannelUID;
  78 import org.openhab.core.thing.Thing;
  79 import org.openhab.core.thing.ThingStatus;
  80 import org.openhab.core.thing.ThingUID;
  81 import org.openhab.core.thing.binding.BaseThingHandler;
  82 import org.openhab.core.types.Command;
  83 import org.openhab.core.types.RefreshType;
  84 import org.openhab.core.types.State;
  85 import org.openhab.core.types.UnDefType;
  86 import org.slf4j.Logger;
  87 import org.slf4j.LoggerFactory;
  88
  89 import com.google.gson.Gson;
  90
  91 /**
  92  * The {@link EchoHandler} is responsible for the handling of the echo device
  93  *
  94  * @author Michael Geramb - Initial contribution
  95  */
  96 @NonNullByDefault
  97 public class EchoHandler extends BaseThingHandler implements IEchoThingHandler {
  98     private final Logger logger = LoggerFactory.getLogger(EchoHandler.class);
  99     private Gson gson;
 100     private @Nullable Device device;
 101     private Set<String> capabilities = new HashSet<>();
 102     private @Nullable AccountHandler account;
 103     private @Nullable ScheduledFuture<?> updateStateJob;
 104     private @Nullable ScheduledFuture<?> updateProgressJob;
 105     private Object progressLock = new Object();
 106     private @Nullable String wakeWord;
 107     private @Nullable String lastKnownRadioStationId;
 108     private @Nullable String lastKnownBluetoothMAC;
 109     private @Nullable String lastKnownAmazonMusicId;
 110     private String musicProviderId = "TUNEIN";
 111     private boolean isPlaying = false;
 112     private boolean isPaused = false;
 113     private int lastKnownVolume = 25;
 114     private int textToSpeechVolume = 0;
 115     private @Nullable JsonEqualizer lastKnownEqualizer = null;
 116     private @Nullable BluetoothState bluetoothState;
 117     private boolean disableUpdate = false;
 118     private boolean updateRemind = true;
 119     private boolean updateTextToSpeech = true;
 120     private boolean updateTextCommand = true;
 121     private boolean updateAlarm = true;
 122     private boolean updateRoutine = true;
 123     private boolean updatePlayMusicVoiceCommand = true;
 124     private boolean updateStartCommand = true;
 125     private @Nullable Integer notificationVolumeLevel;
 126     private @Nullable Boolean ascendingAlarm;
 127     private @Nullable JsonPlaylists playLists;
 128     private List<JsonNotificationSound> alarmSounds = List.of();
 129     private List<JsonMusicProvider> musicProviders = List.of();
 130     private List<ChannelHandler> channelHandlers = new ArrayList<>();
 131
 132     private @Nullable JsonNotificationResponse currentNotification;
 133     private @Nullable ScheduledFuture<?> currentNotifcationUpdateTimer;
 134     long mediaLengthMs;
 135     long mediaProgressMs;
 136     long mediaStartMs;
 137     String lastSpokenText = "";
 138
 139     public EchoHandler(Thing thing, Gson gson) {
 140         super(thing);
 141         this.gson = gson;
 142         channelHandlers.add(new ChannelHandlerAnnouncement(this, this.gson));
 143     }
 144
 145     @Override
 146     public void initialize() {
 147         logger.debug("Amazon Echo Control Binding initialized");
 148         Bridge bridge = this.getBridge();
 149         if (bridge != null) {
 150             AccountHandler account = (AccountHandler) bridge.getHandler();
 151             if (account != null) {
 152                 setDeviceAndUpdateThingState(account, this.device, null);
 153                 account.addEchoHandler(this);
 154             }
 155         }
 156     }
 157
 158     public boolean setDeviceAndUpdateThingState(AccountHandler accountHandler, @Nullable Device device,
 159             @Nullable String wakeWord) {
 160         this.account = accountHandler;
 161         if (wakeWord != null) {
 162             this.wakeWord = wakeWord;
 163         }
 164         if (device == null) {
 165             updateStatus(ThingStatus.UNKNOWN);
 166             return false;
 167         }
 168         this.device = device;
 169         this.capabilities = device.getCapabilities();
 170         if (!device.online) {
 171             updateStatus(ThingStatus.OFFLINE);
 172             return false;
 173         }
 174         updateStatus(ThingStatus.ONLINE);
 175         return true;
 176     }
 177
 178     @Override
 179     public void dispose() {
 180         stopCurrentNotification();
 181         ScheduledFuture<?> updateStateJob = this.updateStateJob;
 182         this.updateStateJob = null;
 183         if (updateStateJob != null) {
 184             this.disableUpdate = false;
 185             updateStateJob.cancel(false);
 186         }
 187         stopProgressTimer();
 188         super.dispose();
 189     }
 190
 191     private void stopProgressTimer() {
 192         ScheduledFuture<?> updateProgressJob = this.updateProgressJob;
 193         this.updateProgressJob = null;
 194         if (updateProgressJob != null) {
 195             updateProgressJob.cancel(false);
 196         }
 197     }
 198
 199     public @Nullable BluetoothState findBluetoothState() {
 200         return this.bluetoothState;
 201     }
 202
 203     public @Nullable JsonPlaylists findPlaylists() {
 204         return this.playLists;
 205     }
 206
 207     public List<JsonNotificationSound> findAlarmSounds() {
 208         return this.alarmSounds;
 209     }
 210
 211     public List<JsonMusicProvider> findMusicProviders() {
 212         return this.musicProviders;
 213     }
 214
 215     private @Nullable Connection findConnection() {
 216         AccountHandler accountHandler = this.account;
 217         if (accountHandler != null) {
 218             return accountHandler.findConnection();
 219         }
 220         return null;
 221     }
 222
 223     public @Nullable AccountHandler findAccount() {
 224         return this.account;
 225     }
 226
 227     public @Nullable Device findDevice() {
 228         return this.device;
 229     }
 230
 231     public String findSerialNumber() {
 232         String id = (String) getConfig().get(DEVICE_PROPERTY_SERIAL_NUMBER);
 233         if (id == null) {
 234             return "";
 235         }
 236         return id;
 237     }
 238
 239     @Override
 240     public void handleCommand(ChannelUID channelUID, Command command) {
 241         try {
 242             logger.trace("Command '{}' received for channel '{}'", command, channelUID);
 243             int waitForUpdate = 1000;
 244             boolean needBluetoothRefresh = false;
 245             String lastKnownBluetoothMAC = this.lastKnownBluetoothMAC;
 246
 247             ScheduledFuture<?> updateStateJob = this.updateStateJob;
 248             this.updateStateJob = null;
 249             if (updateStateJob != null) {
 250                 this.disableUpdate = false;
 251                 updateStateJob.cancel(false);
 252             }
 253             AccountHandler account = this.account;
 254             if (account == null) {
 255                 return;
 256             }
 257             Connection connection = account.findConnection();
 258             if (connection == null) {
 259                 return;
 260             }
 261             Device device = this.device;
 262             if (device == null) {
 263                 return;
 264             }
 265
 266             String channelId = channelUID.getId();
 267             for (ChannelHandler channelHandler : channelHandlers) {
 268                 if (channelHandler.tryHandleCommand(device, connection, channelId, command)) {
 269                     return;
 270                 }
 271             }
 272
 273             // Player commands
 274             if (channelId.equals(CHANNEL_PLAYER)) {
 275                 if (command == PlayPauseType.PAUSE || command == OnOffType.OFF) {
 276                     connection.command(device, "{\"type\":\"PauseCommand\"}");
 277                 } else if (command == PlayPauseType.PLAY || command == OnOffType.ON) {
 278                     if (isPaused) {
 279                         connection.command(device, "{\"type\":\"PlayCommand\"}");
 280                     } else {
 281                         connection.playMusicVoiceCommand(device, this.musicProviderId, "!");
 282                         waitForUpdate = 3000;
 283                     }
 284                 } else if (command == NextPreviousType.NEXT) {
 285                     connection.command(device, "{\"type\":\"NextCommand\"}");
 286                 } else if (command == NextPreviousType.PREVIOUS) {
 287                     connection.command(device, "{\"type\":\"PreviousCommand\"}");
 288                 } else if (command == RewindFastforwardType.FASTFORWARD) {
 289                     connection.command(device, "{\"type\":\"ForwardCommand\"}");
 290                 } else if (command == RewindFastforwardType.REWIND) {
 291                     connection.command(device, "{\"type\":\"RewindCommand\"}");
 292                 }
 293             }
 294             // Notification commands
 295             if (channelId.equals(CHANNEL_NOTIFICATION_VOLUME)) {
 296                 if (command instanceof PercentType percentCommand) {
 297                     int volume = percentCommand.intValue();
 298                     connection.notificationVolume(device, volume);
 299                     this.notificationVolumeLevel = volume;
 300                     waitForUpdate = -1;
 301                     account.forceCheckData();
 302                 }
 303             }
 304             if (channelId.equals(CHANNEL_ASCENDING_ALARM)) {
 305                 if (command == OnOffType.OFF) {
 306                     connection.ascendingAlarm(device, false);
 307                     this.ascendingAlarm = false;
 308                     waitForUpdate = -1;
 309                     account.forceCheckData();
 310                 }
 311                 if (command == OnOffType.ON) {
 312                     connection.ascendingAlarm(device, true);
 313                     this.ascendingAlarm = true;
 314                     waitForUpdate = -1;
 315                     account.forceCheckData();
 316                 }
 317             }
 318             // Media progress commands
 319             Long mediaPosition = null;
 320             if (channelId.equals(CHANNEL_MEDIA_PROGRESS)) {
 321                 if (command instanceof PercentType percentCommand) {
 322                     int percent = percentCommand.intValue();
 323                     mediaPosition = Math.round((mediaLengthMs / 1000d) * (percent / 100d));
 324                 }
 325             }
 326             if (channelId.equals(CHANNEL_MEDIA_PROGRESS_TIME)) {
 327                 if (command instanceof DecimalType decimalCommand) {
 328                     mediaPosition = decimalCommand.longValue();
 329                 }
 330                 if (command instanceof QuantityType<?> quantityCommand) {
 331                     @Nullable
 332                     QuantityType<?> seconds = quantityCommand.toUnit(Units.SECOND);
 333                     if (seconds != null) {
 334                         mediaPosition = seconds.longValue();
 335                     }
 336                 }
 337             }
 338             if (mediaPosition != null) {
 339                 waitForUpdate = -1;
 340                 synchronized (progressLock) {
 341                     String seekCommand = "{\"type\":\"SeekCommand\",\"mediaPosition\":" + mediaPosition
 342                             + ",\"contentFocusClientId\":null}";
 343                     connection.command(device, seekCommand);
 344                     connection.command(device, seekCommand); // Must be sent twice, the first one is ignored sometimes
 345                     this.mediaProgressMs = mediaPosition * 1000;
 346                     mediaStartMs = System.currentTimeMillis() - this.mediaProgressMs;
 347                     updateMediaProgress(false);
 348                 }
 349             }
 350             // Volume commands
 351             if (channelId.equals(CHANNEL_VOLUME)) {
 352                 Integer volume = null;
 353                 if (command instanceof PercentType percentCommand) {
 354                     volume = percentCommand.intValue();
 355                 } else if (command == OnOffType.OFF) {
 356                     volume = 0;
 357                 } else if (command == OnOffType.ON) {
 358                     volume = lastKnownVolume;
 359                 } else if (command == IncreaseDecreaseType.INCREASE) {
 360                     if (lastKnownVolume < 100) {
 361                         lastKnownVolume++;
 362                         volume = lastKnownVolume;
 363                     }
 364                 } else if (command == IncreaseDecreaseType.DECREASE) {
 365                     if (lastKnownVolume > 0) {
 366                         lastKnownVolume--;
 367                         volume = lastKnownVolume;
 368                     }
 369                 }
 370                 if (volume != null) {
 371                     if ("WHA".equals(device.deviceFamily)) {
 372                         connection.command(device, "{\"type\":\"VolumeLevelCommand\",\"volumeLevel\":" + volume
 373                                 + ",\"contentFocusClientId\":\"Default\"}");
 374                     } else {
 375                         connection.volume(device, volume);
 376                     }
 377                     lastKnownVolume = volume;
 378                     updateState(CHANNEL_VOLUME, new PercentType(lastKnownVolume));
 379                     waitForUpdate = -1;
 380                 }
 381             }
 382             // equalizer commands
 383             if (channelId.equals(CHANNEL_EQUALIZER_BASS) || channelId.equals(CHANNEL_EQUALIZER_MIDRANGE)
 384                     || channelId.equals(CHANNEL_EQUALIZER_TREBLE)) {
 385                 if (handleEqualizerCommands(channelId, command, connection, device)) {
 386                     waitForUpdate = -1;
 387                 }
 388             }
 389
 390             // shuffle command
 391             if (channelId.equals(CHANNEL_SHUFFLE)) {
 392                 if (command instanceof OnOffType value) {
 393
 394                     connection.command(device, "{\"type\":\"ShuffleCommand\",\"shuffle\":\""
 395                             + (value == OnOffType.ON ? "true" : "false") + "\"}");
 396                 }
 397             }
 398
 399             // play music command
 400             if (channelId.equals(CHANNEL_MUSIC_PROVIDER_ID)) {
 401                 if (command instanceof StringType) {
 402                     waitForUpdate = 0;
 403                     String musicProviderId = command.toFullString();
 404                     if (!musicProviderId.equals(this.musicProviderId)) {
 405                         this.musicProviderId = musicProviderId;
 406                         if (this.isPlaying) {
 407                             connection.playMusicVoiceCommand(device, this.musicProviderId, "!");
 408                             waitForUpdate = 3000;
 409                         }
 410                     }
 411                 }
 412             }
 413             if (channelId.equals(CHANNEL_PLAY_MUSIC_VOICE_COMMAND)) {
 414                 if (command instanceof StringType) {
 415                     String voiceCommand = command.toFullString();
 416                     if (!this.musicProviderId.isEmpty()) {
 417                         connection.playMusicVoiceCommand(device, this.musicProviderId, voiceCommand);
 418                         waitForUpdate = 3000;
 419                         updatePlayMusicVoiceCommand = true;
 420                     }
 421                 }
 422             }
 423
 424             // bluetooth commands
 425             if (channelId.equals(CHANNEL_BLUETOOTH_MAC)) {
 426                 needBluetoothRefresh = true;
 427                 if (command instanceof StringType stringCommand) {
 428                     String address = stringCommand.toFullString();
 429                     if (!address.isEmpty()) {
 430                         waitForUpdate = 4000;
 431                     }
 432                     connection.bluetooth(device, address);
 433                 }
 434             }
 435             if (channelId.equals(CHANNEL_BLUETOOTH)) {
 436                 needBluetoothRefresh = true;
 437                 if (command == OnOffType.ON) {
 438                     waitForUpdate = 4000;
 439                     String bluetoothId = lastKnownBluetoothMAC;
 440                     BluetoothState state = bluetoothState;
 441                     if (state != null && (bluetoothId == null || bluetoothId.isEmpty())) {
 442                         for (PairedDevice paired : state.getPairedDeviceList()) {
 443                             String pairedAddress = paired.address;
 444                             if (pairedAddress != null && !pairedAddress.isEmpty()) {
 445                                 lastKnownBluetoothMAC = pairedAddress;
 446                                 break;
 447                             }
 448                         }
 449                     }
 450                     if (lastKnownBluetoothMAC != null && !lastKnownBluetoothMAC.isEmpty()) {
 451                         connection.bluetooth(device, lastKnownBluetoothMAC);
 452                     }
 453                 } else if (command == OnOffType.OFF) {
 454                     connection.bluetooth(device, null);
 455                 }
 456             }
 457             if (channelId.equals(CHANNEL_BLUETOOTH_DEVICE_NAME)) {
 458                 needBluetoothRefresh = true;
 459             }
 460             // amazon music commands
 461             if (channelId.equals(CHANNEL_AMAZON_MUSIC_TRACK_ID)) {
 462                 if (command instanceof StringType) {
 463                     String trackId = command.toFullString();
 464                     if (!trackId.isEmpty()) {
 465                         waitForUpdate = 3000;
 466                     }
 467                     connection.playAmazonMusicTrack(device, trackId);
 468                 }
 469             }
 470             if (channelId.equals(CHANNEL_AMAZON_MUSIC_PLAY_LIST_ID)) {
 471                 if (command instanceof StringType) {
 472                     String playListId = command.toFullString();
 473                     if (!playListId.isEmpty()) {
 474                         waitForUpdate = 3000;
 475                     }
 476                     connection.playAmazonMusicPlayList(device, playListId);
 477                 }
 478             }
 479             if (channelId.equals(CHANNEL_AMAZON_MUSIC)) {
 480                 if (command == OnOffType.ON) {
 481                     String lastKnownAmazonMusicId = this.lastKnownAmazonMusicId;
 482                     if (lastKnownAmazonMusicId != null && !lastKnownAmazonMusicId.isEmpty()) {
 483                         waitForUpdate = 3000;
 484                     }
 485                     connection.playAmazonMusicTrack(device, lastKnownAmazonMusicId);
 486                 } else if (command == OnOffType.OFF) {
 487                     connection.playAmazonMusicTrack(device, "");
 488                 }
 489             }
 490
 491             // radio commands
 492             if (channelId.equals(CHANNEL_RADIO_STATION_ID)) {
 493                 if (command instanceof StringType) {
 494                     String stationId = command.toFullString();
 495                     if (!stationId.isEmpty()) {
 496                         waitForUpdate = 3000;
 497                     }
 498                     connection.playRadio(device, stationId);
 499                 }
 500             }
 501             if (channelId.equals(CHANNEL_RADIO)) {
 502                 if (command == OnOffType.ON) {
 503                     String lastKnownRadioStationId = this.lastKnownRadioStationId;
 504                     if (lastKnownRadioStationId != null && !lastKnownRadioStationId.isEmpty()) {
 505                         waitForUpdate = 3000;
 506                     }
 507                     connection.playRadio(device, lastKnownRadioStationId);
 508                 } else if (command == OnOffType.OFF) {
 509                     connection.playRadio(device, "");
 510                 }
 511             }
 512
 513             // notification
 514             if (channelId.equals(CHANNEL_REMIND)) {
 515                 if (command instanceof StringType) {
 516                     stopCurrentNotification();
 517                     String reminder = command.toFullString();
 518                     if (!reminder.isEmpty()) {
 519                         waitForUpdate = 3000;
 520                         updateRemind = true;
 521                         currentNotification = connection.notification(device, "Reminder", reminder, null);
 522                         currentNotifcationUpdateTimer = scheduler.scheduleWithFixedDelay(() -> {
 523                             updateNotificationTimerState();
 524                         }, 1, 1, TimeUnit.SECONDS);
 525                     }
 526                 }
 527             }
 528             if (channelId.equals(CHANNEL_PLAY_ALARM_SOUND)) {
 529                 if (command instanceof StringType) {
 530                     stopCurrentNotification();
 531                     String alarmSound = command.toFullString();
 532                     if (!alarmSound.isEmpty()) {
 533                         waitForUpdate = 3000;
 534                         updateAlarm = true;
 535                         String[] parts = alarmSound.split(":", 2);
 536                         JsonNotificationSound sound = new JsonNotificationSound();
 537                         if (parts.length == 2) {
 538                             sound.providerId = parts[0];
 539                             sound.id = parts[1];
 540                         } else {
 541                             sound.providerId = "ECHO";
 542                             sound.id = alarmSound;
 543                         }
 544                         currentNotification = connection.notification(device, "Alarm", null, sound);
 545                         currentNotifcationUpdateTimer = scheduler.scheduleWithFixedDelay(() -> {
 546                             updateNotificationTimerState();
 547                         }, 1, 1, TimeUnit.SECONDS);
 548                     }
 549                 }
 550             }
 551
 552             // routine commands
 553             if (channelId.equals(CHANNEL_TEXT_TO_SPEECH)) {
 554                 if (command instanceof StringType) {
 555                     String text = command.toFullString();
 556                     if (!text.isEmpty()) {
 557                         waitForUpdate = 1000;
 558                         updateTextToSpeech = true;
 559                         startTextToSpeech(connection, device, text);
 560                     }
 561                 }
 562             }
 563             if (channelId.equals(CHANNEL_TEXT_TO_SPEECH_VOLUME)) {
 564                 if (command instanceof PercentType percentCommand) {
 565                     textToSpeechVolume = percentCommand.intValue();
 566                 } else if (command == OnOffType.OFF) {
 567                     textToSpeechVolume = 0;
 568                 } else if (command == OnOffType.ON) {
 569                     textToSpeechVolume = lastKnownVolume;
 570                 } else if (command == IncreaseDecreaseType.INCREASE) {
 571                     if (textToSpeechVolume < 100) {
 572                         textToSpeechVolume++;
 573                     }
 574                 } else if (command == IncreaseDecreaseType.DECREASE) {
 575                     if (textToSpeechVolume > 0) {
 576                         textToSpeechVolume--;
 577                     }
 578                 }
 579                 this.updateState(channelId, new PercentType(textToSpeechVolume));
 580             }
 581             if (channelId.equals(CHANNEL_TEXT_COMMAND)) {
 582                 if (command instanceof StringType) {
 583                     String text = command.toFullString();
 584                     if (!text.isEmpty()) {
 585                         waitForUpdate = 1000;
 586                         updateTextCommand = true;
 587                         startTextCommand(connection, device, text);
 588                     }
 589                 }
 590             }
 591             if (channelId.equals(CHANNEL_LAST_VOICE_COMMAND)) {
 592                 if (command instanceof StringType) {
 593                     String text = command.toFullString();
 594                     if (!text.isEmpty()) {
 595                         waitForUpdate = -1;
 596                         startTextToSpeech(connection, device, text);
 597                     }
 598                 }
 599             }
 600             if (channelId.equals(CHANNEL_START_COMMAND)) {
 601                 if (command instanceof StringType) {
 602                     String commandText = command.toFullString();
 603                     if (!commandText.isEmpty()) {
 604                         updateStartCommand = true;
 605                         if (commandText.startsWith(FLASH_BRIEFING_COMMAND_PREFIX)) {
 606                             // Handle custom flashbriefings commands
 607                             String flashBriefingId = commandText.substring(FLASH_BRIEFING_COMMAND_PREFIX.length());
 608                             for (FlashBriefingProfileHandler flashBriefingHandler : account
 609                                     .getFlashBriefingProfileHandlers()) {
 610                                 ThingUID flashBriefingUid = flashBriefingHandler.getThing().getUID();
 611                                 if (flashBriefingId.equals(flashBriefingHandler.getThing().getUID().getId())) {
 612                                     flashBriefingHandler.handleCommand(
 613                                             new ChannelUID(flashBriefingUid, CHANNEL_PLAY_ON_DEVICE),
 614                                             new StringType(device.serialNumber));
 615                                     break;
 616                                 }
 617                             }
 618                         } else {
 619                             // Handle standard commands
 620                             if (!commandText.startsWith("Alexa.")) {
 621                                 commandText = "Alexa." + commandText + ".Play";
 622                             }
 623                             waitForUpdate = 1000;
 624                             connection.executeSequenceCommand(device, commandText, Map.of());
 625                         }
 626                     }
 627                 }
 628             }
 629             if (channelId.equals(CHANNEL_START_ROUTINE)) {
 630                 if (command instanceof StringType) {
 631                     String utterance = command.toFullString();
 632                     if (!utterance.isEmpty()) {
 633                         waitForUpdate = 1000;
 634                         updateRoutine = true;
 635                         connection.startRoutine(device, utterance);
 636                     }
 637                 }
 638             }
 639             if (waitForUpdate < 0) {
 640                 return;
 641             }
 642             // force update of the state
 643             this.disableUpdate = true;
 644             final boolean bluetoothRefresh = needBluetoothRefresh;
 645             Runnable doRefresh = () -> {
 646                 this.disableUpdate = false;
 647                 BluetoothState state = null;
 648                 if (bluetoothRefresh) {
 649                     JsonBluetoothStates states;
 650                     states = connection.getBluetoothConnectionStates();
 651                     if (states != null) {
 652                         state = states.findStateByDevice(device);
 653                     }
 654                 }
 655
 656                 updateState(account, device, state, null, null, null, null, null);
 657             };
 658             if (command instanceof RefreshType) {
 659                 waitForUpdate = 0;
 660                 account.forceCheckData();
 661             }
 662             if (waitForUpdate == 0) {
 663                 doRefresh.run();
 664             } else {
 665                 this.updateStateJob = scheduler.schedule(doRefresh, waitForUpdate, TimeUnit.MILLISECONDS);
 666             }
 667         } catch (IOException | URISyntaxException | InterruptedException e) {
 668             logger.info("handleCommand fails", e);
 669         }
 670     }
 671
 672     private boolean handleEqualizerCommands(String channelId, Command command, Connection connection, Device device)
 673             throws URISyntaxException {
 674         if (command instanceof RefreshType) {
 675             this.lastKnownEqualizer = null;
 676         }
 677         if (command instanceof DecimalType decimalCommand) {
 678             if (this.lastKnownEqualizer == null) {
 679                 updateEqualizerState();
 680             }
 681             JsonEqualizer lastKnownEqualizer = this.lastKnownEqualizer;
 682             if (lastKnownEqualizer != null) {
 683                 JsonEqualizer newEqualizerSetting = lastKnownEqualizer.createClone();
 684                 if (channelId.equals(CHANNEL_EQUALIZER_BASS)) {
 685                     newEqualizerSetting.bass = decimalCommand.intValue();
 686                 }
 687                 if (channelId.equals(CHANNEL_EQUALIZER_MIDRANGE)) {
 688                     newEqualizerSetting.mid = decimalCommand.intValue();
 689                 }
 690                 if (channelId.equals(CHANNEL_EQUALIZER_TREBLE)) {
 691                     newEqualizerSetting.treble = decimalCommand.intValue();
 692                 }
 693                 try {
 694                     connection.setEqualizer(device, newEqualizerSetting);
 695                     return true;
 696                 } catch (HttpException | IOException | ConnectionException | InterruptedException e) {
 697                     logger.debug("Update equalizer failed", e);
 698                     this.lastKnownEqualizer = null;
 699                 }
 700             }
 701         }
 702         return false;
 703     }
 704
 705     private void startTextToSpeech(Connection connection, Device device, String text)
 706             throws IOException, URISyntaxException {
 707         Integer volume = null;
 708         if (textToSpeechVolume != 0) {
 709             volume = textToSpeechVolume;
 710         }
 711         connection.textToSpeech(device, text, volume, lastKnownVolume);
 712     }
 713
 714     private void startTextCommand(Connection connection, Device device, String text)
 715             throws IOException, URISyntaxException {
 716         Integer volume = null;
 717         if (textToSpeechVolume != 0) {
 718             volume = textToSpeechVolume;
 719         }
 720         connection.textCommand(device, text, volume, lastKnownVolume);
 721     }
 722
 723     @Override
 724     public void startAnnouncement(Device device, String speak, String bodyText, @Nullable String title,
 725             @Nullable Integer volume) throws IOException, URISyntaxException {
 726         Connection connection = this.findConnection();
 727         if (connection == null) {
 728             return;
 729         }
 730         if (volume == null && textToSpeechVolume != 0) {
 731             volume = textToSpeechVolume;
 732         }
 733         if (volume != null && volume < 0) {
 734             volume = null; // the meaning of negative values is 'do not use'. The api requires null in this case.
 735         }
 736         connection.announcement(device, speak, bodyText, title, volume, lastKnownVolume);
 737     }
 738
 739     private void stopCurrentNotification() {
 740         ScheduledFuture<?> currentNotifcationUpdateTimer = this.currentNotifcationUpdateTimer;
 741         if (currentNotifcationUpdateTimer != null) {
 742             this.currentNotifcationUpdateTimer = null;
 743             currentNotifcationUpdateTimer.cancel(true);
 744         }
 745         JsonNotificationResponse currentNotification = this.currentNotification;
 746         if (currentNotification != null) {
 747             this.currentNotification = null;
 748             Connection currentConnection = this.findConnection();
 749             if (currentConnection != null) {
 750                 try {
 751                     currentConnection.stopNotification(currentNotification);
 752                 } catch (IOException | URISyntaxException | InterruptedException e) {
 753                     logger.warn("Stop notification failed", e);
 754                 }
 755             }
 756         }
 757     }
 758
 759     private void updateNotificationTimerState() {
 760         boolean stopCurrentNotification = true;
 761         JsonNotificationResponse currentNotification = this.currentNotification;
 762         try {
 763             if (currentNotification != null) {
 764                 Connection currentConnection = this.findConnection();
 765                 if (currentConnection != null) {
 766                     JsonNotificationResponse newState = currentConnection.getNotificationState(currentNotification);
 767                     if (newState != null && "ON".equals(newState.status)) {
 768                         stopCurrentNotification = false;
 769                     }
 770                 }
 771             }
 772         } catch (IOException | URISyntaxException | InterruptedException e) {
 773             logger.warn("update notification state fails", e);
 774         }
 775         if (stopCurrentNotification) {
 776             if (currentNotification != null) {
 777                 String type = currentNotification.type;
 778                 if (type != null) {
 779                     if ("Reminder".equals(type)) {
 780                         updateState(CHANNEL_REMIND, StringType.EMPTY);
 781                         updateRemind = false;
 782                     }
 783                     if ("Alarm".equals(type)) {
 784                         updateState(CHANNEL_PLAY_ALARM_SOUND, StringType.EMPTY);
 785                         updateAlarm = false;
 786                     }
 787                 }
 788             }
 789             stopCurrentNotification();
 790         }
 791     }
 792
 793     public void updateState(AccountHandler accountHandler, @Nullable Device device,
 794             @Nullable BluetoothState bluetoothState, @Nullable DeviceNotificationState deviceNotificationState,
 795             @Nullable AscendingAlarmModel ascendingAlarmModel, @Nullable JsonPlaylists playlists,
 796             @Nullable List<JsonNotificationSound> alarmSounds, @Nullable List<JsonMusicProvider> musicProviders) {
 797         try {
 798             this.logger.debug("Handle updateState {}", this.getThing().getUID());
 799
 800             if (deviceNotificationState != null) {
 801                 notificationVolumeLevel = deviceNotificationState.volumeLevel;
 802             }
 803             if (ascendingAlarmModel != null) {
 804                 ascendingAlarm = ascendingAlarmModel.ascendingAlarmEnabled;
 805             }
 806             if (playlists != null) {
 807                 this.playLists = playlists;
 808             }
 809             if (alarmSounds != null) {
 810                 this.alarmSounds = alarmSounds;
 811             }
 812             if (musicProviders != null) {
 813                 this.musicProviders = musicProviders;
 814             }
 815             if (!setDeviceAndUpdateThingState(accountHandler, device, null)) {
 816                 this.logger.debug("Handle updateState {} aborted: Not online", this.getThing().getUID());
 817                 return;
 818             }
 819             if (device == null) {
 820                 this.logger.debug("Handle updateState {} aborted: No device", this.getThing().getUID());
 821                 return;
 822             }
 823
 824             if (this.disableUpdate) {
 825                 this.logger.debug("Handle updateState {} aborted: Disabled", this.getThing().getUID());
 826                 return;
 827             }
 828             Connection connection = this.findConnection();
 829             if (connection == null) {
 830                 return;
 831             }
 832
 833             if (this.lastKnownEqualizer == null) {
 834                 updateEqualizerState();
 835             }
 836
 837             PlayerInfo playerInfo = null;
 838             Provider provider = null;
 839             InfoText infoText = null;
 840             MainArt mainArt = null;
 841             String musicProviderId = null;
 842             Progress progress = null;
 843             try {
 844                 JsonPlayerState playerState = connection.getPlayer(device);
 845                 if (playerState != null) {
 846                     playerInfo = playerState.playerInfo;
 847                     if (playerInfo != null) {
 848                         infoText = playerInfo.infoText;
 849                         if (infoText == null) {
 850                             infoText = playerInfo.miniInfoText;
 851                         }
 852                         mainArt = playerInfo.mainArt;
 853                         provider = playerInfo.provider;
 854                         if (provider != null) {
 855                             musicProviderId = provider.providerName;
 856                             // Map the music provider id to the one used for starting music with voice command
 857                             if (musicProviderId != null) {
 858                                 musicProviderId = musicProviderId.toUpperCase();
 859
 860                                 if ("AMAZON MUSIC".equals(musicProviderId)) {
 861                                     musicProviderId = "AMAZON_MUSIC";
 862                                 }
 863                                 if ("CLOUD_PLAYER".equals(musicProviderId)) {
 864                                     musicProviderId = "AMAZON_MUSIC";
 865                                 }
 866                                 if (musicProviderId.startsWith("TUNEIN")) {
 867                                     musicProviderId = "TUNEIN";
 868                                 }
 869                                 if (musicProviderId.startsWith("IHEARTRADIO")) {
 870                                     musicProviderId = "I_HEART_RADIO";
 871                                 }
 872                                 if ("APPLE".equals(musicProviderId) && musicProviderId.contains("MUSIC")) {
 873                                     musicProviderId = "APPLE_MUSIC";
 874                                 }
 875                             }
 876                         }
 877                         progress = playerInfo.progress;
 878                     }
 879                 }
 880             } catch (HttpException e) {
 881                 if (e.getCode() != 400) {
 882                     logger.info("getPlayer fails", e);
 883                 }
 884             } catch (IOException | URISyntaxException | InterruptedException e) {
 885                 logger.info("getPlayer fails", e);
 886             }
 887             // check playing
 888             isPlaying = (playerInfo != null && "PLAYING".equals(playerInfo.state));
 889
 890             isPaused = (playerInfo != null && "PAUSED".equals(playerInfo.state));
 891             synchronized (progressLock) {
 892                 Boolean showTime = null;
 893                 Long mediaLength = null;
 894                 Long mediaProgress = null;
 895                 if (progress != null) {
 896                     showTime = progress.showTiming;
 897                     mediaLength = progress.mediaLength;
 898                     mediaProgress = progress.mediaProgress;
 899                 }
 900                 if (showTime != null && showTime && mediaProgress != null && mediaLength != null) {
 901                     mediaProgressMs = mediaProgress * 1000;
 902                     mediaLengthMs = mediaLength * 1000;
 903                     mediaStartMs = System.currentTimeMillis() - mediaProgressMs;
 904                     if (isPlaying) {
 905                         if (updateProgressJob == null) {
 906                             updateProgressJob = scheduler.scheduleWithFixedDelay(this::updateMediaProgress, 1000, 1000,
 907                                     TimeUnit.MILLISECONDS);
 908                         }
 909                     } else {
 910                         stopProgressTimer();
 911                     }
 912                 } else {
 913                     stopProgressTimer();
 914                     mediaProgressMs = 0;
 915                     mediaStartMs = 0;
 916                     mediaLengthMs = 0;
 917                 }
 918                 updateMediaProgress(true);
 919             }
 920
 921             JsonMediaState mediaState = null;
 922             try {
 923                 if ("AMAZON_MUSIC".equalsIgnoreCase(musicProviderId) || "TUNEIN".equalsIgnoreCase(musicProviderId)) {
 924                     mediaState = connection.getMediaState(device);
 925                 }
 926             } catch (HttpException e) {
 927                 if (e.getCode() == 400) {
 928                     updateState(CHANNEL_RADIO_STATION_ID, StringType.EMPTY);
 929                 } else {
 930                     logger.info("getMediaState fails", e);
 931                 }
 932             } catch (IOException | URISyntaxException | InterruptedException e) {
 933                 logger.info("getMediaState fails", e);
 934             }
 935
 936             // handle music provider id
 937             if (provider != null && isPlaying) {
 938                 if (musicProviderId != null) {
 939                     this.musicProviderId = musicProviderId;
 940                 }
 941             }
 942
 943             // handle amazon music
 944             String amazonMusicTrackId = "";
 945             String amazonMusicPlayListId = "";
 946             boolean amazonMusic = false;
 947             if (mediaState != null) {
 948                 String contentId = mediaState.contentId;
 949                 if (isPlaying && "CLOUD_PLAYER".equals(mediaState.providerId) && contentId != null
 950                         && !contentId.isEmpty()) {
 951                     amazonMusicTrackId = contentId;
 952                     lastKnownAmazonMusicId = amazonMusicTrackId;
 953                     amazonMusic = true;
 954                 }
 955             }
 956
 957             // handle bluetooth
 958             String bluetoothMAC = "";
 959             String bluetoothDeviceName = "";
 960             boolean bluetoothIsConnected = false;
 961             if (bluetoothState != null) {
 962                 this.bluetoothState = bluetoothState;
 963                 for (PairedDevice paired : bluetoothState.getPairedDeviceList()) {
 964                     String pairedAddress = paired.address;
 965                     if (paired.connected && pairedAddress != null) {
 966                         bluetoothIsConnected = true;
 967                         bluetoothMAC = pairedAddress;
 968                         bluetoothDeviceName = paired.friendlyName;
 969                         if (bluetoothDeviceName == null || bluetoothDeviceName.isEmpty()) {
 970                             bluetoothDeviceName = pairedAddress;
 971                         }
 972                         break;
 973                     }
 974                 }
 975
 976             }
 977             if (!bluetoothMAC.isEmpty()) {
 978                 lastKnownBluetoothMAC = bluetoothMAC;
 979             }
 980
 981             // handle radio
 982             boolean isRadio = false;
 983             String radioStationId = "";
 984             if (mediaState != null) {
 985                 radioStationId = Objects.requireNonNullElse(mediaState.radioStationId, "");
 986                 if (!radioStationId.isEmpty()) {
 987                     lastKnownRadioStationId = radioStationId;
 988                     if ("TUNEIN".equalsIgnoreCase(musicProviderId)) {
 989                         isRadio = true;
 990                         if (!"PLAYING".equals(mediaState.currentState)) {
 991                             radioStationId = "";
 992                         }
 993                     }
 994                 }
 995             }
 996
 997             // handle title, subtitle, imageUrl
 998             String title = "";
 999             String subTitle1 = "";
1000             String subTitle2 = "";
1001             String imageUrl = "";
1002             if (infoText != null) {
1003                 if (infoText.title != null) {
1004                     title = infoText.title;
1005                 }
1006                 if (infoText.subText1 != null) {
1007                     subTitle1 = infoText.subText1;
1008                 }
1009
1010                 if (infoText.subText2 != null) {
1011                     subTitle2 = infoText.subText2;
1012                 }
1013             }
1014             if (mainArt != null) {
1015                 if (mainArt.url != null) {
1016                     imageUrl = mainArt.url;
1017                 }
1018             }
1019             if (mediaState != null) {
1020                 List<QueueEntry> queueEntries = Objects.requireNonNullElse(mediaState.queue, List.of());
1021                 if (!queueEntries.isEmpty()) {
1022                     QueueEntry entry = queueEntries.get(0);
1023                     if (isRadio) {
1024                         if ((imageUrl == null || imageUrl.isEmpty()) && entry.imageURL != null) {
1025                             imageUrl = entry.imageURL;
1026                         }
1027                         if ((subTitle1 == null || subTitle1.isEmpty()) && entry.radioStationSlogan != null) {
1028                             subTitle1 = entry.radioStationSlogan;
1029                         }
1030                         if ((subTitle2 == null || subTitle2.isEmpty()) && entry.radioStationLocation != null) {
1031                             subTitle2 = entry.radioStationLocation;
1032                         }
1033                     }
1034
1035                 }
1036             }
1037
1038             // handle provider
1039             String providerDisplayName = "";
1040             if (provider != null) {
1041                 if (provider.providerDisplayName != null) {
1042                     providerDisplayName = Objects.requireNonNullElse(provider.providerDisplayName, providerDisplayName);
1043                 }
1044                 String providerName = provider.providerName;
1045                 if (providerName != null && !providerName.isEmpty() && providerDisplayName.isEmpty()) {
1046                     providerDisplayName = provider.providerName;
1047                 }
1048             }
1049
1050             // handle volume
1051             Integer volume = null;
1052             if (!connection.isSequenceNodeQueueRunning()) {
1053                 if (mediaState != null) {
1054                     volume = mediaState.volume;
1055                 }
1056                 if (playerInfo != null && volume == null) {
1057                     Volume volumnInfo = playerInfo.volume;
1058                     if (volumnInfo != null) {
1059                         volume = volumnInfo.volume;
1060                     }
1061                 }
1062                 if (volume != null && volume > 0) {
1063                     lastKnownVolume = volume;
1064                 }
1065                 if (volume == null) {
1066                     volume = lastKnownVolume;
1067                 }
1068             }
1069             // Update states
1070             if (updateRemind && currentNotifcationUpdateTimer == null) {
1071                 updateRemind = false;
1072                 updateState(CHANNEL_REMIND, StringType.EMPTY);
1073             }
1074             if (updateAlarm && currentNotifcationUpdateTimer == null) {
1075                 updateAlarm = false;
1076                 updateState(CHANNEL_PLAY_ALARM_SOUND, StringType.EMPTY);
1077             }
1078             if (updateRoutine) {
1079                 updateRoutine = false;
1080                 updateState(CHANNEL_START_ROUTINE, StringType.EMPTY);
1081             }
1082             if (updateTextToSpeech) {
1083                 updateTextToSpeech = false;
1084                 updateState(CHANNEL_TEXT_TO_SPEECH, StringType.EMPTY);
1085             }
1086             if (updateTextCommand) {
1087                 updateTextCommand = false;
1088                 updateState(CHANNEL_TEXT_COMMAND, StringType.EMPTY);
1089             }
1090             if (updatePlayMusicVoiceCommand) {
1091                 updatePlayMusicVoiceCommand = false;
1092                 updateState(CHANNEL_PLAY_MUSIC_VOICE_COMMAND, StringType.EMPTY);
1093             }
1094             if (updateStartCommand) {
1095                 updateStartCommand = false;
1096                 updateState(CHANNEL_START_COMMAND, StringType.EMPTY);
1097             }
1098
1099             updateState(CHANNEL_MUSIC_PROVIDER_ID, new StringType(musicProviderId));
1100             updateState(CHANNEL_AMAZON_MUSIC_TRACK_ID, new StringType(amazonMusicTrackId));
1101             updateState(CHANNEL_AMAZON_MUSIC, isPlaying && amazonMusic ? OnOffType.ON : OnOffType.OFF);
1102             updateState(CHANNEL_AMAZON_MUSIC_PLAY_LIST_ID, new StringType(amazonMusicPlayListId));
1103             updateState(CHANNEL_RADIO_STATION_ID, new StringType(radioStationId));
1104             updateState(CHANNEL_RADIO, isPlaying && isRadio ? OnOffType.ON : OnOffType.OFF);
1105             updateState(CHANNEL_PROVIDER_DISPLAY_NAME, new StringType(providerDisplayName));
1106             updateState(CHANNEL_PLAYER, isPlaying ? PlayPauseType.PLAY : PlayPauseType.PAUSE);
1107             updateState(CHANNEL_IMAGE_URL, new StringType(imageUrl));
1108             updateState(CHANNEL_TITLE, new StringType(title));
1109             if (volume != null) {
1110                 updateState(CHANNEL_VOLUME, new PercentType(volume));
1111             }
1112             updateState(CHANNEL_SUBTITLE1, new StringType(subTitle1));
1113             updateState(CHANNEL_SUBTITLE2, new StringType(subTitle2));
1114             if (bluetoothState != null) {
1115                 updateState(CHANNEL_BLUETOOTH, bluetoothIsConnected ? OnOffType.ON : OnOffType.OFF);
1116                 updateState(CHANNEL_BLUETOOTH_MAC, new StringType(bluetoothMAC));
1117                 updateState(CHANNEL_BLUETOOTH_DEVICE_NAME, new StringType(bluetoothDeviceName));
1118             }
1119
1120             updateState(CHANNEL_ASCENDING_ALARM,
1121                     ascendingAlarm != null ? (ascendingAlarm ? OnOffType.ON : OnOffType.OFF) : UnDefType.UNDEF);
1122
1123             final Integer notificationVolumeLevel = this.notificationVolumeLevel;
1124             if (notificationVolumeLevel != null) {
1125                 updateState(CHANNEL_NOTIFICATION_VOLUME, new PercentType(notificationVolumeLevel));
1126             } else {
1127                 updateState(CHANNEL_NOTIFICATION_VOLUME, UnDefType.UNDEF);
1128             }
1129         } catch (Exception e) {
1130             this.logger.debug("Handle updateState {} failed: {}", this.getThing().getUID(), e.getMessage(), e);
1131
1132             disableUpdate = false;
1133             throw e; // Rethrow same exception
1134         }
1135     }
1136
1137     private void updateEqualizerState() {
1138         if (!this.capabilities.contains("SOUND_SETTINGS")) {
1139             return;
1140         }
1141
1142         Connection connection = findConnection();
1143         if (connection == null) {
1144             return;
1145         }
1146         Device device = findDevice();
1147         if (device == null) {
1148             return;
1149         }
1150         Integer bass = null;
1151         Integer midrange = null;
1152         Integer treble = null;
1153         try {
1154             JsonEqualizer equalizer = connection.getEqualizer(device);
1155             if (equalizer != null) {
1156                 bass = equalizer.bass;
1157                 midrange = equalizer.mid;
1158                 treble = equalizer.treble;
1159             }
1160             this.lastKnownEqualizer = equalizer;
1161         } catch (IOException | URISyntaxException | HttpException | ConnectionException | InterruptedException e) {
1162             logger.debug("Get equalizer failes", e);
1163             return;
1164         }
1165         if (bass != null) {
1166             updateState(CHANNEL_EQUALIZER_BASS, new DecimalType(bass));
1167         }
1168         if (midrange != null) {
1169             updateState(CHANNEL_EQUALIZER_MIDRANGE, new DecimalType(midrange));
1170         }
1171         if (treble != null) {
1172             updateState(CHANNEL_EQUALIZER_TREBLE, new DecimalType(treble));
1173         }
1174     }
1175
1176     private void updateMediaProgress() {
1177         updateMediaProgress(false);
1178     }
1179
1180     private void updateMediaProgress(boolean updateMediaLength) {
1181         synchronized (progressLock) {
1182             if (mediaStartMs > 0) {
1183                 long currentPlayTimeMs = isPlaying ? System.currentTimeMillis() - mediaStartMs : mediaProgressMs;
1184                 if (mediaLengthMs > 0) {
1185                     int progressPercent = (int) Math.min(100,
1186                             Math.round((double) currentPlayTimeMs / (double) mediaLengthMs * 100));
1187                     updateState(CHANNEL_MEDIA_PROGRESS, new PercentType(progressPercent));
1188                 } else {
1189                     updateState(CHANNEL_MEDIA_PROGRESS, UnDefType.UNDEF);
1190                 }
1191                 updateState(CHANNEL_MEDIA_PROGRESS_TIME, new QuantityType<>(currentPlayTimeMs / 1000, Units.SECOND));
1192                 if (updateMediaLength) {
1193                     updateState(CHANNEL_MEDIA_LENGTH, new QuantityType<>(mediaLengthMs / 1000, Units.SECOND));
1194                 }
1195             } else {
1196                 updateState(CHANNEL_MEDIA_PROGRESS, UnDefType.UNDEF);
1197                 updateState(CHANNEL_MEDIA_LENGTH, UnDefType.UNDEF);
1198                 updateState(CHANNEL_MEDIA_PROGRESS_TIME, UnDefType.UNDEF);
1199                 if (updateMediaLength) {
1200                     updateState(CHANNEL_MEDIA_LENGTH, UnDefType.UNDEF);
1201                 }
1202             }
1203         }
1204     }
1205
1206     public void handlePushActivity(Activity pushActivity) {
1207         if ("DISCARDED_NON_DEVICE_DIRECTED_INTENT".equals(pushActivity.activityStatus)) {
1208             return;
1209         }
1210         Description description = pushActivity.parseDescription();
1211         String firstUtteranceId = description.firstUtteranceId;
1212         if (firstUtteranceId == null || firstUtteranceId.isEmpty()
1213                 || firstUtteranceId.toLowerCase().startsWith("textclient:")) {
1214             return;
1215         }
1216         String firstStreamId = description.firstStreamId;
1217         if (firstStreamId == null || firstStreamId.isEmpty()) {
1218             return;
1219         }
1220         String spokenText = description.summary;
1221         if (spokenText != null && !spokenText.isEmpty()) {
1222             // remove wake word
1223             String wakeWordPrefix = this.wakeWord;
1224             if (wakeWordPrefix != null) {
1225                 wakeWordPrefix += " ";
1226                 if (spokenText.toLowerCase().startsWith(wakeWordPrefix.toLowerCase())) {
1227                     spokenText = spokenText.substring(wakeWordPrefix.length());
1228                 }
1229             }
1230
1231             if (lastSpokenText.isEmpty() || lastSpokenText.equals(spokenText)) {
1232                 updateState(CHANNEL_LAST_VOICE_COMMAND, StringType.EMPTY);
1233             }
1234             lastSpokenText = spokenText;
1235             updateState(CHANNEL_LAST_VOICE_COMMAND, new StringType(spokenText));
1236         }
1237     }
1238
1239     public void handlePushCommand(String command, String payload) {
1240         this.logger.debug("Handle push command {}", command);
1241         switch (command) {
1242             case "PUSH_VOLUME_CHANGE":
1243                 JsonCommandPayloadPushVolumeChange volumeChange = Objects
1244                         .requireNonNull(gson.fromJson(payload, JsonCommandPayloadPushVolumeChange.class));
1245                 Connection connection = this.findConnection();
1246                 Integer volumeSetting = volumeChange.volumeSetting;
1247                 Boolean muted = volumeChange.isMuted;
1248                 if (muted != null && muted) {
1249                     updateState(CHANNEL_VOLUME, new PercentType(0));
1250                 }
1251                 if (volumeSetting != null && connection != null && !connection.isSequenceNodeQueueRunning()) {
1252                     lastKnownVolume = volumeSetting;
1253                     updateState(CHANNEL_VOLUME, new PercentType(lastKnownVolume));
1254                 }
1255                 break;
1256             case "PUSH_EQUALIZER_STATE_CHANGE":
1257                 updateEqualizerState();
1258                 break;
1259             default:
1260                 AccountHandler account = this.account;
1261                 Device device = this.device;
1262                 if (account != null && device != null) {
1263                     this.disableUpdate = false;
1264                     updateState(account, device, null, null, null, null, null, null);
1265                 }
1266         }
1267     }
1268
1269     public void updateNotifications(ZonedDateTime currentTime, ZonedDateTime now,
1270             @Nullable JsonCommandPayloadPushNotificationChange pushPayload,
1271             List<JsonNotificationResponse> notifications) {
1272         Device device = this.device;
1273         if (device == null) {
1274             return;
1275         }
1276
1277         ZonedDateTime nextReminder = null;
1278         ZonedDateTime nextAlarm = null;
1279         ZonedDateTime nextMusicAlarm = null;
1280         ZonedDateTime nextTimer = null;
1281         for (JsonNotificationResponse notification : notifications) {
1282             if (Objects.equals(notification.deviceSerialNumber, device.serialNumber)) {
1283                 // notification for this device
1284                 if ("ON".equals(notification.status)) {
1285                     if ("Reminder".equals(notification.type)) {
1286                         String offset = ZoneId.systemDefault().getRules().getOffset(Instant.now()).toString();
1287                         String date = notification.originalDate != null ? notification.originalDate
1288                                 : ZonedDateTime.now().toLocalDate().format(DateTimeFormatter.ISO_LOCAL_DATE);
1289                         String time = notification.originalTime != null ? notification.originalTime : "00:00:00";
1290                         ZonedDateTime alarmTime = ZonedDateTime.parse(date + "T" + time + offset,
1291                                 DateTimeFormatter.ISO_DATE_TIME);
1292                         String recurringPattern = notification.recurringPattern;
1293                         if (recurringPattern != null && !recurringPattern.isBlank() && alarmTime.isBefore(now)) {
1294                             continue; // Ignore recurring entry if alarm time is before now
1295                         }
1296                         if (nextReminder == null || alarmTime.isBefore(nextReminder)) {
1297                             nextReminder = alarmTime;
1298                         }
1299                     } else if ("Timer".equals(notification.type)) {
1300                         // use remaining time
1301                         ZonedDateTime alarmTime = currentTime.plus(notification.remainingTime, ChronoUnit.MILLIS);
1302                         if (nextTimer == null || alarmTime.isBefore(nextTimer)) {
1303                             nextTimer = alarmTime;
1304                         }
1305                     } else if ("Alarm".equals(notification.type)) {
1306                         String offset = ZoneId.systemDefault().getRules().getOffset(Instant.now()).toString();
1307                         ZonedDateTime alarmTime = ZonedDateTime
1308                                 .parse(notification.originalDate + "T" + notification.originalTime + offset);
1309                         String recurringPattern = notification.recurringPattern;
1310                         if (recurringPattern != null && !recurringPattern.isBlank() && alarmTime.isBefore(now)) {
1311                             continue; // Ignore recurring entry if alarm time is before now
1312                         }
1313                         if (nextAlarm == null || alarmTime.isBefore(nextAlarm)) {
1314                             nextAlarm = alarmTime;
1315                         }
1316                     } else if ("MusicAlarm".equals(notification.type)) {
1317                         String offset = ZoneId.systemDefault().getRules().getOffset(Instant.now()).toString();
1318                         ZonedDateTime alarmTime = ZonedDateTime
1319                                 .parse(notification.originalDate + "T" + notification.originalTime + offset);
1320                         String recurringPattern = notification.recurringPattern;
1321                         if (recurringPattern != null && !recurringPattern.isBlank() && alarmTime.isBefore(now)) {
1322                             continue; // Ignore recurring entry if alarm time is before now
1323                         }
1324                         if (nextMusicAlarm == null || alarmTime.isBefore(nextMusicAlarm)) {
1325                             nextMusicAlarm = alarmTime;
1326                         }
1327                     }
1328                 }
1329             }
1330         }
1331
1332         updateState(CHANNEL_NEXT_REMINDER, nextReminder == null ? UnDefType.UNDEF : new DateTimeType(nextReminder));
1333         updateState(CHANNEL_NEXT_ALARM, nextAlarm == null ? UnDefType.UNDEF : new DateTimeType(nextAlarm));
1334         updateState(CHANNEL_NEXT_MUSIC_ALARM,
1335                 nextMusicAlarm == null ? UnDefType.UNDEF : new DateTimeType(nextMusicAlarm));
1336         updateState(CHANNEL_NEXT_TIMER, nextTimer == null ? UnDefType.UNDEF : new DateTimeType(nextTimer));
1337     }
1338
1339     @Override
1340     public void updateChannelState(String channelId, State state) {
1341         updateState(channelId, state);
1342     }
1343 }