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.netatmo.internal.handler.capability;
  14
  15 import static org.openhab.binding.netatmo.internal.NetatmoBindingConstants.*;
  16 import static org.openhab.core.thing.Thing.*;
  17
  18 import java.util.Collection;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import org.eclipse.jdt.annotation.NonNullByDefault;
  24 import org.eclipse.jdt.annotation.Nullable;
  25 import org.openhab.binding.netatmo.internal.api.data.ModuleType;
  26 import org.openhab.binding.netatmo.internal.api.dto.Device;
  27 import org.openhab.binding.netatmo.internal.api.dto.Event;
  28 import org.openhab.binding.netatmo.internal.api.dto.HomeData;
  29 import org.openhab.binding.netatmo.internal.api.dto.HomeEvent;
  30 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusModule;
  31 import org.openhab.binding.netatmo.internal.api.dto.NAHomeStatus.HomeStatus;
  32 import org.openhab.binding.netatmo.internal.api.dto.NAMain;
  33 import org.openhab.binding.netatmo.internal.api.dto.NAObject;
  34 import org.openhab.binding.netatmo.internal.api.dto.NAThing;
  35 import org.openhab.binding.netatmo.internal.api.dto.WebhookEvent;
  36 import org.openhab.binding.netatmo.internal.handler.CommonInterface;
  37 import org.openhab.core.thing.Thing;
  38 import org.openhab.core.thing.binding.ThingHandlerService;
  39 import org.openhab.core.types.Command;
  40
  41 /**
  42  * The {@link Capability} is the base class for all inherited capabilities
  43  *
  44  * @author Gaël L'hopital - Initial contribution
  45  *
  46  */
  47 @NonNullByDefault
  48 public class Capability {
  49
  50     protected final Thing thing;
  51     protected final CommonInterface handler;
  52     protected final ModuleType moduleType;
  53
  54     protected boolean firstLaunch;
  55     protected Map<String, String> properties = Map.of();
  56     protected @Nullable String statusReason;
  57
  58     Capability(CommonInterface handler) {
  59         this.handler = handler;
  60         this.thing = handler.getThing();
  61         this.moduleType = ModuleType.from(thing.getThingTypeUID());
  62     }
  63
  64     public final @Nullable String setNewData(NAObject newData) {
  65         beforeNewData();
  66         if (newData instanceof HomeData homeData) {
  67             updateHomeData(homeData);
  68         }
  69         if (newData instanceof HomeStatus homeStatus) {
  70             updateHomeStatus(homeStatus);
  71         }
  72         if (newData instanceof HomeStatusModule homeStatusModule) {
  73             updateHomeStatusModule(homeStatusModule);
  74         }
  75
  76         if (newData instanceof HomeEvent homeEvent) {
  77             updateHomeEvent(homeEvent);
  78         } else if (newData instanceof WebhookEvent webhookEvent && webhookEvent.getEventType().validFor(moduleType)) {
  79             updateWebhookEvent(webhookEvent);
  80         } else if (newData instanceof Event event) {
  81             updateEvent(event);
  82         }
  83
  84         if (newData instanceof NAThing naThing) {
  85             updateNAThing(naThing);
  86         }
  87         if (newData instanceof NAMain naMain) {
  88             updateNAMain(naMain);
  89         }
  90         if (newData instanceof Device device) {
  91             updateNADevice(device);
  92         }
  93         afterNewData(newData);
  94         return statusReason;
  95     }
  96
  97     protected void beforeNewData() {
  98         properties = new HashMap<>(thing.getProperties());
  99         firstLaunch = properties.isEmpty();
 100         if (firstLaunch) {
 101             properties.put(PROPERTY_THING_TYPE_VERSION, moduleType.thingTypeVersion);
 102             if (!moduleType.isLogical()) {
 103                 String name = moduleType.apiName.isBlank() ? moduleType.name() : moduleType.apiName;
 104                 properties.put(PROPERTY_MODEL_ID, name);
 105                 properties.put(PROPERTY_VENDOR, VENDOR);
 106             }
 107         }
 108         statusReason = null;
 109     }
 110
 111     protected void afterNewData(@Nullable NAObject newData) {
 112         if (!properties.equals(thing.getProperties())) {
 113             thing.setProperties(properties);
 114         }
 115     }
 116
 117     protected void updateNAThing(NAThing newData) {
 118         String firmware = newData.getFirmware();
 119         if (firmware != null && !firmware.isBlank()) {
 120             properties.put(PROPERTY_FIRMWARE_VERSION, firmware);
 121         }
 122         if (!newData.isReachable()) {
 123             statusReason = "@text/device-not-connected";
 124         }
 125     }
 126
 127     protected void updateNAMain(NAMain newData) {
 128         // do nothing by default, can be overridden by subclasses
 129     }
 130
 131     protected void updateHomeEvent(HomeEvent newData) {
 132         // do nothing by default, can be overridden by subclasses
 133     }
 134
 135     protected void updateHomeStatus(HomeStatus newData) {
 136         // do nothing by default, can be overridden by subclasses
 137     }
 138
 139     protected void updateHomeData(HomeData newData) {
 140         // do nothing by default, can be overridden by subclasses
 141     }
 142
 143     protected void updateEvent(Event newData) {
 144         // do nothing by default, can be overridden by subclasses
 145     }
 146
 147     protected void updateWebhookEvent(WebhookEvent newData) {
 148         // do nothing by default, can be overridden by subclasses
 149     }
 150
 151     protected void updateNADevice(Device newData) {
 152         // do nothing by default, can be overridden by subclasses
 153     }
 154
 155     public void initialize() {
 156         // do nothing by default, can be overridden by subclasses
 157     }
 158
 159     public void expireData() {
 160         if (!handler.getCapabilities().containsKey(RefreshCapability.class)) {
 161             CommonInterface bridgeHandler = handler.getBridgeHandler();
 162             if (bridgeHandler != null) {
 163                 bridgeHandler.expireData();
 164             }
 165         }
 166     }
 167
 168     public void dispose() {
 169         // do nothing by default, can be overridden by subclasses
 170     }
 171
 172     public void updateHomeStatusModule(HomeStatusModule newData) {
 173         // do nothing by default, can be overridden by subclasses
 174     }
 175
 176     public void handleCommand(String channelName, Command command) {
 177         // do nothing by default, can be overridden by subclasses
 178     }
 179
 180     public Collection<Class<? extends ThingHandlerService>> getServices() {
 181         return List.of();
 182     }
 183
 184     public List<NAObject> updateReadings() {
 185         return List.of();
 186     }
 187 }