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

   1 /**
   2  * Copyright (c) 2010-2024 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 java.time.Instant;
  16 import java.time.ZoneId;
  17 import java.time.ZonedDateTime;
  18 import java.util.ArrayList;
  19 import java.util.Collection;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Objects;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.openhab.binding.netatmo.internal.api.NetatmoException;
  28 import org.openhab.binding.netatmo.internal.api.SecurityApi;
  29 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FeatureArea;
  30 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FloodLightMode;
  31 import org.openhab.binding.netatmo.internal.api.dto.HomeData;
  32 import org.openhab.binding.netatmo.internal.api.dto.HomeDataModule;
  33 import org.openhab.binding.netatmo.internal.api.dto.HomeDataPerson;
  34 import org.openhab.binding.netatmo.internal.api.dto.HomeEvent;
  35 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusModule;
  36 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusPerson;
  37 import org.openhab.binding.netatmo.internal.api.dto.NAHomeStatus.HomeStatus;
  38 import org.openhab.binding.netatmo.internal.api.dto.NAObject;
  39 import org.openhab.binding.netatmo.internal.config.HomeConfiguration;
  40 import org.openhab.binding.netatmo.internal.deserialization.NAObjectMap;
  41 import org.openhab.binding.netatmo.internal.handler.CommonInterface;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44
  45 /**
  46  * The {@link SecurityCapability} is the base class for handler able to handle security features
  47  *
  48  * @author Gaël L'hopital - Initial contribution
  49  *
  50  */
  51 @NonNullByDefault
  52 class SecurityCapability extends RestCapability<SecurityApi> {
  53     private final static ZonedDateTime ZDT_REFERENCE = ZonedDateTime.ofInstant(Instant.ofEpochMilli(0),
  54             ZoneId.systemDefault());
  55
  56     private final Logger logger = LoggerFactory.getLogger(SecurityCapability.class);
  57     private final Map<String, HomeEvent> eventBuffer = new HashMap<>();
  58
  59     private ZonedDateTime freshestEventTime = ZDT_REFERENCE;
  60     private NAObjectMap<HomeDataPerson> persons = new NAObjectMap<>();
  61     private NAObjectMap<HomeDataModule> modules = new NAObjectMap<>();
  62     private String securityId = "";
  63
  64     SecurityCapability(CommonInterface handler) {
  65         super(handler, SecurityApi.class);
  66     }
  67
  68     @Override
  69     public void initialize() {
  70         super.initialize();
  71         freshestEventTime = ZDT_REFERENCE;
  72         securityId = handler.getThingConfigAs(HomeConfiguration.class).getIdForArea(FeatureArea.SECURITY);
  73     }
  74
  75     @Override
  76     protected void updateHomeData(HomeData homeData) {
  77         if (homeData instanceof HomeData.Security securityData) {
  78             persons = securityData.getPersons();
  79             modules = homeData.getModules();
  80             handler.getActiveChildren(FeatureArea.SECURITY).forEach(childHandler -> {
  81                 String childId = childHandler.getId();
  82                 persons.getOpt(childId).ifPresentOrElse(
  83                         personData -> childHandler.setNewData(personData.ignoringForThingUpdate()), () -> {
  84                             modules.getOpt(childId).ifPresent(
  85                                     childData -> childHandler.setNewData(childData.ignoringForThingUpdate()));
  86                             modules.values().stream().filter(module -> childId.equals(module.getBridge()))
  87                                     .forEach(bridgedModule -> childHandler.setNewData(bridgedModule));
  88                         });
  89             });
  90         }
  91     }
  92
  93     @Override
  94     protected void updateHomeStatus(HomeStatus securityStatus) {
  95         NAObjectMap<HomeStatusPerson> persons = securityStatus.getPersons();
  96         NAObjectMap<HomeStatusModule> modules = securityStatus.getModules();
  97         handler.getActiveChildren(FeatureArea.SECURITY).forEach(childHandler -> {
  98             String childId = childHandler.getId();
  99             persons.getOpt(childId).ifPresentOrElse(personData -> childHandler.setNewData(personData), () -> {
 100                 modules.getOpt(childId).ifPresent(childData -> {
 101                     childHandler.setNewData(childData);
 102                     modules.values().stream().filter(module -> childId.equals(module.getBridge()))
 103                             .forEach(bridgedModule -> childHandler.setNewData(bridgedModule));
 104                 });
 105             });
 106         });
 107     }
 108
 109     @Override
 110     protected void updateHomeEvent(HomeEvent homeEvent) {
 111         addEventIfKnownObject(homeEvent, homeEvent.getPersonId());
 112         addEventIfKnownObject(homeEvent, homeEvent.getCameraId());
 113     }
 114
 115     private void addEventIfKnownObject(HomeEvent homeEvent, @Nullable String objectId) {
 116         if (objectId == null) {
 117             return;
 118         }
 119         handler.getActiveChildren(FeatureArea.SECURITY).filter(child -> child.getId().equals(objectId))
 120                 .forEach(child -> child.setNewData(homeEvent));
 121     }
 122
 123     @Override
 124     protected List<NAObject> updateReadings(SecurityApi api) {
 125         List<NAObject> result = new ArrayList<>();
 126         try {
 127             for (HomeEvent event : api.getHomeEvents(securityId, freshestEventTime)) {
 128                 HomeEvent previousEvent = eventBuffer.get(event.getCameraId());
 129                 if (previousEvent == null || previousEvent.getTime().isBefore(event.getTime())) {
 130                     eventBuffer.put(event.getCameraId(), event);
 131                 }
 132                 String personId = event.getPersonId();
 133                 if (personId != null) {
 134                     previousEvent = eventBuffer.get(personId);
 135                     if (previousEvent == null || previousEvent.getTime().isBefore(event.getTime())) {
 136                         eventBuffer.put(personId, event);
 137                     }
 138                 }
 139                 if (event.getTime().isAfter(freshestEventTime)) {
 140                     freshestEventTime = event.getTime();
 141                 }
 142             }
 143         } catch (NetatmoException e) {
 144             logger.warn("Error retrieving last events for home '{}' : {}", securityId, e.getMessage());
 145         }
 146         return result;
 147     }
 148
 149     public NAObjectMap<HomeDataPerson> getPersons() {
 150         return persons;
 151     }
 152
 153     public NAObjectMap<HomeDataModule> getModules() {
 154         return modules;
 155     }
 156
 157     public @Nullable HomeEvent getLastPersonEvent(String personId) {
 158         HomeEvent event = eventBuffer.get(personId);
 159         if (event == null) {
 160             Collection<HomeEvent> events = requestPersonEvents(personId);
 161             if (!events.isEmpty()) {
 162                 event = events.iterator().next();
 163                 eventBuffer.put(personId, event);
 164             }
 165         }
 166         return event;
 167     }
 168
 169     public @Nullable HomeEvent getDeviceLastEvent(String moduleId, String deviceType) {
 170         HomeEvent event = eventBuffer.get(moduleId);
 171         if (event == null) {
 172             Collection<HomeEvent> events = requestDeviceEvents(moduleId, deviceType);
 173             if (!events.isEmpty()) {
 174                 event = events.iterator().next();
 175                 eventBuffer.put(moduleId, event);
 176             }
 177         }
 178         return event;
 179     }
 180
 181     private Collection<HomeEvent> requestDeviceEvents(String moduleId, String deviceType) {
 182         return Objects.requireNonNull(getApi().map(api -> {
 183             try {
 184                 return api.getDeviceEvents(securityId, moduleId, deviceType);
 185             } catch (NetatmoException e) {
 186                 logger.warn("Error retrieving last events of camera '{}' : {}", moduleId, e.getMessage());
 187                 return null;
 188             }
 189         }).orElse(List.of()));
 190     }
 191
 192     private Collection<HomeEvent> requestPersonEvents(String personId) {
 193         return Objects.requireNonNull(getApi().map(api -> {
 194             try {
 195                 return api.getPersonEvents(securityId, personId);
 196             } catch (NetatmoException e) {
 197                 logger.warn("Error retrieving last events of person '{}' : {}", personId, e.getMessage());
 198                 return null;
 199             }
 200         }).orElse(List.of()));
 201     }
 202
 203     public void setPersonAway(String personId, boolean away) {
 204         getApi().ifPresent(api -> {
 205             try {
 206                 api.setPersonAwayStatus(securityId, personId, away);
 207                 handler.expireData();
 208             } catch (NetatmoException e) {
 209                 logger.warn("Error setting person away/at home '{}' : {}", personId, e.getMessage());
 210             }
 211         });
 212     }
 213
 214     public @Nullable String ping(String vpnUrl) {
 215         return getApi().map(api -> api.ping(vpnUrl)).orElse(null);
 216     }
 217
 218     public void changeStatus(@Nullable String localURL, boolean status) {
 219         if (localURL == null) {
 220             logger.info("Monitoring changes can only be done on local camera.");
 221             return;
 222         }
 223         getApi().ifPresent(api -> {
 224             try {
 225                 api.changeStatus(localURL, status);
 226                 handler.expireData();
 227             } catch (NetatmoException e) {
 228                 logger.warn("Error changing camera monitoring status '{}' : {}", status, e.getMessage());
 229             }
 230         });
 231     }
 232
 233     public void changeFloodlightMode(String cameraId, FloodLightMode mode) {
 234         getApi().ifPresent(api -> {
 235             try {
 236                 api.changeFloodLightMode(securityId, cameraId, mode);
 237                 handler.expireData();
 238             } catch (NetatmoException e) {
 239                 logger.warn("Error changing Presence floodlight mode '{}' : {}", mode, e.getMessage());
 240             }
 241         });
 242     }
 243 }