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.miio.internal.handler;
  14
  15 import static org.openhab.binding.miio.internal.MiIoBindingConstants.*;
  16
  17 import java.io.ByteArrayInputStream;
  18 import java.io.ByteArrayOutputStream;
  19 import java.io.File;
  20 import java.io.IOException;
  21 import java.text.SimpleDateFormat;
  22 import java.time.Instant;
  23 import java.time.ZoneId;
  24 import java.time.ZonedDateTime;
  25 import java.util.Collections;
  26 import java.util.Date;
  27 import java.util.Map.Entry;
  28 import java.util.Set;
  29 import java.util.concurrent.ConcurrentHashMap;
  30 import java.util.concurrent.TimeUnit;
  31 import java.util.stream.Collectors;
  32 import java.util.stream.Stream;
  33
  34 import javax.imageio.ImageIO;
  35
  36 import org.eclipse.jdt.annotation.NonNullByDefault;
  37 import org.eclipse.jdt.annotation.Nullable;
  38 import org.openhab.binding.miio.internal.MiIoBindingConfiguration;
  39 import org.openhab.binding.miio.internal.MiIoCommand;
  40 import org.openhab.binding.miio.internal.MiIoSendCommand;
  41 import org.openhab.binding.miio.internal.basic.MiIoDatabaseWatchService;
  42 import org.openhab.binding.miio.internal.cloud.CloudConnector;
  43 import org.openhab.binding.miio.internal.cloud.CloudUtil;
  44 import org.openhab.binding.miio.internal.cloud.MiCloudException;
  45 import org.openhab.binding.miio.internal.robot.ConsumablesType;
  46 import org.openhab.binding.miio.internal.robot.FanModeType;
  47 import org.openhab.binding.miio.internal.robot.RRMapDraw;
  48 import org.openhab.binding.miio.internal.robot.RobotCababilities;
  49 import org.openhab.binding.miio.internal.robot.StatusDTO;
  50 import org.openhab.binding.miio.internal.robot.StatusType;
  51 import org.openhab.binding.miio.internal.robot.VacuumErrorType;
  52 import org.openhab.binding.miio.internal.transport.MiIoAsyncCommunication;
  53 import org.openhab.core.cache.ExpiringCache;
  54 import org.openhab.core.library.types.DateTimeType;
  55 import org.openhab.core.library.types.DecimalType;
  56 import org.openhab.core.library.types.OnOffType;
  57 import org.openhab.core.library.types.QuantityType;
  58 import org.openhab.core.library.types.RawType;
  59 import org.openhab.core.library.types.StringType;
  60 import org.openhab.core.library.unit.SIUnits;
  61 import org.openhab.core.library.unit.Units;
  62 import org.openhab.core.thing.Channel;
  63 import org.openhab.core.thing.ChannelUID;
  64 import org.openhab.core.thing.Thing;
  65 import org.openhab.core.thing.ThingStatusDetail;
  66 import org.openhab.core.thing.binding.builder.ChannelBuilder;
  67 import org.openhab.core.thing.binding.builder.ThingBuilder;
  68 import org.openhab.core.thing.type.ChannelType;
  69 import org.openhab.core.thing.type.ChannelTypeRegistry;
  70 import org.openhab.core.types.Command;
  71 import org.openhab.core.types.RefreshType;
  72 import org.openhab.core.types.State;
  73 import org.openhab.core.types.UnDefType;
  74 import org.slf4j.Logger;
  75 import org.slf4j.LoggerFactory;
  76
  77 import com.google.gson.Gson;
  78 import com.google.gson.GsonBuilder;
  79 import com.google.gson.JsonArray;
  80 import com.google.gson.JsonObject;
  81
  82 /**
  83  * The {@link MiIoVacuumHandler} is responsible for handling commands, which are
  84  * sent to one of the channels.
  85  *
  86  * @author Marcel Verpaalen - Initial contribution
  87  */
  88 @NonNullByDefault
  89 public class MiIoVacuumHandler extends MiIoAbstractHandler {
  90     private final Logger logger = LoggerFactory.getLogger(MiIoVacuumHandler.class);
  91     private static final float MAP_SCALE = 2.0f;
  92     private static final SimpleDateFormat DATEFORMATTER = new SimpleDateFormat("yyyyMMdd-HHmmss");
  93     private static final Gson GSON = new GsonBuilder().serializeNulls().create();
  94     private final ChannelUID mapChannelUid;
  95
  96     private static final Set<RobotCababilities> FEATURES_CHANNELS = Collections.unmodifiableSet(Stream
  97             .of(RobotCababilities.SEGMENT_STATUS, RobotCababilities.MAP_STATUS, RobotCababilities.LED_STATUS,
  98                     RobotCababilities.CARPET_MODE, RobotCababilities.FW_FEATURES, RobotCababilities.ROOM_MAPPING,
  99                     RobotCababilities.MULTI_MAP_LIST, RobotCababilities.CUSTOMIZE_CLEAN_MODE)
 100             .collect(Collectors.toSet()));
 101
 102     private ExpiringCache<String> status;
 103     private ExpiringCache<String> consumables;
 104     private ExpiringCache<String> dnd;
 105     private ExpiringCache<String> history;
 106     private int stateId;
 107     private ExpiringCache<String> map;
 108     private String lastHistoryId = "";
 109     private String lastMap = "";
 110     private boolean hasChannelStructure;
 111     private ConcurrentHashMap<RobotCababilities, Boolean> deviceCapabilities = new ConcurrentHashMap<>();
 112     private ChannelTypeRegistry channelTypeRegistry;
 113
 114     public MiIoVacuumHandler(Thing thing, MiIoDatabaseWatchService miIoDatabaseWatchService,
 115             CloudConnector cloudConnector, ChannelTypeRegistry channelTypeRegistry) {
 116         super(thing, miIoDatabaseWatchService, cloudConnector);
 117         this.channelTypeRegistry = channelTypeRegistry;
 118         mapChannelUid = new ChannelUID(thing.getUID(), CHANNEL_VACUUM_MAP);
 119         status = new ExpiringCache<>(CACHE_EXPIRY, () -> {
 120             try {
 121                 int ret = sendCommand(MiIoCommand.GET_STATUS);
 122                 if (ret != 0) {
 123                     return "id:" + ret;
 124                 }
 125             } catch (Exception e) {
 126                 logger.debug("Error during status refresh: {}", e.getMessage(), e);
 127             }
 128             return null;
 129         });
 130         consumables = new ExpiringCache<>(CACHE_EXPIRY, () -> {
 131             try {
 132                 int ret = sendCommand(MiIoCommand.CONSUMABLES_GET);
 133                 if (ret != 0) {
 134                     return "id:" + ret;
 135                 }
 136             } catch (Exception e) {
 137                 logger.debug("Error during consumables refresh: {}", e.getMessage(), e);
 138             }
 139             return null;
 140         });
 141         dnd = new ExpiringCache<>(CACHE_EXPIRY, () -> {
 142             try {
 143                 int ret = sendCommand(MiIoCommand.DND_GET);
 144                 if (ret != 0) {
 145                     return "id:" + ret;
 146                 }
 147             } catch (Exception e) {
 148                 logger.debug("Error during dnd refresh: {}", e.getMessage(), e);
 149             }
 150             return null;
 151         });
 152         history = new ExpiringCache<>(CACHE_EXPIRY, () -> {
 153             try {
 154                 int ret = sendCommand(MiIoCommand.CLEAN_SUMMARY_GET);
 155                 if (ret != 0) {
 156                     return "id:" + ret;
 157                 }
 158             } catch (Exception e) {
 159                 logger.debug("Error during cleaning data refresh: {}", e.getMessage(), e);
 160             }
 161             return null;
 162         });
 163         map = new ExpiringCache<String>(CACHE_EXPIRY, () -> {
 164             try {
 165                 int ret = sendCommand(MiIoCommand.GET_MAP);
 166                 if (ret != 0) {
 167                     return "id:" + ret;
 168                 }
 169             } catch (Exception e) {
 170                 logger.debug("Error during dnd refresh: {}", e.getMessage(), e);
 171             }
 172             return null;
 173         });
 174         updateState(RobotCababilities.SEGMENT_CLEAN.getChannel(), new StringType("-"));
 175     }
 176
 177     @Override
 178     public void handleCommand(ChannelUID channelUID, Command command) {
 179         if (getConnection() == null) {
 180             logger.debug("Vacuum {} not online. Command {} ignored", getThing().getUID(), command.toString());
 181             return;
 182         }
 183         if (command == RefreshType.REFRESH) {
 184             logger.debug("Refreshing {}", channelUID);
 185             updateData();
 186             lastMap = "";
 187             if (channelUID.getId().equals(CHANNEL_VACUUM_MAP)) {
 188                 sendCommand(MiIoCommand.GET_MAP);
 189             }
 190             return;
 191         }
 192         if (handleCommandsChannels(channelUID, command)) {
 193             forceStatusUpdate();
 194             return;
 195         }
 196         if (channelUID.getId().equals(CHANNEL_VACUUM)) {
 197             if (command instanceof OnOffType) {
 198                 if (command.equals(OnOffType.ON)) {
 199                     sendCommand(MiIoCommand.START_VACUUM);
 200                     forceStatusUpdate();
 201                     return;
 202                 } else {
 203                     sendCommand(MiIoCommand.STOP_VACUUM);
 204                     miIoScheduler.schedule(() -> {
 205                         sendCommand(MiIoCommand.CHARGE);
 206                         forceStatusUpdate();
 207                     }, 2000, TimeUnit.MILLISECONDS);
 208                     return;
 209                 }
 210             }
 211         }
 212         if (channelUID.getId().equals(CHANNEL_CONTROL)) {
 213             if (command.toString().equals("vacuum")) {
 214                 sendCommand(MiIoCommand.START_VACUUM);
 215             } else if (command.toString().equals("spot")) {
 216                 sendCommand(MiIoCommand.START_SPOT);
 217             } else if (command.toString().equals("pause")) {
 218                 sendCommand(MiIoCommand.PAUSE);
 219             } else if (command.toString().equals("dock")) {
 220                 sendCommand(MiIoCommand.STOP_VACUUM);
 221                 miIoScheduler.schedule(() -> {
 222                     sendCommand(MiIoCommand.CHARGE);
 223                     forceStatusUpdate();
 224                 }, 2000, TimeUnit.MILLISECONDS);
 225                 return;
 226             } else {
 227                 logger.info("Command {} not recognised", command.toString());
 228             }
 229             forceStatusUpdate();
 230             return;
 231         }
 232         if (channelUID.getId().equals(CHANNEL_FAN_POWER)) {
 233             sendCommand(MiIoCommand.SET_MODE, "[" + command.toString() + "]");
 234             forceStatusUpdate();
 235             return;
 236         }
 237         if (channelUID.getId().equals(RobotCababilities.WATERBOX_MODE.getChannel())) {
 238             sendCommand(MiIoCommand.SET_WATERBOX_MODE, "[" + command.toString() + "]");
 239             forceStatusUpdate();
 240             return;
 241         }
 242         if (channelUID.getId().equals(RobotCababilities.SEGMENT_CLEAN.getChannel()) && !command.toString().isEmpty()
 243                 && !command.toString().contentEquals("-")) {
 244             sendCommand(MiIoCommand.START_SEGMENT, "[" + command.toString() + "]");
 245             updateState(RobotCababilities.SEGMENT_CLEAN.getChannel(), new StringType("-"));
 246             forceStatusUpdate();
 247             return;
 248         }
 249         if (channelUID.getId().equals(CHANNEL_FAN_CONTROL)) {
 250             if (Integer.valueOf(command.toString()) > 0) {
 251                 sendCommand(MiIoCommand.SET_MODE, "[" + command.toString() + "]");
 252             }
 253             forceStatusUpdate();
 254             return;
 255         }
 256         if (channelUID.getId().equals(CHANNEL_CONSUMABLE_RESET)) {
 257             sendCommand(MiIoCommand.CONSUMABLES_RESET, "[" + command.toString() + "]");
 258             updateState(CHANNEL_CONSUMABLE_RESET, new StringType("none"));
 259         }
 260     }
 261
 262     private void forceStatusUpdate() {
 263         status.invalidateValue();
 264         miIoScheduler.schedule(() -> {
 265             status.getValue();
 266         }, 3000, TimeUnit.MILLISECONDS);
 267     }
 268
 269     private void safeUpdateState(String channelID, @Nullable Integer state) {
 270         if (state != null) {
 271             updateState(channelID, new DecimalType(state));
 272         } else {
 273             logger.debug("Channel {} not update. value not available.", channelID);
 274         }
 275     }
 276
 277     private boolean updateVacuumStatus(JsonObject statusData) {
 278         StatusDTO statusInfo = GSON.fromJson(statusData, StatusDTO.class);
 279         safeUpdateState(CHANNEL_BATTERY, statusInfo.getBattery());
 280         if (statusInfo.getCleanArea() != null) {
 281             updateState(CHANNEL_CLEAN_AREA,
 282                     new QuantityType<>(statusInfo.getCleanArea() / 1000000.0, SIUnits.SQUARE_METRE));
 283         }
 284         if (statusInfo.getCleanTime() != null) {
 285             updateState(CHANNEL_CLEAN_TIME,
 286                     new QuantityType<>(TimeUnit.SECONDS.toMinutes(statusInfo.getCleanTime()), Units.MINUTE));
 287         }
 288         safeUpdateState(CHANNEL_DND_ENABLED, statusInfo.getDndEnabled());
 289
 290         if (statusInfo.getErrorCode() != null) {
 291             updateState(CHANNEL_ERROR_CODE,
 292                     new StringType(VacuumErrorType.getType(statusInfo.getErrorCode()).getDescription()));
 293             safeUpdateState(CHANNEL_ERROR_ID, statusInfo.getErrorCode());
 294         }
 295
 296         if (statusInfo.getFanPower() != null) {
 297             updateState(CHANNEL_FAN_POWER, new DecimalType(statusInfo.getFanPower()));
 298             updateState(CHANNEL_FAN_CONTROL, new DecimalType(FanModeType.getType(statusInfo.getFanPower()).getId()));
 299         }
 300         safeUpdateState(CHANNEL_IN_CLEANING, statusInfo.getInCleaning());
 301         safeUpdateState(CHANNEL_MAP_PRESENT, statusInfo.getMapPresent());
 302         if (statusInfo.getState() != null) {
 303             stateId = statusInfo.getState();
 304             StatusType state = StatusType.getType(statusInfo.getState());
 305             updateState(CHANNEL_STATE, new StringType(state.getDescription()));
 306             updateState(CHANNEL_STATE_ID, new DecimalType(statusInfo.getState()));
 307
 308             State vacuum = OnOffType.OFF;
 309             String control;
 310             switch (state) {
 311                 case ZONE:
 312                 case ROOM:
 313                 case CLEANING:
 314                 case RETURNING:
 315                     control = "vacuum";
 316                     vacuum = OnOffType.ON;
 317                     break;
 318                 case CHARGING:
 319                 case CHARGING_ERROR:
 320                 case DOCKING:
 321                 case FULL:
 322                     control = "dock";
 323                     break;
 324                 case SLEEPING:
 325                 case PAUSED:
 326                 case IDLE:
 327                     control = "pause";
 328                     break;
 329                 case SPOTCLEAN:
 330                     control = "spot";
 331                     vacuum = OnOffType.ON;
 332                     break;
 333                 default:
 334                     control = "undef";
 335                     break;
 336             }
 337             if ("undef".equals(control)) {
 338                 updateState(CHANNEL_CONTROL, UnDefType.UNDEF);
 339             } else {
 340                 updateState(CHANNEL_CONTROL, new StringType(control));
 341             }
 342             updateState(CHANNEL_VACUUM, vacuum);
 343         }
 344         if (deviceCapabilities.containsKey(RobotCababilities.WATERBOX_MODE)) {
 345             safeUpdateState(RobotCababilities.WATERBOX_MODE.getChannel(), statusInfo.getWaterBoxMode());
 346         }
 347         if (deviceCapabilities.containsKey(RobotCababilities.WATERBOX_STATUS)) {
 348             safeUpdateState(RobotCababilities.WATERBOX_STATUS.getChannel(), statusInfo.getWaterBoxStatus());
 349         }
 350         if (deviceCapabilities.containsKey(RobotCababilities.WATERBOX_CARRIAGE)) {
 351             safeUpdateState(RobotCababilities.WATERBOX_CARRIAGE.getChannel(), statusInfo.getWaterBoxCarriageStatus());
 352         }
 353         if (deviceCapabilities.containsKey(RobotCababilities.LOCKSTATUS)) {
 354             safeUpdateState(RobotCababilities.LOCKSTATUS.getChannel(), statusInfo.getLockStatus());
 355         }
 356         if (deviceCapabilities.containsKey(RobotCababilities.MOP_FORBIDDEN)) {
 357             safeUpdateState(RobotCababilities.MOP_FORBIDDEN.getChannel(), statusInfo.getMopForbiddenEnable());
 358         }
 359         if (deviceCapabilities.containsKey(RobotCababilities.LOCATING)) {
 360             safeUpdateState(RobotCababilities.LOCATING.getChannel(), statusInfo.getIsLocating());
 361         }
 362         return true;
 363     }
 364
 365     private boolean updateConsumables(JsonObject consumablesData) {
 366         int mainBrush = consumablesData.get("main_brush_work_time").getAsInt();
 367         int sideBrush = consumablesData.get("side_brush_work_time").getAsInt();
 368         int filter = consumablesData.get("filter_work_time").getAsInt();
 369         int sensor = consumablesData.get("sensor_dirty_time").getAsInt();
 370         updateState(CHANNEL_CONSUMABLE_MAIN_TIME,
 371                 new QuantityType<>(ConsumablesType.remainingHours(mainBrush, ConsumablesType.MAIN_BRUSH), Units.HOUR));
 372         updateState(CHANNEL_CONSUMABLE_MAIN_PERC,
 373                 new DecimalType(ConsumablesType.remainingPercent(mainBrush, ConsumablesType.MAIN_BRUSH)));
 374         updateState(CHANNEL_CONSUMABLE_SIDE_TIME,
 375                 new QuantityType<>(ConsumablesType.remainingHours(sideBrush, ConsumablesType.SIDE_BRUSH), Units.HOUR));
 376         updateState(CHANNEL_CONSUMABLE_SIDE_PERC,
 377                 new DecimalType(ConsumablesType.remainingPercent(sideBrush, ConsumablesType.SIDE_BRUSH)));
 378         updateState(CHANNEL_CONSUMABLE_FILTER_TIME,
 379                 new QuantityType<>(ConsumablesType.remainingHours(filter, ConsumablesType.FILTER), Units.HOUR));
 380         updateState(CHANNEL_CONSUMABLE_FILTER_PERC,
 381                 new DecimalType(ConsumablesType.remainingPercent(filter, ConsumablesType.FILTER)));
 382         updateState(CHANNEL_CONSUMABLE_SENSOR_TIME,
 383                 new QuantityType<>(ConsumablesType.remainingHours(sensor, ConsumablesType.SENSOR), Units.HOUR));
 384         updateState(CHANNEL_CONSUMABLE_SENSOR_PERC,
 385                 new DecimalType(ConsumablesType.remainingPercent(sensor, ConsumablesType.SENSOR)));
 386         return true;
 387     }
 388
 389     private boolean updateDnD(JsonObject dndData) {
 390         logger.trace("Do not disturb data: {}", dndData.toString());
 391         updateState(CHANNEL_DND_FUNCTION, new DecimalType(dndData.get("enabled").getAsBigDecimal()));
 392         updateState(CHANNEL_DND_START, new StringType(String.format("%02d:%02d", dndData.get("start_hour").getAsInt(),
 393                 dndData.get("start_minute").getAsInt())));
 394         updateState(CHANNEL_DND_END, new StringType(
 395                 String.format("%02d:%02d", dndData.get("end_hour").getAsInt(), dndData.get("end_minute").getAsInt())));
 396         return true;
 397     }
 398
 399     private boolean updateHistory(JsonArray historyData) {
 400         logger.trace("Cleaning history data: {}", historyData.toString());
 401         updateState(CHANNEL_HISTORY_TOTALTIME,
 402                 new QuantityType<>(TimeUnit.SECONDS.toMinutes(historyData.get(0).getAsLong()), Units.MINUTE));
 403         updateState(CHANNEL_HISTORY_TOTALAREA,
 404                 new QuantityType<>(historyData.get(1).getAsDouble() / 1000000D, SIUnits.SQUARE_METRE));
 405         updateState(CHANNEL_HISTORY_COUNT, new DecimalType(historyData.get(2).toString()));
 406         if (historyData.get(3).getAsJsonArray().size() > 0) {
 407             String lastClean = historyData.get(3).getAsJsonArray().get(0).getAsString();
 408             if (!lastClean.equals(lastHistoryId)) {
 409                 lastHistoryId = lastClean;
 410                 sendCommand(MiIoCommand.CLEAN_RECORD_GET, "[" + lastClean + "]");
 411             }
 412         }
 413         return true;
 414     }
 415
 416     private void updateHistoryRecord(JsonArray historyData) {
 417         ZonedDateTime startTime = ZonedDateTime.ofInstant(Instant.ofEpochSecond(historyData.get(0).getAsLong()),
 418                 ZoneId.systemDefault());
 419         ZonedDateTime endTime = ZonedDateTime.ofInstant(Instant.ofEpochSecond(historyData.get(1).getAsLong()),
 420                 ZoneId.systemDefault());
 421         long duration = TimeUnit.SECONDS.toMinutes(historyData.get(2).getAsLong());
 422         double area = historyData.get(3).getAsDouble() / 1000000D;
 423         int error = historyData.get(4).getAsInt();
 424         int finished = historyData.get(5).getAsInt();
 425         JsonObject historyRecord = new JsonObject();
 426         historyRecord.addProperty("start", startTime.toString());
 427         historyRecord.addProperty("end", endTime.toString());
 428         historyRecord.addProperty("duration", duration);
 429         historyRecord.addProperty("area", area);
 430         historyRecord.addProperty("error", error);
 431         historyRecord.addProperty("finished", finished);
 432         updateState(CHANNEL_HISTORY_START_TIME, new DateTimeType(startTime));
 433         updateState(CHANNEL_HISTORY_END_TIME, new DateTimeType(endTime));
 434         updateState(CHANNEL_HISTORY_DURATION, new QuantityType<>(duration, Units.MINUTE));
 435         updateState(CHANNEL_HISTORY_AREA, new QuantityType<>(area, SIUnits.SQUARE_METRE));
 436         updateState(CHANNEL_HISTORY_ERROR, new DecimalType(error));
 437         updateState(CHANNEL_HISTORY_FINISH, new DecimalType(finished));
 438         updateState(CHANNEL_HISTORY_RECORD, new StringType(historyRecord.toString()));
 439     }
 440
 441     @Override
 442     protected boolean skipUpdate() {
 443         if (!hasConnection()) {
 444             logger.debug("Skipping periodic update for '{}'. No Connection", getThing().getUID().toString());
 445             return true;
 446         }
 447         if (ThingStatusDetail.CONFIGURATION_ERROR.equals(getThing().getStatusInfo().getStatusDetail())) {
 448             logger.debug("Skipping periodic update for '{}' UID '{}'. Thing Status", getThing().getUID().toString(),
 449                     getThing().getStatusInfo().getStatusDetail());
 450             refreshNetwork();
 451             return true;
 452         }
 453         final MiIoAsyncCommunication mc = miioCom;
 454         if (mc != null && mc.getQueueLength() > MAX_QUEUE) {
 455             logger.debug("Skipping periodic update for '{}'. {} elements in queue.", getThing().getUID().toString(),
 456                     mc.getQueueLength());
 457             return true;
 458         }
 459         return false;
 460     }
 461
 462     @Override
 463     protected synchronized void updateData() {
 464         if (!hasConnection() || skipUpdate()) {
 465             return;
 466         }
 467         logger.debug("Periodic update for '{}' ({})", getThing().getUID().toString(), getThing().getThingTypeUID());
 468         try {
 469             dnd.getValue();
 470             history.getValue();
 471             status.getValue();
 472             refreshNetwork();
 473             consumables.getValue();
 474             if (lastMap.isEmpty() || stateId != 8) {
 475                 if (isLinked(mapChannelUid)) {
 476                     map.getValue();
 477                 }
 478             }
 479             for (RobotCababilities cmd : FEATURES_CHANNELS) {
 480                 if (isLinked(cmd.getChannel())) {
 481                     sendCommand(cmd.getCommand());
 482                 }
 483             }
 484         } catch (Exception e) {
 485             logger.debug("Error while updating '{}': '{}", getThing().getUID().toString(), e.getLocalizedMessage());
 486         }
 487     }
 488
 489     @Override
 490     public void initialize() {
 491         super.initialize();
 492         hasChannelStructure = false;
 493     }
 494
 495     @Override
 496     protected boolean initializeData() {
 497         updateState(CHANNEL_CONSUMABLE_RESET, new StringType("none"));
 498         return super.initializeData();
 499     }
 500
 501     @Override
 502     public void onMessageReceived(MiIoSendCommand response) {
 503         super.onMessageReceived(response);
 504         if (response.isError()) {
 505             return;
 506         }
 507         switch (response.getCommand()) {
 508             case GET_STATUS:
 509                 if (response.getResult().isJsonArray()) {
 510                     JsonObject statusResponse = response.getResult().getAsJsonArray().get(0).getAsJsonObject();
 511                     if (!hasChannelStructure) {
 512                         setCapabilities(statusResponse);
 513                         createCapabilityChannels();
 514                     }
 515                     updateVacuumStatus(statusResponse);
 516                 }
 517                 break;
 518             case CONSUMABLES_GET:
 519                 if (response.getResult().isJsonArray()) {
 520                     updateConsumables(response.getResult().getAsJsonArray().get(0).getAsJsonObject());
 521                 }
 522                 break;
 523             case DND_GET:
 524                 if (response.getResult().isJsonArray()) {
 525                     updateDnD(response.getResult().getAsJsonArray().get(0).getAsJsonObject());
 526                 }
 527                 break;
 528             case CLEAN_SUMMARY_GET:
 529                 if (response.getResult().isJsonArray()) {
 530                     updateHistory(response.getResult().getAsJsonArray());
 531                 }
 532                 break;
 533             case CLEAN_RECORD_GET:
 534                 if (response.getResult().isJsonArray() && response.getResult().getAsJsonArray().size() > 0
 535                         && response.getResult().getAsJsonArray().get(0).isJsonArray()) {
 536                     updateHistoryRecord(response.getResult().getAsJsonArray().get(0).getAsJsonArray());
 537                 } else {
 538                     logger.debug("Could not extract cleaning history record from: {}", response);
 539                 }
 540                 break;
 541             case GET_MAP:
 542                 if (response.getResult().isJsonArray()) {
 543                     String mapresponse = response.getResult().getAsJsonArray().get(0).getAsString();
 544                     if (!mapresponse.contentEquals("retry") && !mapresponse.contentEquals(lastMap)) {
 545                         lastMap = mapresponse;
 546                         miIoScheduler.submit(() -> updateState(CHANNEL_VACUUM_MAP, getMap(mapresponse)));
 547                     }
 548                 }
 549                 break;
 550             case GET_MAP_STATUS:
 551             case GET_SEGMENT_STATUS:
 552             case GET_LED_STATUS:
 553                 updateNumericChannel(response);
 554                 break;
 555             case GET_CARPET_MODE:
 556             case GET_FW_FEATURES:
 557             case GET_CUSTOMIZED_CLEAN_MODE:
 558             case GET_MULTI_MAP_LIST:
 559             case GET_ROOM_MAPPING:
 560                 for (RobotCababilities cmd : FEATURES_CHANNELS) {
 561                     if (response.getCommand().getCommand().contentEquals(cmd.getCommand())) {
 562                         updateState(cmd.getChannel(), new StringType(response.getResult().toString()));
 563                         break;
 564                     }
 565                 }
 566                 break;
 567             default:
 568                 break;
 569         }
 570     }
 571
 572     private void updateNumericChannel(MiIoSendCommand response) {
 573         RobotCababilities capabilityChannel = null;
 574         for (RobotCababilities cmd : FEATURES_CHANNELS) {
 575             if (response.getCommand().getCommand().contentEquals(cmd.getCommand())) {
 576                 capabilityChannel = cmd;
 577                 break;
 578             }
 579         }
 580         if (capabilityChannel != null) {
 581             if (response.getResult().isJsonArray() && response.getResult().getAsJsonArray().get(0).isJsonPrimitive()) {
 582                 try {
 583                     Integer stat = response.getResult().getAsJsonArray().get(0).getAsInt();
 584                     updateState(capabilityChannel.getChannel(), new DecimalType(stat));
 585                     return;
 586                 } catch (ClassCastException | IllegalStateException e) {
 587                     logger.debug("Could not update numeric channel {} with '{}': {}", capabilityChannel.getChannel(),
 588                             response.getResult(), e.getMessage());
 589                 }
 590             } else {
 591                 logger.debug("Could not update numeric channel {} with '{}': Not in expected format",
 592                         capabilityChannel.getChannel(), response.getResult());
 593             }
 594             updateState(capabilityChannel.getChannel(), UnDefType.UNDEF);
 595         }
 596     }
 597
 598     private void setCapabilities(JsonObject statusResponse) {
 599         for (RobotCababilities capability : RobotCababilities.values()) {
 600             if (statusResponse.has(capability.getStatusFieldName())) {
 601                 deviceCapabilities.putIfAbsent(capability, false);
 602                 logger.debug("Setting additional vacuum {}", capability);
 603             }
 604         }
 605     }
 606
 607     private void createCapabilityChannels() {
 608         ThingBuilder thingBuilder = editThing();
 609         int cnt = 0;
 610
 611         for (Entry<RobotCababilities, Boolean> robotCapability : deviceCapabilities.entrySet()) {
 612             RobotCababilities capability = robotCapability.getKey();
 613             Boolean channelCreated = robotCapability.getValue();
 614             if (!channelCreated) {
 615                 if (thing.getChannels().stream()
 616                         .anyMatch(ch -> ch.getUID().getId().equalsIgnoreCase(capability.getChannel()))) {
 617                     logger.debug("Channel already available...skip creation of channel '{}'.", capability.getChannel());
 618                     deviceCapabilities.replace(capability, true);
 619                     continue;
 620                 }
 621                 logger.debug("Creating dynamic channel for capability {}", capability);
 622                 ChannelType channelType = channelTypeRegistry.getChannelType(capability.getChannelType());
 623                 if (channelType != null) {
 624                     logger.debug("Found channelType '{}' for capability {}", channelType, capability.name());
 625                     ChannelUID channelUID = new ChannelUID(getThing().getUID(), capability.getChannel());
 626                     Channel channel = ChannelBuilder.create(channelUID, channelType.getItemType())
 627                             .withType(capability.getChannelType()).withLabel(channelType.getLabel()).build();
 628                     thingBuilder.withChannel(channel);
 629                     cnt++;
 630                 } else {
 631                     logger.debug("ChannelType {} not found (Unexpected). Available types:",
 632                             capability.getChannelType());
 633                     for (ChannelType ct : channelTypeRegistry.getChannelTypes()) {
 634                         logger.debug("Available channelType: '{}' '{}' '{}'", ct.getUID(), ct.toString(),
 635                                 ct.getConfigDescriptionURI());
 636                     }
 637                 }
 638             }
 639         }
 640         if (cnt > 0) {
 641             updateThing(thingBuilder.build());
 642         }
 643         hasChannelStructure = true;
 644     }
 645
 646     private State getMap(String map) {
 647         final MiIoBindingConfiguration configuration = this.configuration;
 648         if (configuration != null && cloudConnector.isConnected()) {
 649             try {
 650                 final @Nullable RawType mapDl = cloudConnector.getMap(map, configuration.cloudServer);
 651                 if (mapDl != null) {
 652                     byte[] mapData = mapDl.getBytes();
 653                     RRMapDraw rrMap = RRMapDraw.loadImage(new ByteArrayInputStream(mapData));
 654                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 655                     if (logger.isDebugEnabled()) {
 656                         final String mapPath = BINDING_USERDATA_PATH + File.separator + map
 657                                 + DATEFORMATTER.format(new Date()) + ".rrmap";
 658                         CloudUtil.writeBytesToFileNio(mapData, mapPath);
 659                         logger.debug("Mapdata saved to {}", mapPath);
 660                     }
 661                     ImageIO.write(rrMap.getImage(MAP_SCALE), "jpg", baos);
 662                     byte[] byteArray = baos.toByteArray();
 663                     if (byteArray != null && byteArray.length > 0) {
 664                         return new RawType(byteArray, "image/jpeg");
 665                     } else {
 666                         logger.debug("Mapdata empty removing image");
 667                         return UnDefType.UNDEF;
 668                     }
 669                 }
 670             } catch (MiCloudException e) {
 671                 logger.debug("Error getting data from Xiaomi cloud. Mapdata could not be updated: {}", e.getMessage());
 672             } catch (IOException e) {
 673                 logger.debug("Mapdata could not be updated: {}", e.getMessage());
 674             }
 675         } else {
 676             logger.debug("Not connected to Xiaomi cloud. Cannot retreive new map: {}", map);
 677         }
 678         return UnDefType.UNDEF;
 679     }
 680 }