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

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