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.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(GetHevCycleConfigurationRequest.class);
  56         register(GetHevCycleRequest.class);
  57         register(GetHostFirmwareRequest.class);
  58         register(GetHostInfoRequest.class);
  59         register(GetInfoRequest.class);
  60         register(GetLabelRequest.class);
  61         register(GetLastHevCycleResultRequest.class);
  62         register(GetLightInfraredRequest.class);
  63         register(GetLightPowerRequest.class);
  64         register(GetLocationRequest.class);
  65         register(GetPowerRequest.class);
  66         register(GetRequest.class);
  67         register(GetServiceRequest.class);
  68         register(GetTagLabelsRequest.class);
  69         register(GetTagsRequest.class);
  70         register(GetTileEffectRequest.class);
  71         register(GetVersionRequest.class);
  72         register(GetWifiFirmwareRequest.class);
  73         register(GetWifiInfoRequest.class);
  74         register(SetColorRequest.class);
  75         register(SetColorZonesRequest.class);
  76         register(SetDimAbsoluteRequest.class);
  77         register(SetHevCycleRequest.class);
  78         register(SetHevCycleConfigurationRequest.class);
  79         register(SetLabelRequest.class);
  80         register(SetLightInfraredRequest.class);
  81         register(SetLightPowerRequest.class);
  82         register(SetPowerRequest.class);
  83         register(SetTagsRequest.class);
  84         register(StateGroupResponse.class);
  85         register(StateHevCycleConfigurationResponse.class);
  86         register(StateHevCycleResponse.class);
  87         register(StateHostFirmwareResponse.class);
  88         register(StateHostInfoResponse.class);
  89         register(StateInfoResponse.class);
  90         register(StateLabelResponse.class);
  91         register(StateLastHevCycleResultResponse.class);
  92         register(StateLightInfraredResponse.class);
  93         register(StateLightPowerResponse.class);
  94         register(StateLocationResponse.class);
  95         register(StateMultiZoneResponse.class);
  96         register(StatePowerResponse.class);
  97         register(StateResponse.class);
  98         register(StateServiceResponse.class);
  99         register(StateTileEffectResponse.class);
 100         register(StateVersionResponse.class);
 101         register(StateWifiFirmwareResponse.class);
 102         register(StateWifiInfoResponse.class);
 103         register(StateZoneResponse.class);
 104         register(TagLabelsResponse.class);
 105         register(TagsResponse.class);
 106     }
 107
 108     /**
 109      * Registers a packet handler for the given packet type.
 110      *
 111      * @param type the type to register
 112      * @param handler the packet handler to associate with the type
 113      */
 114     public final void register(int type, PacketHandler<?> handler) {
 115         handlers.put(type, handler);
 116     }
 117
 118     /**
 119      * Registers a new generic packet handler for the given packet class. The
 120      * packet class must meet the criteria for {@link GenericHandler};
 121      * specifically, it must have a no-argument constructor and require no
 122      * parsing logic outside of an invocation of
 123      * {@link Packet#parse(java.nio.ByteBuffer)}.
 124      *
 125      * @param type the type of the packet to register
 126      * @param clazz the class of the packet to register
 127      */
 128     public final void register(int type, Class<? extends Packet> clazz) {
 129         handlers.put(type, new GenericHandler<>(clazz));
 130     }
 131
 132     /**
 133      * Registers a generic packet type. All requirements of
 134      * {@link GenericHandler} must met; specifically, classes must have a
 135      * no-args constructor and require no additional parsing logic.
 136      * Additionally, a public static integer {@code TYPE} field must be defined.
 137      *
 138      * @param <T> the packet type to register
 139      * @param clazz the packet class to register
 140      */
 141     public final <T extends Packet> void register(Class<T> clazz) {
 142         GenericHandler<T> handler = new GenericHandler<>(clazz);
 143
 144         if (!handler.isTypeFound()) {
 145             throw new IllegalArgumentException("Unable to register generic packet with no TYPE field.");
 146         }
 147
 148         handlers.put(handler.getType(), handler);
 149     }
 150
 151     /**
 152      * Gets a registered handler for the given packet type, if any exists. If
 153      * no matching handler can be found, {@code null} is returned.
 154      *
 155      * @param packetType the packet type of the handler to retrieve
 156      * @return a packet handler, or null
 157      */
 158     public @Nullable PacketHandler<?> getHandler(int packetType) {
 159         return handlers.get(packetType);
 160     }
 161
 162     public static @Nullable PacketHandler<?> createHandler(int packetType) {
 163         return getInstance().getHandler(packetType);
 164     }
 165 }