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.rfxcom.internal.messages;
  14
  15 import java.lang.reflect.Constructor;
  16 import java.lang.reflect.InvocationTargetException;
  17 import java.util.Collections;
  18 import java.util.HashMap;
  19 import java.util.Map;
  20
  21 import org.openhab.binding.rfxcom.internal.config.RFXComDeviceConfiguration;
  22 import org.openhab.binding.rfxcom.internal.exceptions.RFXComException;
  23 import org.openhab.binding.rfxcom.internal.exceptions.RFXComMessageNotImplementedException;
  24 import org.openhab.binding.rfxcom.internal.messages.RFXComBaseMessage.PacketType;
  25 import org.openhab.core.thing.ChannelUID;
  26 import org.openhab.core.types.Command;
  27
  28 /**
  29  * Factory to create RFXCom messages from either bytes delivered by the RFXCom device
  30  * or from openhab state to transmit.
  31  *
  32  * @author Pauli Anttila - Initial contribution
  33  * @author James Hewitt-Thomas - Use the enum singleton pattern to allow dependency injection
  34  */
  35 public enum RFXComMessageFactoryImpl implements RFXComMessageFactory {
  36     INSTANCE();
  37
  38     @SuppressWarnings("serial")
  39     private static final Map<PacketType, Class<? extends RFXComMessage>> MESSAGE_CLASSES = Collections
  40             .unmodifiableMap(new HashMap<PacketType, Class<? extends RFXComMessage>>() {
  41                 {
  42                     put(PacketType.INTERFACE_CONTROL, RFXComInterfaceControlMessage.class);
  43                     put(PacketType.INTERFACE_MESSAGE, RFXComInterfaceMessage.class);
  44                     put(PacketType.TRANSMITTER_MESSAGE, RFXComTransmitterMessage.class);
  45                     put(PacketType.UNDECODED_RF_MESSAGE, RFXComUndecodedRFMessage.class);
  46                     put(PacketType.LIGHTING1, RFXComLighting1Message.class);
  47                     put(PacketType.LIGHTING2, RFXComLighting2Message.class);
  48                     // put(PacketType.LIGHTING3, RFXComLighting3Message.class);
  49                     put(PacketType.LIGHTING4, RFXComLighting4Message.class);
  50                     put(PacketType.LIGHTING5, RFXComLighting5Message.class);
  51                     put(PacketType.LIGHTING6, RFXComLighting6Message.class);
  52                     put(PacketType.CHIME, RFXComChimeMessage.class);
  53                     put(PacketType.FAN, RFXComFanMessage.class);
  54                     // put(PacketType.FAN_SF01, RFXComFanMessage.class);
  55                     // put(PacketType.FAN_ITHO, RFXComFanMessage.class);
  56                     // put(PacketType.FAN_SEAV, RFXComFanMessage.class);
  57                     put(PacketType.FAN_LUCCI_DC, RFXComFanMessage.class);
  58                     // put(PacketType.FAN_FT1211R, RFXComFanMessage.class);
  59                     put(PacketType.FAN_FALMEC, RFXComFanMessage.class);
  60                     put(PacketType.FAN_LUCCI_DC_II, RFXComFanMessage.class);
  61                     put(PacketType.FAN_NOVY, RFXComFanMessage.class);
  62                     put(PacketType.CURTAIN1, RFXComCurtain1Message.class);
  63                     put(PacketType.BLINDS1, RFXComBlinds1Message.class);
  64                     put(PacketType.RFY, RFXComRfyMessage.class);
  65                     put(PacketType.HOME_CONFORT, RFXComHomeConfortMessage.class);
  66                     put(PacketType.SECURITY1, RFXComSecurity1Message.class);
  67                     put(PacketType.SECURITY2, RFXComSecurity2Message.class);
  68                     // put(PacketType.CAMERA1, RFXComCamera1Message.class);
  69                     // put(PacketType.REMOTE_CONTROL, RFXComRemoteControlMessage.class);
  70                     put(PacketType.THERMOSTAT1, RFXComThermostat1Message.class);
  71                     // put(PacketType.THERMOSTAT2, RFXComThermostat2Message.class);
  72                     put(PacketType.THERMOSTAT3, RFXComThermostat3Message.class);
  73                     // put(PacketType.RADIATOR1, RFXComRadiator1Message.class);
  74                     put(PacketType.BBQ, RFXComBBQTemperatureMessage.class);
  75                     put(PacketType.TEMPERATURE_RAIN, RFXComTemperatureRainMessage.class);
  76                     put(PacketType.TEMPERATURE, RFXComTemperatureMessage.class);
  77                     put(PacketType.HUMIDITY, RFXComHumidityMessage.class);
  78                     put(PacketType.TEMPERATURE_HUMIDITY, RFXComTemperatureHumidityMessage.class);
  79                     // put(PacketType.BAROMETRIC, RFXComBarometricMessage.class);
  80                     put(PacketType.TEMPERATURE_HUMIDITY_BAROMETRIC, RFXComTemperatureHumidityBarometricMessage.class);
  81                     put(PacketType.RAIN, RFXComRainMessage.class);
  82                     put(PacketType.WIND, RFXComWindMessage.class);
  83                     put(PacketType.UV, RFXComUVMessage.class);
  84                     put(PacketType.DATE_TIME, RFXComDateTimeMessage.class);
  85                     put(PacketType.CURRENT, RFXComCurrentMessage.class);
  86                     put(PacketType.ENERGY, RFXComEnergyMessage.class);
  87                     put(PacketType.CURRENT_ENERGY, RFXComCurrentEnergyMessage.class);
  88                     // put(PacketType.POWER, RFXComPowerMessage.class);
  89                     // put(PacketType.WEIGHT, RFXComWeightMessage.class);
  90                     // put(PacketType.GAS, RFXComGasMessage.class);
  91                     // put(PacketType.WATER, RFXComWaterMessage.class);
  92                     put(PacketType.RFXSENSOR, RFXComRFXSensorMessage.class);
  93                     // put(PacketType.RFXMETER, RFXComRFXMeterMessage.class);
  94                     // put(PacketType.FS20, RFXComFS20Message.class);
  95                     put(PacketType.RAW, RFXComRawMessage.class);
  96                     // put(PacketType.IO_LINES, RFXComIOLinesMessage.class);
  97                 }
  98             });
  99
 100     /**
 101      * Create message for transmission from the packet type associated with the thing.
 102      */
 103     @Override
 104     public RFXComMessage createMessage(PacketType packetType, RFXComDeviceConfiguration config, ChannelUID channelUID,
 105             Command command) throws RFXComException {
 106         try {
 107             Class<? extends RFXComMessage> cl = MESSAGE_CLASSES.get(packetType);
 108             if (cl == null) {
 109                 throw new RFXComMessageNotImplementedException("Message " + packetType + " not implemented");
 110             }
 111             RFXComMessage msg = cl.getDeclaredConstructor().newInstance();
 112             msg.setConfig(config);
 113             msg.convertFromState(channelUID.getId(), command);
 114             return msg;
 115         } catch (ReflectiveOperationException e) {
 116             throw new RFXComException(e);
 117         }
 118     }
 119
 120     /**
 121      * Create message from received bytes.
 122      */
 123     @Override
 124     public RFXComMessage createMessage(byte[] packet) throws RFXComException {
 125         PacketType packetType = ByteEnumUtil.fromByte(PacketType.class, packet[1]);
 126
 127         try {
 128             Class<? extends RFXComMessage> cl = MESSAGE_CLASSES.get(packetType);
 129             if (cl == null) {
 130                 throw new RFXComMessageNotImplementedException("Message " + packetType + " not implemented");
 131             }
 132             Constructor<?> c = cl.getConstructor(byte[].class);
 133             return (RFXComMessage) c.newInstance(packet);
 134         } catch (InvocationTargetException e) {
 135             if (e.getCause() instanceof RFXComException) {
 136                 throw (RFXComException) e.getCause();
 137             } else {
 138                 throw new RFXComException(e);
 139             }
 140         } catch (NoSuchMethodException | IllegalAccessException | InstantiationException e) {
 141             throw new RFXComException(e);
 142         }
 143     }
 144
 145     public static PacketType convertPacketType(String packetType) throws IllegalArgumentException {
 146         for (PacketType p : PacketType.values()) {
 147             if (p.toString().replace("_", "").equals(packetType.replace("_", ""))) {
 148                 return p;
 149             }
 150         }
 151
 152         throw new IllegalArgumentException("Unknown packet type " + packetType);
 153     }
 154 }