import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
public void startAutomaticRefresh() {
    // refreshJob.cancel(true);
    refreshJob = scheduler.scheduleWithFixedDelay(() -> {
        try {
            boolean success = updateDraytonWiserData();
            if (success) {
                String thingUID = getThing().getUID().getId();
                updateState(new ChannelUID(getThing().getUID(), CHANNEL_TEMPERATURE), getTemperature(thingUID));
                updateState(new ChannelUID(getThing().getUID(), CHANNEL_HUMIDITY), getHumidity(thingUID));
                updateState(new ChannelUID(getThing().getUID(), CHANNEL_SETPOINT), getSetPoint(thingUID));
            }
        } catch (Exception e) {
            logger.debug("Exception occurred during execution: {}", e.getMessage(), e);
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
        }
    }, 0, 60, TimeUnit.SECONDS);
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
private MobileDevice getMobileDevice() throws IOException, TadoClientException {
    try {
        MobileDevice device = getApi().getMobileDeviceDetails(getHomeId(), configuration.id);
        if (device == null) {
            String message = "Mobile device with id " + configuration.id + " unknown or does not belong to home "
                    + getHomeId();
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, message);
            throw new IOException(message);
        }

        return device;
    } catch (IOException | TadoClientException e) {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
                "Could not connect to server due to " + e.getMessage());
        throw e;
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
private void startAutomaticRefresh() {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            logger.debug("Refreshing {}", thing.getUID().getAsString());
            try {
                boolean success = updateData();
                if (success) {
                    updateState(new ChannelUID(getThing().getUID(), CHANNEL_SWITCH), getState());
                    updateState(new ChannelUID(getThing().getUID(), CHANNEL_WATTAGE), getWattage());
                    updateState(new ChannelUID(getThing().getUID(), CHANNEL_TOTAL), getTotal());
                    updateState(new ChannelUID(getThing().getUID(), CHANNEL_SYSINFO), getSysinfo());
                }
            } catch (Exception e) {
                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
                logger.debug("Exception occurred during execution", e);
            }
        }
    };

    refreshJob = scheduler.scheduleWithFixedDelay(runnable, 0, refresh, TimeUnit.SECONDS);
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
private synchronized boolean updateData() {
    logger.trace("Updating data for Plug type {}", thing.getThingTypeUID().getAsString());
    try {
        sysinfoData = plug.sendCommand(HS110.Command.SYSINFO);
        if (thing.getThingTypeUID().equals(THING_TYPE_HS110)) {
            energyData = plug.sendCommand(HS110.Command.ENERGY);
            logger.debug("Updated energy Data for {}: {}", thing.getUID(), energyData);
        }
        logger.debug("Updated sysinfo Data for {}: {}", thing.getUID(), sysinfoData);
        return true;

    } catch (IOException e) {
        logger.warn("Error accessing plug ", e);
        energyData = null;
        sysinfoData = null;
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
        return false;
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public Collection<ConfigStatusMessage> getConfigStatus() {

    Collection<ConfigStatusMessage> configStatus = new ArrayList<>();

    try {
        InetAddress ip = InetAddress.getByName(plug.ip);
        if (!ip.isReachable(500)) {
            configStatus.add(
                    ConfigStatusMessage.Builder.error("offline").withMessageKeySuffix("ip unreachable").build());
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR);
        }
    } catch (IOException e) {
        logger.debug("Communication error ocurred reaching the device ", e);
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
    }

    return configStatus;
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void networkStateUpdated(final ZigBeeTransportState state) {
    switch (state) {
        case UNINITIALISED:
            break;
        case INITIALISING:
            break;
        case ONLINE:
            updateStatus(ThingStatus.ONLINE);
            break;
        case OFFLINE:
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.NONE,
                    getI18nConstant(ZigBeeBindingConstants.OFFLINE_STARTUP_FAIL));
            break;
        default:
            break;
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void initialize() {
    final String configAddress = (String) getConfig().get(ZigBeeBindingConstants.CONFIGURATION_MACADDRESS);
    logger.debug("{}: Initializing ZigBee thing handler {}", configAddress, getThing().getUID());

    if (configAddress == null || configAddress.length() == 0) {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
                getI18nConstant(ZigBeeBindingConstants.OFFLINE_NO_ADDRESS));
        return;
    }
    nodeIeeeAddress = new IeeeAddress(configAddress);

    updateStatus(ThingStatus.UNKNOWN);

    if (getBridge() != null) {
        bridgeStatusChanged(getBridge().getStatusInfo());
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
/**
 * Initialize the connection to Nest.
 */
@Override
public void initialize() {
    logger.debug("Initializing Nest bridge handler");

    config = getConfigAs(NestBridgeConfiguration.class);
    authorizer = new NestAuthorizer(config);
    updateStatus(ThingStatus.UNKNOWN, ThingStatusDetail.NONE, "Starting poll query");

    initializeJob = scheduler.schedule(() -> {
        try {
            logger.debug("Product ID      {}", config.productId);
            logger.debug("Product Secret  {}", config.productSecret);
            logger.debug("Pincode         {}", config.pincode);
            logger.debug("Access Token    {}", getExistingOrNewAccessToken());
            redirectUrlSupplier = new NestRedirectUrlSupplier(getHttpHeaders());
            restartStreamingUpdates();
        } catch (InvalidAccessTokenException e) {
            logger.debug("Invalid access token", e);
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
                    "Token is invalid and could not be refreshed: " + e.getMessage());
        }
    }, 0, TimeUnit.SECONDS);

    logger.debug("Finished initializing Nest bridge handler");
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
/**
 * Creates a session manager object and the send queue. The initial IP address may be null
 * or is not matching with the real IP address of the bridge. The session manager will send
 * a broadcast packet to find the bridge with the respective bridge ID and will change the
 * IP address of the send queue object accordingly.
 *
 * The keep alive timer that is also setup here, will send keep alive packets periodically.
 * If the bridge doesn't respond anymore (e.g. DHCP IP change), the initial session handshake
 * starts all over again.
 */
@Override
protected void startConnectAndKeepAlive(InetAddress addr) {
    dispose();

    int port = getPort(MilightBindingConstants.PORT_VER6);
    if (port == 0) {
        return;
    }

    com.setAddress(addr);
    com.setPort(port);
    com.start();

    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_PENDING, "Waiting for session");
    session = new MilightV6SessionManager(com, bridgeid, scheduler, this, addr);
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void initialize() {
    if (getConfig().get(IP_ADDRESS) != null && !getConfig().get(IP_ADDRESS).equals("")) {
        transceiver.registerHandler(this);

        if (pollingJob == null || pollingJob.isCancelled()) {
            try {
                pollingJob = scheduler.scheduleWithFixedDelay(pollingRunnable, 0,
                        ((BigDecimal) getConfig().get(POLLING_REFRESH_INTERVAL)).intValue(), TimeUnit.SECONDS);
            } catch (Exception e) {
                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.NONE,
                        "An exception occurred while scheduling the polling job");
            }
        }

        cache = new ExpiringCacheMap<>(
                Math.max((((BigDecimal) getConfig().get(POLLING_REFRESH_INTERVAL)).intValue()) - 5, 0) * 1000);

        cache.put(CACHE_REPORT_1, () -> transceiver.send("report 1", getHandler()));
        cache.put(CACHE_REPORT_2, () -> transceiver.send("report 2", getHandler()));
        cache.put(CACHE_REPORT_3, () -> transceiver.send("report 3", getHandler()));
    } else {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
                "IP address or port number not set");
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void initialize() {
    logger.debug("Niko Home Control: initializing bridge handler");

    Configuration config = this.getConfig();
    InetAddress addr = getAddr();
    int port = getPort();

    logger.debug("Niko Home Control: bridge handler host {}, port {}", addr, port);

    if (addr != null) {
        createCommunicationObject(addr, port);
    } else {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR,
                "Niko Home Control: cannot resolve bridge IP with hostname " + config.get(CONFIG_HOST_NAME));
    }

}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
/**
 * Updates the thing status based on device status.
 */
private void updateStatus(HmDevice device) throws BridgeHandlerNotAvailableException, IOException {
    loadHomematicChannelValues(device.getChannel(0));

    ThingStatus oldStatus = thing.getStatus();
    ThingStatus newStatus = ThingStatus.ONLINE;
    ThingStatusDetail newDetail = ThingStatusDetail.NONE;

    if (device.isFirmwareUpdating()) {
        newStatus = ThingStatus.OFFLINE;
        newDetail = ThingStatusDetail.FIRMWARE_UPDATING;
    } else if (device.isUnreach()) {
        newStatus = ThingStatus.OFFLINE;
        newDetail = ThingStatusDetail.COMMUNICATION_ERROR;
    } else if (device.isConfigPending() || device.isUpdatePending()) {
        newDetail = ThingStatusDetail.CONFIGURATION_PENDING;
    }

    if (thing.getStatus() != newStatus || thing.getStatusInfo().getStatusDetail() != newDetail) {
        updateStatus(newStatus, newDetail);
    }
    if (oldStatus == ThingStatus.OFFLINE && newStatus == ThingStatus.ONLINE) {
        initialize();
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void initialize() {
    try {
        config = getThing().getConfiguration();
        host = InetAddress.getByName(config.get(HOST).toString());
        port = getConfigInteger(config, PORT);
    } catch (UnknownHostException e) {
        logger.warn("Bridge IP/PORT config is not set or not valid");
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR);
        return;
    }
    logger.debug("Init socket on Port: {}", port);
    socket = new XiaomiBridgeSocket(port);
    socket.intialize();
    socket.registerListener(this);

    scheduler.schedule(() -> {
        discoverItems();
    }, 1, TimeUnit.SECONDS);
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
private void updateThingStatus() {
    if (getItemId() != null) {
        // note: this call implicitly registers our handler as a listener on the bridge, if it's not already
        if (getXiaomiBridgeHandler() != null) {
            Bridge bridge = getBridge();
            ThingStatus bridgeStatus = (bridge == null) ? null : bridge.getStatus();
            if (bridgeStatus == ThingStatus.ONLINE) {
                ThingStatus itemStatus = getThing().getStatus();
                boolean hasItemActivity = getXiaomiBridgeHandler().hasItemActivity(getItemId(),
                        ONLINE_TIMEOUT_MILLIS);
                ThingStatus newStatus = hasItemActivity ? ThingStatus.ONLINE : ThingStatus.OFFLINE;

                if (!newStatus.equals(itemStatus)) {
                    updateStatus(newStatus);
                }
            } else {
                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.BRIDGE_OFFLINE);
            }
        } else {
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR);
        }
    } else {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR);
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
private synchronized void update() {
    logger.debug("Updating WiFiLED data '{}'", getThing().getUID());

    try {
        LEDStateDTO ledState = driver.getLEDStateDTO();
        HSBType color = new HSBType(ledState.getHue(), ledState.getSaturation(), ledState.getBrightness());
        updateState(WiFiLEDBindingConstants.CHANNEL_POWER, ledState.power);
        updateState(WiFiLEDBindingConstants.CHANNEL_COLOR, color);
        updateState(WiFiLEDBindingConstants.CHANNEL_WHITE, ledState.getWhite());
        updateState(WiFiLEDBindingConstants.CHANNEL_PROGRAM, ledState.getProgram());
        updateState(WiFiLEDBindingConstants.CHANNEL_PROGRAM_SPEED, ledState.getProgramSpeed());

        if (getThing().getStatus().equals(ThingStatus.OFFLINE)) {
            updateStatus(ThingStatus.ONLINE);
        }
    } catch (IOException e) {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void initialize() {
    config = getConfigAs(SourceConfig.class);
    scheduler.scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
            try {
                refresh();
                updateStatus(ThingStatus.ONLINE);
            } catch (Exception e) {
                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
                        e.getClass().getName() + ":" + e.getMessage());
                logger.debug("Error refreshing source {} ", getThing().getUID(), e);
            }
        }

    }, 0, config.refreshInterval, TimeUnit.SECONDS);
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
/**
 * Overrides the status changed to simply call the {@link #_wrappedCallback}
 *
 * @param status the new status
 * @param detail the new detail
 * @param msg the new message
 */
@Override
public void statusChanged(ThingStatus status, ThingStatusDetail detail, String msg) {
    _statusLock.lock();
    try {
        // Simply return we match the last status change (prevents loops if changing to the same status)
        if (status == _lastThingStatus && detail == _lastThingStatusDetail) {
            return;
        }

        _lastThingStatus = status;
        _lastThingStatusDetail = detail;
    } finally {
        _statusLock.unlock();
    }
    // If we got this far - call the underlying one
    _wrappedCallback.statusChanged(status, detail, msg);

}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
@Override
public void initialize() {
    logger.debug("Initializing Z-Way device handler ...");

    // Set thing status to a valid status
    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_PENDING,
            "Checking configuration and bridge...");

    // Configuration - thing status update with a error message
    mConfig = loadAndCheckConfiguration();

    if (mConfig != null) {
        logger.debug("Configuration complete: {}", mConfig);

        // Start an extra thread to check the connection, because it takes sometimes more
        // than 5000 milliseconds and the handler will suspend (ThingStatus.UNINITIALIZED).
        scheduler.schedule(new Initializer(), 2, TimeUnit.SECONDS);
    } else {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "Z-Way node id required!");
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
/**
 * Calls createCommunicationObject if the host name is configured correctly.
 */
@Override
public void initialize() {
    // Determine the zone of this thing
    String zoneName = (String) thing.getConfiguration().get(YamahaReceiverBindingConstants.CONFIG_ZONE);
    zone = zoneName != null ? YamahaReceiverBindingConstants.Zone.valueOf(zoneName) : null;
    if (zoneName == null || zone == null) {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "Zone not set!");
        return;
    }

    channelsTypeProviderPreset = new ChannelsTypeProviderPreset(thing.getUID());
    channelsTypeProviderAvailableInputs = new ChannelsTypeProviderAvailableInputs(thing.getUID());
    // Allow bundleContext to be null for tests
    if (bundleContext != null) {
        servicePreset = bundleContext.registerService(ChannelTypeProvider.class.getName(),
                channelsTypeProviderPreset, new Hashtable<>());
        serviceAvailableInputs = bundleContext.registerService(ChannelTypeProvider.class.getName(),
                channelsTypeProviderAvailableInputs, new Hashtable<>());
    }

    YamahaBridgeHandler bridgeHandler = getBridgeHandler();
    if (bridgeHandler != null) {
        bridgeStatusChanged(bridgeHandler.getThing().getStatusInfo());
    }
}
 

import org.eclipse.smarthome.core.thing.ThingStatusDetail; //导入依赖的package包/类
private synchronized void updateData() {
    logger.debug("Update SMAEnergyMeter data '{}'", getThing().getUID());

    try {
        energyMeter.update();

        updateState(CHANNEL_POWER_IN, energyMeter.getPowerIn());
        updateState(CHANNEL_POWER_OUT, energyMeter.getPowerOut());
        updateState(CHANNEL_ENERGY_IN, energyMeter.getEnergyIn());
        updateState(CHANNEL_ENERGY_OUT, energyMeter.getEnergyOut());

        if (getThing().getStatus().equals(ThingStatus.OFFLINE)) {
            updateStatus(ThingStatus.ONLINE);
        }
    } catch (IOException e) {
        updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
    }
}