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.lifx.internal.dto;
  14
  15 import java.util.HashMap;
  16 import java.util.Map;
  17
  18 import org.eclipse.jdt.annotation.NonNullByDefault;
  19 import org.eclipse.jdt.annotation.Nullable;
  20
  21 /**
  22  * A static factory for registering packet types that may be received and
  23  * dispatched to client cod * request types, like {@code PowerStateRequest}) or types received only via UDP
  24  * e. Packet handlers (used to construct actual packet
  25  * instances) may be retrieved via their packet type.
  26  *
  27  * @author Tim Buckley - Initial contribution
  28  * @author Karel Goderis - Enhancement for the V2 LIFX Firmware and LAN Protocol Specification
  29  * @author Wouter Born - Support LIFX 2016 product line-up and infrared functionality
  30  */
  31 @NonNullByDefault
  32 public class PacketFactory {
  33
  34     private static @Nullable PacketFactory instance;
  35
  36     public static synchronized PacketFactory getInstance() {
  37         PacketFactory result = instance;
  38         if (result == null) {
  39             result = new PacketFactory();
  40             instance = result;
  41         }
  42         return result;
  43     }
  44
  45     private final Map<Integer, PacketHandler<?>> handlers;
  46
  47     private PacketFactory() {
  48         handlers = new HashMap<>();
  49
  50         register(AcknowledgementResponse.class);
  51         register(EchoRequestResponse.class);
  52         register(GetColorZonesRequest.class);
  53         register(GetEchoRequest.class);
  54         register(GetGroupRequest.class);
  55         register(GetHostFirmwareRequest.class);
  56         register(GetHostInfoRequest.class);
  57         register(GetInfoRequest.class);
  58         register(GetLabelRequest.class);
  59         register(GetLightInfraredRequest.class);
  60         register(GetLightPowerRequest.class);
  61         register(GetLocationRequest.class);
  62         register(GetPowerRequest.class);
  63         register(GetRequest.class);
  64         register(GetServiceRequest.class);
  65         register(GetTagLabelsRequest.class);
  66         register(GetTagsRequest.class);
  67         register(GetTileEffectRequest.class);
  68         register(GetVersionRequest.class);
  69         register(GetWifiFirmwareRequest.class);
  70         register(GetWifiInfoRequest.class);
  71         register(SetColorRequest.class);
  72         register(SetColorZonesRequest.class);
  73         register(SetDimAbsoluteRequest.class);
  74         register(SetLabelRequest.class);
  75         register(SetLightInfraredRequest.class);
  76         register(SetLightPowerRequest.class);
  77         register(SetPowerRequest.class);
  78         register(SetTagsRequest.class);
  79         register(StateGroupResponse.class);
  80         register(StateHostFirmwareResponse.class);
  81         register(StateHostInfoResponse.class);
  82         register(StateInfoResponse.class);
  83         register(StateLabelResponse.class);
  84         register(StateLightInfraredResponse.class);
  85         register(StateLightPowerResponse.class);
  86         register(StateLocationResponse.class);
  87         register(StateMultiZoneResponse.class);
  88         register(StatePowerResponse.class);
  89         register(StateResponse.class);
  90         register(StateServiceResponse.class);
  91         register(StateTileEffectResponse.class);
  92         register(StateVersionResponse.class);
  93         register(StateWifiFirmwareResponse.class);
  94         register(StateWifiInfoResponse.class);
  95         register(StateZoneResponse.class);
  96         register(TagLabelsResponse.class);
  97         register(TagsResponse.class);
  98     }
  99
 100     /**
 101      * Registers a packet handler for the given packet type.
 102      *
 103      * @param type the type to register
 104      * @param handler the packet handler to associate with the type
 105      */
 106     public final void register(int type, PacketHandler<?> handler) {
 107         handlers.put(type, handler);
 108     }
 109
 110     /**
 111      * Registers a new generic packet handler for the given packet class. The
 112      * packet class must meet the criteria for {@link GenericHandler};
 113      * specifically, it must have an no-argument constructor and require no
 114      * parsing logic outside of an invocation of
 115      * {@link Packet#parse(java.nio.ByteBuffer)}.
 116      *
 117      * @param type the type of the packet to register
 118      * @param clazz the class of the packet to register
 119      */
 120     public final void register(int type, Class<? extends Packet> clazz) {
 121         handlers.put(type, new GenericHandler<>(clazz));
 122     }
 123
 124     /**
 125      * Registers a generic packet type. All requirements of
 126      * {@link GenericHandler} must met; specifically, classes must have a
 127      * no-args constructor and require no additional parsing logic.
 128      * Additionally, a public static integer {@code TYPE} field must be defined.
 129      *
 130      * @param <T> the packet type to register
 131      * @param clazz the packet class to register
 132      */
 133     public final <T extends Packet> void register(Class<T> clazz) {
 134         GenericHandler<T> handler = new GenericHandler<>(clazz);
 135
 136         if (!handler.isTypeFound()) {
 137             throw new IllegalArgumentException("Unable to register generic packet with no TYPE field.");
 138         }
 139
 140         handlers.put(handler.getType(), handler);
 141     }
 142
 143     /**
 144      * Gets a registered handler for the given packet type, if any exists. If
 145      * no matching handler can be found, {@code null} is returned.
 146      *
 147      * @param packetType the packet type of the handler to retrieve
 148      * @return a packet handler, or null
 149      */
 150     public @Nullable PacketHandler<?> getHandler(int packetType) {
 151         return handlers.get(packetType);
 152     }
 153
 154     public static @Nullable PacketHandler<?> createHandler(int packetType) {
 155         return getInstance().getHandler(packetType);
 156     }
 157 }