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.homematic.internal.communicator.virtual;
  14
  15 import static org.openhab.binding.homematic.internal.misc.HomematicConstants.VIRTUAL_DATAPOINT_NAME_BUTTON;
  16
  17 import java.util.HashSet;
  18
  19 import org.openhab.binding.homematic.internal.misc.MiscUtils;
  20 import org.openhab.binding.homematic.internal.model.HmChannel;
  21 import org.openhab.binding.homematic.internal.model.HmDatapoint;
  22 import org.openhab.binding.homematic.internal.model.HmDevice;
  23 import org.openhab.binding.homematic.internal.model.HmValueType;
  24 import org.openhab.core.thing.CommonTriggerEvents;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 /**
  29  * A virtual String datapoint which adds a BUTTON datapoint. It will forward key events to the
  30  * system channel {@link org.openhab.core.thing.DefaultSystemChannelTypeProvider#SYSTEM_BUTTON}.
  31  *
  32  * @author Michael Reitler - Initial contribution
  33  */
  34 public class ButtonVirtualDatapointHandler extends AbstractVirtualDatapointHandler {
  35     private final Logger logger = LoggerFactory.getLogger(ButtonVirtualDatapointHandler.class);
  36
  37     private static final String LONG_REPEATED_EVENT = "LONG_REPEATED";
  38     private static final String LONG_RELEASED_EVENT = "LONG_RELEASED";
  39
  40     private HashSet<String> devicesUsingLongStartEvent = new HashSet<>();
  41
  42     @Override
  43     public String getName() {
  44         return VIRTUAL_DATAPOINT_NAME_BUTTON;
  45     }
  46
  47     @Override
  48     public void initialize(HmDevice device) {
  49         for (HmChannel channel : device.getChannels()) {
  50             if (channel.hasPressDatapoint()) {
  51                 HmDatapoint dp = addDatapoint(device, channel.getNumber(), getName(), HmValueType.STRING, null, false);
  52                 dp.setTrigger(true);
  53                 dp.setOptions(new String[] { CommonTriggerEvents.SHORT_PRESSED, CommonTriggerEvents.LONG_PRESSED,
  54                         LONG_REPEATED_EVENT, LONG_RELEASED_EVENT });
  55             }
  56         }
  57     }
  58
  59     @Override
  60     public boolean canHandleEvent(HmDatapoint dp) {
  61         return dp.isPressDatapoint();
  62     }
  63
  64     @Override
  65     public void handleEvent(VirtualGateway gateway, HmDatapoint dp) {
  66         HmChannel channel = dp.getChannel();
  67         String deviceSerial = channel.getDevice().getAddress();
  68         HmDatapoint vdp = getVirtualDatapoint(channel);
  69         int usPos = dp.getName().indexOf("_");
  70         String pressType = usPos == -1 ? dp.getName() : dp.getName().substring(usPos + 1);
  71         boolean isLongPressActive = CommonTriggerEvents.LONG_PRESSED.equals(vdp.getValue())
  72                 || LONG_REPEATED_EVENT.equals(vdp.getValue());
  73         if (MiscUtils.isTrueValue(dp.getValue())) {
  74             switch (pressType) {
  75                 case "SHORT": {
  76                     vdp.setValue(null); // Force sending new event
  77                     vdp.setValue(CommonTriggerEvents.SHORT_PRESSED);
  78                     break;
  79                 }
  80                 case "LONG":
  81                     if (isLongPressActive) {
  82                         // HM-IP devices do long press repetitions via LONG instead of CONT events,
  83                         // so clear previous value to force re-triggering of event
  84                         vdp.setValue(null);
  85                         vdp.setValue(LONG_REPEATED_EVENT);
  86                     } else {
  87                         // HM devices start long press via LONG events
  88                         vdp.setValue(CommonTriggerEvents.LONG_PRESSED);
  89                     }
  90                     break;
  91                 case "LONG_START":
  92                     vdp.setValue(CommonTriggerEvents.LONG_PRESSED);
  93                     devicesUsingLongStartEvent.add(deviceSerial);
  94                     break;
  95                 case "LONG_RELEASE":
  96                     // Only send release events if we sent a pressed event before
  97                     vdp.setValue(isLongPressActive ? LONG_RELEASED_EVENT : null);
  98                     break;
  99                 case "CONT":
 100                     // Clear previous value to force re-triggering of repetition
 101                     vdp.setValue(null);
 102                     // Only send repetitions if there was a pressed event before
 103                     // (a CONT might arrive simultaneously with the initial LONG event)
 104                     if (isLongPressActive) {
 105                         vdp.setValue(LONG_REPEATED_EVENT);
 106                     }
 107                     break;
 108                 default:
 109                     vdp.setValue(null);
 110                     logger.warn("Unexpected vaule '{}' for PRESS virtual datapoint", pressType);
 111             }
 112         } else {
 113             String usedStartEvent = devicesUsingLongStartEvent.contains(deviceSerial) ? "LONG_START" : "LONG";
 114             if (usedStartEvent.equals(pressType) && LONG_REPEATED_EVENT.equals(vdp.getValue())) {
 115                 // If we're currently processing a repeated long-press event, don't let the initial LONG
 116                 // event time out the repetitions, the CONT delay handler will take care of it
 117                 vdp.setValue(LONG_REPEATED_EVENT);
 118             } else if (isLongPressActive) {
 119                 // We seemingly missed an event (either a CONT or the final LONG_RELEASE),
 120                 // so end the long press cycle now
 121                 vdp.setValue(LONG_RELEASED_EVENT);
 122             } else {
 123                 vdp.setValue(null);
 124             }
 125         }
 126         logger.debug("Handled virtual button event on {}:{}: press type {}, value {}, button state {} -> {}",
 127                 channel.getDevice().getAddress(), channel.getNumber(), pressType, dp.getValue(), vdp.getPreviousValue(),
 128                 vdp.getValue());
 129     }
 130 }