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.io.neeo.internal.servletservices;
  14
  15 import java.beans.PropertyChangeEvent;
  16 import java.beans.PropertyChangeListener;
  17 import java.io.IOException;
  18 import java.util.Map.Entry;
  19 import java.util.Objects;
  20 import java.util.concurrent.ScheduledExecutorService;
  21
  22 import javax.servlet.http.HttpServletRequest;
  23 import javax.servlet.http.HttpServletResponse;
  24 import javax.ws.rs.client.ClientBuilder;
  25
  26 import org.eclipse.jdt.annotation.NonNull;
  27 import org.eclipse.jdt.annotation.NonNullByDefault;
  28 import org.eclipse.jdt.annotation.Nullable;
  29 import org.openhab.core.common.ThreadPoolManager;
  30 import org.openhab.core.events.Event;
  31 import org.openhab.core.events.EventFilter;
  32 import org.openhab.core.items.Item;
  33 import org.openhab.core.items.ItemNotFoundException;
  34 import org.openhab.core.items.events.ItemCommandEvent;
  35 import org.openhab.core.items.events.ItemEventFactory;
  36 import org.openhab.core.items.events.ItemStateChangedEvent;
  37 import org.openhab.core.library.types.OnOffType;
  38 import org.openhab.core.thing.ChannelUID;
  39 import org.openhab.core.thing.ThingUID;
  40 import org.openhab.core.thing.events.ChannelTriggeredEvent;
  41 import org.openhab.core.thing.events.ThingEventFactory;
  42 import org.openhab.core.types.Command;
  43 import org.openhab.core.types.State;
  44 import org.openhab.io.neeo.internal.NeeoApi;
  45 import org.openhab.io.neeo.internal.NeeoConstants;
  46 import org.openhab.io.neeo.internal.NeeoDeviceKeys;
  47 import org.openhab.io.neeo.internal.NeeoItemValueConverter;
  48 import org.openhab.io.neeo.internal.NeeoUtil;
  49 import org.openhab.io.neeo.internal.ServiceContext;
  50 import org.openhab.io.neeo.internal.models.ButtonInfo;
  51 import org.openhab.io.neeo.internal.models.NeeoButtonGroup;
  52 import org.openhab.io.neeo.internal.models.NeeoCapabilityType;
  53 import org.openhab.io.neeo.internal.models.NeeoDevice;
  54 import org.openhab.io.neeo.internal.models.NeeoDeviceChannel;
  55 import org.openhab.io.neeo.internal.models.NeeoDeviceChannelDirectory;
  56 import org.openhab.io.neeo.internal.models.NeeoDeviceChannelKind;
  57 import org.openhab.io.neeo.internal.models.NeeoDirectoryRequest;
  58 import org.openhab.io.neeo.internal.models.NeeoDirectoryRequestAction;
  59 import org.openhab.io.neeo.internal.models.NeeoDirectoryResult;
  60 import org.openhab.io.neeo.internal.models.NeeoItemValue;
  61 import org.openhab.io.neeo.internal.models.NeeoNotification;
  62 import org.openhab.io.neeo.internal.models.NeeoSensorNotification;
  63 import org.openhab.io.neeo.internal.models.NeeoThingUID;
  64 import org.openhab.io.neeo.internal.net.HttpRequest;
  65 import org.openhab.io.neeo.internal.servletservices.models.PathInfo;
  66 import org.openhab.io.neeo.internal.servletservices.models.ReturnStatus;
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69
  70 import com.google.gson.Gson;
  71
  72 /**
  73  * The implementation of {@link ServletService} that will handle device callbacks from the Neeo Brain
  74  *
  75  * @author Tim Roberts - Initial Contribution
  76  */
  77 @NonNullByDefault
  78 public class NeeoBrainService extends DefaultServletService {
  79
  80     /** The logger */
  81     private final Logger logger = LoggerFactory.getLogger(NeeoBrainService.class);
  82
  83     /** The gson used for communications */
  84     private final Gson gson = NeeoUtil.createGson();
  85
  86     /** The NEEO API to use */
  87     private final NeeoApi api;
  88
  89     /** The service context */
  90     private final ServiceContext context;
  91
  92     /** The HTTP request */
  93     private final HttpRequest request;
  94
  95     /** The scheduler to use to schedule recipe execution */
  96     private final ScheduledExecutorService scheduler = ThreadPoolManager
  97             .getScheduledPool(NeeoConstants.THREAD_POOL_NAME);
  98
  99     /** The {@link NeeoItemValueConverter} used to convert values with */
 100     private final NeeoItemValueConverter itemConverter;
 101
 102     private final PropertyChangeListener listener = new PropertyChangeListener() {
 103         @Override
 104         public void propertyChange(@Nullable PropertyChangeEvent evt) {
 105             if (evt != null && (Boolean) evt.getNewValue()) {
 106                 resendState();
 107             }
 108         }
 109     };
 110
 111     /**
 112      * Constructs the service from the {@link NeeoApi} and {@link ServiceContext}
 113      *
 114      * @param api the non-null api
 115      * @param context the non-null context
 116      */
 117     public NeeoBrainService(NeeoApi api, ServiceContext context, ClientBuilder clientBuilder) {
 118         Objects.requireNonNull(api, "api cannot be null");
 119         Objects.requireNonNull(context, "context cannot be null");
 120
 121         this.context = context;
 122         this.itemConverter = new NeeoItemValueConverter(context);
 123         this.api = api;
 124         this.api.addPropertyChangeListener(NeeoApi.CONNECTED, listener);
 125         scheduler.execute(() -> {
 126             resendState();
 127         });
 128         request = new HttpRequest(clientBuilder);
 129     }
 130
 131     /**
 132      * Returns true if the path start with 'device' or ends with either 'subscribe' or 'unsubscribe'
 133      *
 134      * @see DefaultServletService#canHandleRoute(String[])
 135      */
 136     @Override
 137     public boolean canHandleRoute(String[] paths) {
 138         Objects.requireNonNull(paths, "paths cannot be null");
 139
 140         if (paths.length == 0) {
 141             return false;
 142         }
 143
 144         if ("device".equalsIgnoreCase(paths[0])) {
 145             return true;
 146         }
 147
 148         final String lastPath = paths.length >= 2 ? paths[1] : null;
 149         return "subscribe".equalsIgnoreCase(lastPath) || "unsubscribe".equalsIgnoreCase(lastPath);
 150     }
 151
 152     @Override
 153     public void handlePost(HttpServletRequest req, String[] paths, HttpServletResponse resp) throws IOException {
 154         Objects.requireNonNull(req, "req cannot be null");
 155         Objects.requireNonNull(paths, "paths cannot be null");
 156         Objects.requireNonNull(resp, "resp cannot be null");
 157         if (paths.length == 0) {
 158             throw new IllegalArgumentException("paths cannot be empty");
 159         }
 160
 161         final boolean hasDeviceStart = "device".equalsIgnoreCase(paths[0]);
 162
 163         if (hasDeviceStart) {
 164             final PathInfo pathInfo = new PathInfo(paths);
 165
 166             if ("directory".equalsIgnoreCase(pathInfo.getComponentType())) {
 167                 handleDirectory(req, resp, pathInfo);
 168             } else {
 169                 logger.debug("Unknown/unhandled brain service device route (POST): {}", String.join("/", paths));
 170
 171             }
 172         } else {
 173             logger.debug("Unknown/unhandled brain service route (POST): {}", String.join("/", paths));
 174         }
 175     }
 176
 177     @Override
 178     public void handleGet(HttpServletRequest req, String[] paths, HttpServletResponse resp) throws IOException {
 179         Objects.requireNonNull(req, "req cannot be null");
 180         Objects.requireNonNull(paths, "paths cannot be null");
 181         Objects.requireNonNull(resp, "resp cannot be null");
 182         if (paths.length == 0) {
 183             throw new IllegalArgumentException("paths cannot be empty");
 184         }
 185
 186         // Paths handled specially
 187         // 1. See PATHINFO for various /device/* keys (except for the next)
 188         // 2. New subscribe path: /device/{thingUID}/subscribe/default/{devicekey}
 189         // 3. New unsubscribe path: /device/{thingUID}/unsubscribe/default
 190         // 4. Old subscribe path: /{thingUID}/subscribe or unsubscribe/{deviceid}/{devicekey}
 191         // 4. Old unsubscribe path: /{thingUID}/subscribe or unsubscribe/{deviceid}
 192
 193         final boolean hasDeviceStart = "device".equalsIgnoreCase(paths[0]);
 194         if (hasDeviceStart && (paths.length >= 3 && !"subscribe".equalsIgnoreCase(paths[2])
 195                 && !"unsubscribe".equalsIgnoreCase(paths[2]))) {
 196             try {
 197                 final PathInfo pathInfo = new PathInfo(paths);
 198
 199                 String actionValue = pathInfo.getActionValue();
 200                 if (actionValue == null || actionValue.isEmpty()) {
 201                     handleGetValue(resp, pathInfo);
 202                 } else {
 203                     handleSetValue(resp, pathInfo);
 204                 }
 205             } catch (IllegalArgumentException e) {
 206                 logger.debug("Bad path: {} - {}", String.join("", paths), e.getMessage(), e);
 207             }
 208         } else {
 209             int idx = hasDeviceStart ? 1 : 0;
 210
 211             if (idx + 2 < paths.length) {
 212                 final String adapterName = paths[idx++];
 213                 final String action = paths[idx++].toLowerCase();
 214                 idx++; // deviceId/default - not used
 215
 216                 switch (action) {
 217                     case "subscribe":
 218                         if (idx < paths.length) {
 219                             final String deviceKey = paths[idx++];
 220                             handleSubscribe(resp, adapterName, deviceKey);
 221                         } else {
 222                             logger.debug("No device key set for a subscribe action: {}", String.join("/", paths));
 223                         }
 224                         break;
 225                     case "unsubscribe":
 226                         handleUnsubscribe(resp, adapterName);
 227                         break;
 228                     default:
 229                         logger.debug("Unknown action: {}", action);
 230                 }
 231
 232             } else {
 233                 logger.debug("Unknown/unhandled brain service route (GET): {}", String.join("/", paths));
 234             }
 235         }
 236     }
 237
 238     /**
 239      * Handle set value from the path
 240      *
 241      * @param resp the non-null response to write the response to
 242      * @param pathInfo the non-null path information
 243      */
 244     private void handleSetValue(HttpServletResponse resp, PathInfo pathInfo) {
 245         Objects.requireNonNull(resp, "resp cannot be null");
 246         Objects.requireNonNull(pathInfo, "pathInfo cannot be null");
 247
 248         logger.debug("handleSetValue {}", pathInfo);
 249         final NeeoDevice device = context.getDefinitions().getDevice(pathInfo.getThingUid());
 250         if (device != null) {
 251             final NeeoDeviceChannel channel = device.getChannel(pathInfo.getItemName(), pathInfo.getSubType(),
 252                     pathInfo.getChannelNbr());
 253             if (channel != null && channel.getKind() == NeeoDeviceChannelKind.TRIGGER) {
 254                 String value = channel.getValue();
 255                 final ChannelTriggeredEvent event = ThingEventFactory.createTriggerEvent(value == null ? "" : value,
 256                         new ChannelUID(device.getUid(), channel.getItemName()));
 257                 logger.debug("Posting triggered event: {}", event);
 258                 context.getEventPublisher().post(event);
 259             } else {
 260                 try {
 261                     final Item item = context.getItemRegistry().getItem(pathInfo.getItemName());
 262                     final Command cmd = NeeoItemValueConverter.convert(item, pathInfo);
 263                     if (cmd != null) {
 264                         final ItemCommandEvent event = ItemEventFactory.createCommandEvent(item.getName(), cmd);
 265                         logger.debug("Posting item event: {}", event);
 266                         context.getEventPublisher().post(event);
 267                     } else {
 268                         logger.debug("Cannot set value - no command for path: {}", pathInfo);
 269                     }
 270                 } catch (ItemNotFoundException e) {
 271                     logger.debug("Cannot set value - no linked items: {}", pathInfo);
 272                 }
 273             }
 274         } else {
 275             logger.debug("Cannot set value - no device definition: {}", pathInfo);
 276         }
 277     }
 278
 279     /**
 280      * Handle set value from the path
 281      *
 282      * @param resp the non-null response to write the response to
 283      * @param pathInfo the non-null path information
 284      * @throws IOException Signals that an I/O exception has occurred.
 285      */
 286     private void handleGetValue(HttpServletResponse resp, PathInfo pathInfo) throws IOException {
 287         Objects.requireNonNull(resp, "resp cannot be null");
 288         Objects.requireNonNull(pathInfo, "pathInfo cannot be null");
 289
 290         NeeoItemValue niv = new NeeoItemValue("");
 291
 292         try {
 293             final NeeoDevice device = context.getDefinitions().getDevice(pathInfo.getThingUid());
 294             if (device != null) {
 295                 final NeeoDeviceChannel channel = device.getChannel(pathInfo.getItemName(), pathInfo.getSubType(),
 296                         pathInfo.getChannelNbr());
 297                 if (channel != null && channel.getKind() == NeeoDeviceChannelKind.ITEM) {
 298                     try {
 299                         final Item item = context.getItemRegistry().getItem(pathInfo.getItemName());
 300                         niv = itemConverter.convert(channel, item.getState());
 301                     } catch (ItemNotFoundException e) {
 302                         logger.debug("Item '{}' not found to get a value ({})", pathInfo.getItemName(), pathInfo);
 303                     }
 304                 } else {
 305                     logger.debug("Channel definition for '{}' not found to get a value ({})", pathInfo.getItemName(),
 306                             pathInfo);
 307                 }
 308             } else {
 309                 logger.debug("Device definition for '{}' not found to get a value ({})", pathInfo.getItemName(),
 310                         pathInfo);
 311             }
 312
 313             NeeoUtil.write(resp, gson.toJson(niv));
 314         } finally {
 315             logger.debug("handleGetValue {}: {}", pathInfo, niv.getValue());
 316         }
 317     }
 318
 319     /**
 320      * Handle unsubscribing from a device by removing all device keys for the related {@link ThingUID}
 321      *
 322      * @param resp the non-null response to write to
 323      * @param adapterName the non-empty adapter name
 324      * @throws IOException Signals that an I/O exception has occurred.
 325      */
 326     private void handleUnsubscribe(HttpServletResponse resp, String adapterName) throws IOException {
 327         Objects.requireNonNull(resp, "resp cannot be null");
 328         NeeoUtil.requireNotEmpty(adapterName, "adapterName cannot be empty");
 329
 330         logger.debug("handleUnsubscribe {}", adapterName);
 331
 332         try {
 333             final NeeoThingUID uid = new NeeoThingUID(adapterName);
 334             api.getDeviceKeys().remove(uid);
 335             NeeoUtil.write(resp, gson.toJson(ReturnStatus.SUCCESS));
 336         } catch (IllegalArgumentException e) {
 337             logger.debug("AdapterName {} is not a valid thinguid - ignoring", adapterName);
 338             NeeoUtil.write(resp, gson.toJson(new ReturnStatus("AdapterName not a valid ThingUID: " + adapterName)));
 339         }
 340     }
 341
 342     /**
 343      * Handle subscribe to a device by adding the device key to the API for the related {@link ThingUID}
 344      *
 345      * @param resp the non-null response to write to
 346      * @param adapterName the non-empty adapter name
 347      * @param deviceKey the non-empty device key
 348      * @throws IOException Signals that an I/O exception has occurred.
 349      */
 350     private void handleSubscribe(HttpServletResponse resp, String adapterName, String deviceKey) throws IOException {
 351         Objects.requireNonNull(resp, "resp cannot be null");
 352         NeeoUtil.requireNotEmpty(adapterName, "adapterName cannot be empty");
 353         NeeoUtil.requireNotEmpty(deviceKey, "deviceKey cannot be empty");
 354
 355         logger.debug("handleSubscribe {}/{}", adapterName, deviceKey);
 356
 357         try {
 358             final NeeoThingUID uid = new NeeoThingUID(adapterName);
 359             api.getDeviceKeys().put(uid, deviceKey);
 360             NeeoUtil.write(resp, gson.toJson(ReturnStatus.SUCCESS));
 361         } catch (IllegalArgumentException e) {
 362             logger.debug("AdapterName {} is not a valid thinguid - ignoring", adapterName);
 363             NeeoUtil.write(resp, gson.toJson(new ReturnStatus("AdapterName not a valid ThingUID: " + adapterName)));
 364         }
 365     }
 366
 367     /**
 368      * Handle a directory request
 369      *
 370      * @param req the non-null request to use
 371      * @param resp the non-null response to write to
 372      * @param pathInfo the non-null path information
 373      * @throws IOException Signals that an I/O exception has occurred.
 374      */
 375     private void handleDirectory(HttpServletRequest req, HttpServletResponse resp, PathInfo pathInfo)
 376             throws IOException {
 377         Objects.requireNonNull(req, "req cannot be null");
 378         Objects.requireNonNull(resp, "resp cannot be null");
 379         Objects.requireNonNull(pathInfo, "pathInfo cannot be null");
 380
 381         logger.debug("handleDirectory {}", pathInfo);
 382
 383         final NeeoDevice device = context.getDefinitions().getDevice(pathInfo.getThingUid());
 384         if (device != null) {
 385             final NeeoDeviceChannel channel = device.getChannel(pathInfo.getItemName(), pathInfo.getSubType(),
 386                     pathInfo.getChannelNbr());
 387             if ("action".equalsIgnoreCase(pathInfo.getActionValue())) {
 388                 final NeeoDirectoryRequestAction discoveryAction = gson.fromJson(req.getReader(),
 389                         NeeoDirectoryRequestAction.class);
 390
 391                 try {
 392                     final Item item = context.getItemRegistry().getItem(pathInfo.getItemName());
 393                     final Command cmd = NeeoItemValueConverter.convert(item, pathInfo,
 394                             discoveryAction.getActionIdentifier());
 395                     if (cmd != null) {
 396                         final ItemCommandEvent event = ItemEventFactory.createCommandEvent(item.getName(), cmd);
 397                         logger.debug("Posting item event: {}", event);
 398                         context.getEventPublisher().post(event);
 399                     } else {
 400                         logger.debug("Cannot set value (directory) - no command for path: {}", pathInfo);
 401                     }
 402                 } catch (ItemNotFoundException e) {
 403                     logger.debug("Cannot set value(directory)  - no linked items: {}", pathInfo);
 404                 }
 405
 406             } else {
 407                 if (channel instanceof NeeoDeviceChannelDirectory directoryChannel) {
 408                     final NeeoDirectoryRequest discoveryRequest = gson.fromJson(req.getReader(),
 409                             NeeoDirectoryRequest.class);
 410                     NeeoUtil.write(resp, gson.toJson(new NeeoDirectoryResult(discoveryRequest, directoryChannel)));
 411                 } else {
 412                     logger.debug("Channel definition for '{}' not found to directory set value ({})",
 413                             pathInfo.getItemName(), pathInfo);
 414                 }
 415             }
 416         } else {
 417             logger.debug("Device definition for '{}' not found to directory set value ({})", pathInfo.getItemName(),
 418                     pathInfo);
 419
 420         }
 421     }
 422
 423     /**
 424      * Returns the {@link EventFilter} used by this service. The {@link EventFilter} will simply filter for those items
 425      * that have been bound
 426      *
 427      * @return a non-null {@link EventFilter}
 428      */
 429     @NonNull
 430     @Override
 431     public EventFilter getEventFilter() {
 432         return new EventFilter() {
 433
 434             @Override
 435             public boolean apply(@Nullable Event event) {
 436                 Objects.requireNonNull(event, "event cannot be null");
 437
 438                 final ItemStateChangedEvent ise = (ItemStateChangedEvent) event;
 439                 final String itemName = ise.getItemName();
 440
 441                 final NeeoDeviceKeys keys = api.getDeviceKeys();
 442                 final boolean isBound = context.getDefinitions().isBound(keys, itemName);
 443                 logger.trace("Apply Event: {} --- {} --- {} = {}", event, itemName, isBound, keys);
 444                 return isBound;
 445             }
 446         };
 447     }
 448
 449     /**
 450      * Handles the event by notifying the NEEO brain of the new value. If the channel has been linked to the
 451      * {@link NeeoButtonGroup#POWERONOFF}, then the related recipe will be powered on/off (in addition to sending the
 452      * new value).
 453      *
 454      * @see DefaultServletService#handleEvent(Event)
 455      *
 456      */
 457     @Override
 458     public boolean handleEvent(Event event) {
 459         Objects.requireNonNull(event, "event cannot be null");
 460
 461         final ItemStateChangedEvent ise = (ItemStateChangedEvent) event;
 462         final String itemName = ise.getItemName();
 463
 464         logger.trace("handleEvent: {}", event);
 465         notifyState(itemName, ise.getItemState());
 466
 467         return true;
 468     }
 469
 470     /**
 471      * Helper function to send the current state of all bound channels
 472      */
 473     private void resendState() {
 474         for (final Entry<NeeoDevice, NeeoDeviceChannel> boundEntry : context.getDefinitions()
 475                 .getBound(api.getDeviceKeys())) {
 476
 477             final NeeoDevice device = boundEntry.getKey();
 478             final NeeoDeviceChannel channel = boundEntry.getValue();
 479
 480             try {
 481                 final State state = context.getItemRegistry().getItem(channel.getItemName()).getState();
 482
 483                 for (String deviceKey : api.getDeviceKeys().get(device.getUid())) {
 484                     sendNotification(channel, deviceKey, state);
 485                 }
 486             } catch (ItemNotFoundException e) {
 487                 logger.debug("Item not found {}", channel.getItemName());
 488             }
 489         }
 490     }
 491
 492     /**
 493      * Helper function to send some state for an itemName to the brain
 494      *
 495      * @param itemName a non-null, non-empty item name
 496      * @param state a non-null state
 497      */
 498     private void notifyState(String itemName, State state) {
 499         NeeoUtil.requireNotEmpty(itemName, "itemName cannot be empty");
 500         Objects.requireNonNull(state, "state cannot be null");
 501
 502         logger.trace("notifyState: {} --- {}", itemName, state);
 503
 504         for (final Entry<NeeoDevice, NeeoDeviceChannel> boundEntry : context.getDefinitions()
 505                 .getBound(api.getDeviceKeys(), itemName)) {
 506             final NeeoDevice device = boundEntry.getKey();
 507             final NeeoDeviceChannel channel = boundEntry.getValue();
 508             final NeeoThingUID uid = new NeeoThingUID(device.getUid());
 509
 510             logger.trace("notifyState (device): {} --- {} ", uid, channel);
 511             for (String deviceKey : api.getDeviceKeys().get(uid)) {
 512                 logger.trace("notifyState (key): {} --- {}", uid, deviceKey);
 513
 514                 if (state instanceof OnOffType) {
 515                     Boolean recipeState = null;
 516                     final String label = channel.getLabel();
 517                     if (NeeoButtonGroup.POWERONOFF.getText().equalsIgnoreCase(label)) {
 518                         recipeState = state == OnOffType.ON;
 519                     } else if (state == OnOffType.ON && ButtonInfo.POWERON.getLabel().equalsIgnoreCase(label)) {
 520                         recipeState = true;
 521                     } else if (state == OnOffType.OFF && ButtonInfo.POWEROFF.getLabel().equalsIgnoreCase(label)) {
 522                         recipeState = false;
 523                     }
 524
 525                     if (recipeState != null) {
 526                         logger.trace("notifyState (executeRecipe): {} --- {} --- {}", uid, deviceKey, recipeState);
 527                         final boolean turnOn = recipeState;
 528                         scheduler.submit(() -> {
 529                             try {
 530                                 api.executeRecipe(deviceKey, turnOn);
 531                             } catch (IOException e) {
 532                                 logger.debug("Exception occurred while handling executing a recipe: {}", e.getMessage(),
 533                                         e);
 534                             }
 535                         });
 536                     }
 537                 }
 538
 539                 sendNotification(channel, deviceKey, state);
 540             }
 541         }
 542     }
 543
 544     /**
 545      * Helper method to send a notification
 546      *
 547      * @param channel a non-null channel
 548      * @param deviceKey a non-null, non-empty device id
 549      * @param state a non-null state
 550      */
 551     private void sendNotification(NeeoDeviceChannel channel, String deviceKey, State state) {
 552         Objects.requireNonNull(channel, "channel cannot be null");
 553         NeeoUtil.requireNotEmpty(deviceKey, "deviceKey cannot be empty");
 554         Objects.requireNonNull(state, "state cannot be null");
 555
 556         scheduler.execute(() -> {
 557             final String uin = channel.getUniqueItemName();
 558
 559             final NeeoItemValue niv = itemConverter.convert(channel, state);
 560
 561             // Use sensor notification if we have a >= 0.50 firmware AND it's not a power sensor
 562             if (api.getSystemInfo().isFirmwareGreaterOrEqual(NeeoConstants.NEEO_FIRMWARE_0_51_1)
 563                     && channel.getType() != NeeoCapabilityType.SENSOR_POWER) {
 564                 final NeeoSensorNotification notify = new NeeoSensorNotification(deviceKey, uin, niv.getValue());
 565                 try {
 566                     api.notify(gson.toJson(notify));
 567                 } catch (IOException e) {
 568                     logger.debug("Exception occurred while handling event: {}", e.getMessage(), e);
 569                 }
 570             } else {
 571                 final NeeoNotification notify = new NeeoNotification(deviceKey, uin, niv.getValue());
 572                 try {
 573                     api.notify(gson.toJson(notify));
 574                 } catch (IOException e) {
 575                     logger.debug("Exception occurred while handling event: {}", e.getMessage(), e);
 576                 }
 577             }
 578         });
 579     }
 580
 581     /**
 582      * Simply closes the {@link #request}
 583      *
 584      * @see DefaultServletService#close()
 585      */
 586     @Override
 587     public void close() {
 588         this.api.removePropertyChangeListener(listener);
 589         request.close();
 590     }
 591 }