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

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