Units (BCO DAL Remote 1.3.2 API)

java.lang.Object
- org.openbase.bco.dal.remote.unit.Units

```
public class Units
extends Object
```
Author:

Divine Threepwood This is the global unit remote pool of bco. It allows the access and control of all bco units without taking care of the internal unit remote instances. All requested instances are already initialized and activated. Even the shutdown of all instances is managed by this pool.

Field Summary

Fields
Modifier and Type	Field and Description
`static Class<? extends AgentRemote>`	`AGENT`
`static Class<? extends AppRemote>`	`APP`
`static Class<? extends AgentRemote>`	`BASE_UNIT_AGENT` BASE Unit remote-class-constants which can be used to request unit remotes.
`static Class<? extends AppRemote>`	`BASE_UNIT_APP`
`static Class<? extends ConnectionRemote>`	`BASE_UNIT_CONNECTION`
`static Class<? extends ConnectionRemote>`	`BASE_UNIT_CONNECTION_DOOR`
`static Class<? extends ConnectionRemote>`	`BASE_UNIT_CONNECTION_PASSAGE`
`static Class<? extends ConnectionRemote>`	`BASE_UNIT_CONNECTION_WINDOW`
`static Class<? extends DeviceRemote>`	`BASE_UNIT_DEVICE`
`static Class<? extends LocationRemote>`	`BASE_UNIT_LOCATION`
`static Class<? extends SceneRemote>`	`BASE_UNIT_SCENE`
`static Class<? extends UserRemote>`	`BASE_UNIT_USER`
`static Class<? extends BatteryRemote>`	`BATTERY`
`static Class<? extends ButtonRemote>`	`BUTTON`
`static Class<? extends ColorableLightRemote>`	`COLORABLE_LIGHT`
`static Class<? extends ConnectionRemote>`	`CONNECTION`
`static Class<? extends BatteryRemote>`	`DAL_UNIT_BATTERY`
`static Class<? extends ButtonRemote>`	`DAL_UNIT_BUTTON`
`static Class<? extends ColorableLightRemote>`	`DAL_UNIT_COLORABLE_LIGHT`
`static Class<? extends DimmableLightRemote>`	`DAL_UNIT_DIMMABLE_LIGHT`
`static Class<? extends HandleRemote>`	`DAL_UNIT_HANDLE`
`static Class<? extends LightRemote>`	`DAL_UNIT_LIGHT` DAL Unit remote-class-constants which can be used to request unit remotes.
`static Class<? extends MonitorRemote>`	`DAL_UNIT_MONITOR`
`static Class<? extends MotionDetectorRemote>`	`DAL_UNIT_MOTION_DETECTOR`
`static Class<? extends PowerConsumptionSensorRemote>`	`DAL_UNIT_POWER_CONSUMPTION_SENSOR`
`static Class<? extends PowerSwitchRemote>`	`DAL_UNIT_POWER_SWITCH`
`static Class<? extends ReedContactRemote>`	`DAL_UNIT_REED_CONTACT`
`static Class<? extends RollerShutterRemote>`	`DAL_UNIT_ROLLER_SHUTTER`
`static Class<? extends SmokeDetectorRemote>`	`DAL_UNIT_SMOKE_DETECTOR`
`static Class<? extends TamperDetectorRemote>`	`DAL_UNIT_TAMPER_DETECTOR`
`static Class<? extends TemperatureControllerRemote>`	`DAL_UNIT_TEMPERATURE_CONTROLLER`
`static Class<? extends TemperatureSensorRemote>`	`DAL_UNIT_TEMPERATURE_SENSOR`
`static Class<? extends DeviceRemote>`	`DEVICE`
`static Class<? extends DimmableLightRemote>`	`DIMMABLE_LIGHT`
`static Class<? extends ConnectionRemote>`	`DOOR`
`static Class<? extends HandleRemote>`	`HANDLE`
`static Units`	`instance`
`static Class<? extends LightRemote>`	`LIGHT`
`static Class<? extends ColorableLightRemote>`	`LIGHT_COLORABLE`
`static Class<? extends DimmableLightRemote>`	`LIGHT_DIMMABLE`
`static Class<? extends LocationRemote>`	`LOCATION`
`static Class<? extends MonitorRemote>`	`MONITOR`
`static Class<? extends MotionDetectorRemote>`	`MOTION_DETECTOR`
`static Class<? extends ConnectionRemote>`	`PASSAGE`
`static Class<? extends PowerConsumptionSensorRemote>`	`POWER_CONSUMPTION_SENSOR`
`static Class<? extends PowerSwitchRemote>`	`POWER_SWITCH`
`static Class<? extends ReedContactRemote>`	`REED_CONTACT`
`static Class<? extends RollerShutterRemote>`	`ROLLER_SHUTTER`
`static Class<? extends SceneRemote>`	`SCENE`
`static Class<? extends SmokeDetectorRemote>`	`SMOKE_DETECTOR`
`static Class<? extends TamperDetectorRemote>`	`TAMPER_DETECTOR`
`static Class<? extends TemperatureControllerRemote>`	`TEMPERATURE_CONTROLLER`
`static Class<? extends TemperatureSensorRemote>`	`TEMPERATURE_SENSOR`
`static Class<? extends AgentRemote>`	`UNIT_BASE_AGENT`
`static Class<? extends AppRemote>`	`UNIT_BASE_APP`
`static Class<? extends ConnectionRemote>`	`UNIT_BASE_CONNECTION`
`static Class<? extends ConnectionRemote>`	`UNIT_BASE_CONNECTION_DOOR`
`static Class<? extends ConnectionRemote>`	`UNIT_BASE_CONNECTION_PASSAGE`
`static Class<? extends ConnectionRemote>`	`UNIT_BASE_CONNECTION_WINDOW`
`static Class<? extends DeviceRemote>`	`UNIT_BASE_DEVICE`
`static Class<? extends LocationRemote>`	`UNIT_BASE_LOCATION`
`static Class<? extends SceneRemote>`	`UNIT_BASE_SCENE`
`static Class<? extends UserRemote>`	`UNIT_BASE_USER`
`static Class<? extends BatteryRemote>`	`UNIT_DAL_BATTERY`
`static Class<? extends ButtonRemote>`	`UNIT_DAL_BUTTON`
`static Class<? extends HandleRemote>`	`UNIT_DAL_HANDLE`
`static Class<? extends LightRemote>`	`UNIT_DAL_LIGHT`
`static Class<? extends ColorableLightRemote>`	`UNIT_DAL_LIGHT_COLORABLE`
`static Class<? extends DimmableLightRemote>`	`UNIT_DAL_LIGHT_DIMMABLE`
`static Class<? extends MonitorRemote>`	`UNIT_DAL_MONITOR`
`static Class<? extends MotionDetectorRemote>`	`UNIT_DAL_MOTION_DETECTOR`
`static Class<? extends PowerConsumptionSensorRemote>`	`UNIT_DAL_POWER_CONSUMPTION_SENSOR`
`static Class<? extends PowerSwitchRemote>`	`UNIT_DAL_POWER_SWITCH`
`static Class<? extends ReedContactRemote>`	`UNIT_DAL_REED_CONTACT`
`static Class<? extends RollerShutterRemote>`	`UNIT_DAL_ROLLER_SHUTTER`
`static Class<? extends SmokeDetectorRemote>`	`UNIT_DAL_SMOKE_DETECTOR`
`static Class<? extends TamperDetectorRemote>`	`UNIT_DAL_TAMPER_DETECTOR`
`static Class<? extends TemperatureControllerRemote>`	`UNIT_DAL_TEMPERATURE_CONTROLLER`
`static Class<? extends TemperatureSensorRemote>`	`UNIT_DAL_TEMPERATURE_SENSOR`
`static org.openbase.jul.schedule.SyncObject`	`UNIT_POOL_LOCK`
`static Class<? extends UserRemote>`	`USER`
`static Class<? extends ConnectionRemote>`	`WINDOW`

Constructor Summary

Constructors
Constructor and Description

Units()

Constructors
Constructor and Description
`Units()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`contains(UnitRemote<? extends com.google.protobuf.GeneratedMessage> unitRemote)` Method checks if the given unitRemote is managed by this unit remote pool.
`static Future<UnitRemote<?>>`	`getFutureUnit(String unitId, boolean waitForData)` Method establishes a connection to the unit referred by the given unit identifier.
`static <UR extends UnitRemote<?>> Future<UR>`	`getFutureUnit(String unitId, boolean waitForData, Class<UR> unitRemoteClass)` This method is a wrapper for `getUnit(String, boolean)` and casts the result to the given `unitRemoteClass`.
`static Future<UnitRemote<?>>`	`getFutureUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig, boolean waitForData)` Method establishes a connection to the unit referred by the given unit identifier.
`static <UR extends UnitRemote<?>> Future<UR>`	`getFutureUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig, boolean waitForData, Class<UR> unitRemoteClass)` This method is a wrapper for `getUnit(UnitConfig, boolean)` and casts the result to the given `unitRemoteClass`.
`static Future<UnitRemote>`	`getFutureUnitByLabel(String label, boolean waitForData)` Method establishes a connection to the unit referred by the given unit label.
`static <UR extends UnitRemote<?>> Future<UR>`	`getFutureUnitByLabel(String label, boolean waitForData, Class<UR> unitRemoteClass)` This method is a wrapper for `getUnit(String, boolean)` and casts the result to the given `unitRemoteClass`.
`Future<UnitRemote<?>>`	`getFutureUnitByLabelAndLocationScope(String label, String locationScope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit label and location scope.
`static Future<UnitRemote>`	`getFutureUnitByLabelAndType(String label, rst.domotic.unit.UnitTemplateType.UnitTemplate.UnitType unitType, boolean waitForData)` Method establishes a connection to the unit referred by the given unit label.
`static Future<UnitRemote<?>>`	`getFutureUnitByScope(rsb.Scope scope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit scope.
`static Future<UnitRemote<?>>`	`getFutureUnitByScope(rst.rsb.ScopeType.Scope scope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit scope.
`static Future<UnitRemote<?>>`	`getFutureUnitByScope(String scope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit scope.
`static UnitRemote<?>`	`getUnit(String unitId, boolean waitForData)` Method establishes a connection to the unit referred by the given unit identifier.
`static <UR extends UnitRemote<?>> UR`	`getUnit(String unitId, boolean waitForData, Class<UR> unitRemoteClass)` This method is a wrapper for `getUnit(String, boolean)` and casts the result to the given `unitRemoteClass`.
`static UnitRemote<?>`	`getUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig, boolean waitForData)` Method establishes a connection to the unit referred by the given unit identifier.
`static <UR extends UnitRemote<?>> UR`	`getUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig, boolean waitForData, Class<UR> unitRemoteClass)` This method is a wrapper for `getUnit(UnitConfig, boolean)` and casts the result to the given `unitRemoteClass`.
`static UnitRemote<?>`	`getUnitByLabel(String label, boolean waitForData)` Method establishes a connection to the unit referred by the given unit label.
`static <UR extends UnitRemote<?>> UR`	`getUnitByLabel(String label, boolean waitForData, Class<UR> unitRemoteClass)` This method is a wrapper for `getUnit(String, boolean)` and casts the result to the given `unitRemoteClass`.
`UnitRemote<?>`	`getUnitByLabelAndLocationScope(String label, String locationScope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit label and location scope.
`static UnitRemote<?>`	`getUnitByLabelAndType(String label, rst.domotic.unit.UnitTemplateType.UnitTemplate.UnitType unitType, boolean waitForData)` Method establishes a connection to the unit referred by the given unit label.
`static UnitRemote<?>`	`getUnitByScope(rsb.Scope scope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit scope.
`static UnitRemote<?>`	`getUnitByScope(rst.rsb.ScopeType.Scope scope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit scope.
`static UnitRemote<?>`	`getUnitByScope(String scope, boolean waitForData)` Method establishes a connection to the unit referred by the given unit scope.
`static org.openbase.bco.registry.unit.lib.UnitRegistry`	`getUnitRegistry()` Method returns an instance of the unit registry.
`static rst.domotic.unit.UnitTemplateType.UnitTemplate.UnitType`	`getUnitTypeByRemoteClass(Class<? extends UnitRemote<?>> unitRemoteClass)` Method resolves the UnitType of the given unit remote class.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - BASE_UNIT_AGENT
```
public static final Class<? extends AgentRemote> BASE_UNIT_AGENT
```
    BASE Unit remote-class-constants which can be used to request unit remotes.
  - BASE_UNIT_APP
```
public static final Class<? extends AppRemote> BASE_UNIT_APP
```
  - BASE_UNIT_SCENE
```
public static final Class<? extends SceneRemote> BASE_UNIT_SCENE
```
  - BASE_UNIT_USER
```
public static final Class<? extends UserRemote> BASE_UNIT_USER
```
  - BASE_UNIT_DEVICE
```
public static final Class<? extends DeviceRemote> BASE_UNIT_DEVICE
```
  - BASE_UNIT_LOCATION
```
public static final Class<? extends LocationRemote> BASE_UNIT_LOCATION
```
  - BASE_UNIT_CONNECTION
```
public static final Class<? extends ConnectionRemote> BASE_UNIT_CONNECTION
```
  - BASE_UNIT_CONNECTION_DOOR
```
public static final Class<? extends ConnectionRemote> BASE_UNIT_CONNECTION_DOOR
```
  - BASE_UNIT_CONNECTION_WINDOW
```
public static final Class<? extends ConnectionRemote> BASE_UNIT_CONNECTION_WINDOW
```
  - BASE_UNIT_CONNECTION_PASSAGE
```
public static final Class<? extends ConnectionRemote> BASE_UNIT_CONNECTION_PASSAGE
```
  - UNIT_BASE_AGENT
```
public static final Class<? extends AgentRemote> UNIT_BASE_AGENT
```
  - UNIT_BASE_APP
```
public static final Class<? extends AppRemote> UNIT_BASE_APP
```
  - UNIT_BASE_SCENE
```
public static final Class<? extends SceneRemote> UNIT_BASE_SCENE
```
  - UNIT_BASE_USER
```
public static final Class<? extends UserRemote> UNIT_BASE_USER
```
  - UNIT_BASE_DEVICE
```
public static final Class<? extends DeviceRemote> UNIT_BASE_DEVICE
```
  - UNIT_BASE_LOCATION
```
public static final Class<? extends LocationRemote> UNIT_BASE_LOCATION
```
  - UNIT_BASE_CONNECTION
```
public static final Class<? extends ConnectionRemote> UNIT_BASE_CONNECTION
```
  - UNIT_BASE_CONNECTION_DOOR
```
public static final Class<? extends ConnectionRemote> UNIT_BASE_CONNECTION_DOOR
```
  - UNIT_BASE_CONNECTION_WINDOW
```
public static final Class<? extends ConnectionRemote> UNIT_BASE_CONNECTION_WINDOW
```
  - UNIT_BASE_CONNECTION_PASSAGE
```
public static final Class<? extends ConnectionRemote> UNIT_BASE_CONNECTION_PASSAGE
```
  - AGENT
```
public static final Class<? extends AgentRemote> AGENT
```
  - APP
```
public static final Class<? extends AppRemote> APP
```
  - SCENE
```
public static final Class<? extends SceneRemote> SCENE
```
  - USER
```
public static final Class<? extends UserRemote> USER
```
  - DEVICE
```
public static final Class<? extends DeviceRemote> DEVICE
```
  - LOCATION
```
public static final Class<? extends LocationRemote> LOCATION
```
  - DOOR
```
public static final Class<? extends ConnectionRemote> DOOR
```
  - WINDOW
```
public static final Class<? extends ConnectionRemote> WINDOW
```
  - PASSAGE
```
public static final Class<? extends ConnectionRemote> PASSAGE
```
  - CONNECTION
```
public static final Class<? extends ConnectionRemote> CONNECTION
```
  - DAL_UNIT_LIGHT
```
public static final Class<? extends LightRemote> DAL_UNIT_LIGHT
```
    DAL Unit remote-class-constants which can be used to request unit remotes.
  - DAL_UNIT_COLORABLE_LIGHT
```
public static final Class<? extends ColorableLightRemote> DAL_UNIT_COLORABLE_LIGHT
```
  - DAL_UNIT_DIMMABLE_LIGHT
```
public static final Class<? extends DimmableLightRemote> DAL_UNIT_DIMMABLE_LIGHT
```
  - DAL_UNIT_MOTION_DETECTOR
```
public static final Class<? extends MotionDetectorRemote> DAL_UNIT_MOTION_DETECTOR
```
  - DAL_UNIT_POWER_SWITCH
```
public static final Class<? extends PowerSwitchRemote> DAL_UNIT_POWER_SWITCH
```
  - DAL_UNIT_POWER_CONSUMPTION_SENSOR
```
public static final Class<? extends PowerConsumptionSensorRemote> DAL_UNIT_POWER_CONSUMPTION_SENSOR
```
  - DAL_UNIT_BUTTON
```
public static final Class<? extends ButtonRemote> DAL_UNIT_BUTTON
```
  - DAL_UNIT_TEMPERATURE_CONTROLLER
```
public static final Class<? extends TemperatureControllerRemote> DAL_UNIT_TEMPERATURE_CONTROLLER
```
  - DAL_UNIT_TEMPERATURE_SENSOR
```
public static final Class<? extends TemperatureSensorRemote> DAL_UNIT_TEMPERATURE_SENSOR
```
  - DAL_UNIT_BATTERY
```
public static final Class<? extends BatteryRemote> DAL_UNIT_BATTERY
```
  - DAL_UNIT_HANDLE
```
public static final Class<? extends HandleRemote> DAL_UNIT_HANDLE
```
  - DAL_UNIT_MONITOR
```
public static final Class<? extends MonitorRemote> DAL_UNIT_MONITOR
```
  - DAL_UNIT_REED_CONTACT
```
public static final Class<? extends ReedContactRemote> DAL_UNIT_REED_CONTACT
```
  - DAL_UNIT_ROLLER_SHUTTER
```
public static final Class<? extends RollerShutterRemote> DAL_UNIT_ROLLER_SHUTTER
```
  - DAL_UNIT_SMOKE_DETECTOR
```
public static final Class<? extends SmokeDetectorRemote> DAL_UNIT_SMOKE_DETECTOR
```
  - DAL_UNIT_TAMPER_DETECTOR
```
public static final Class<? extends TamperDetectorRemote> DAL_UNIT_TAMPER_DETECTOR
```
  - UNIT_DAL_LIGHT
```
public static final Class<? extends LightRemote> UNIT_DAL_LIGHT
```
  - UNIT_DAL_LIGHT_COLORABLE
```
public static final Class<? extends ColorableLightRemote> UNIT_DAL_LIGHT_COLORABLE
```
  - UNIT_DAL_LIGHT_DIMMABLE
```
public static final Class<? extends DimmableLightRemote> UNIT_DAL_LIGHT_DIMMABLE
```
  - UNIT_DAL_MOTION_DETECTOR
```
public static final Class<? extends MotionDetectorRemote> UNIT_DAL_MOTION_DETECTOR
```
  - UNIT_DAL_POWER_SWITCH
```
public static final Class<? extends PowerSwitchRemote> UNIT_DAL_POWER_SWITCH
```
  - UNIT_DAL_POWER_CONSUMPTION_SENSOR
```
public static final Class<? extends PowerConsumptionSensorRemote> UNIT_DAL_POWER_CONSUMPTION_SENSOR
```
  - UNIT_DAL_BUTTON
```
public static final Class<? extends ButtonRemote> UNIT_DAL_BUTTON
```
  - UNIT_DAL_TEMPERATURE_CONTROLLER
```
public static final Class<? extends TemperatureControllerRemote> UNIT_DAL_TEMPERATURE_CONTROLLER
```
  - UNIT_DAL_TEMPERATURE_SENSOR
```
public static final Class<? extends TemperatureSensorRemote> UNIT_DAL_TEMPERATURE_SENSOR
```
  - UNIT_DAL_BATTERY
```
public static final Class<? extends BatteryRemote> UNIT_DAL_BATTERY
```
  - UNIT_DAL_HANDLE
```
public static final Class<? extends HandleRemote> UNIT_DAL_HANDLE
```
  - UNIT_DAL_MONITOR
```
public static final Class<? extends MonitorRemote> UNIT_DAL_MONITOR
```
  - UNIT_DAL_REED_CONTACT
```
public static final Class<? extends ReedContactRemote> UNIT_DAL_REED_CONTACT
```
  - UNIT_DAL_ROLLER_SHUTTER
```
public static final Class<? extends RollerShutterRemote> UNIT_DAL_ROLLER_SHUTTER
```
  - UNIT_DAL_SMOKE_DETECTOR
```
public static final Class<? extends SmokeDetectorRemote> UNIT_DAL_SMOKE_DETECTOR
```
  - UNIT_DAL_TAMPER_DETECTOR
```
public static final Class<? extends TamperDetectorRemote> UNIT_DAL_TAMPER_DETECTOR
```
  - LIGHT
```
public static final Class<? extends LightRemote> LIGHT
```
  - LIGHT_COLORABLE
```
public static final Class<? extends ColorableLightRemote> LIGHT_COLORABLE
```
  - COLORABLE_LIGHT
```
public static final Class<? extends ColorableLightRemote> COLORABLE_LIGHT
```
  - LIGHT_DIMMABLE
```
public static final Class<? extends DimmableLightRemote> LIGHT_DIMMABLE
```
  - DIMMABLE_LIGHT
```
public static final Class<? extends DimmableLightRemote> DIMMABLE_LIGHT
```
  - MOTION_DETECTOR
```
public static final Class<? extends MotionDetectorRemote> MOTION_DETECTOR
```
  - POWER_SWITCH
```
public static final Class<? extends PowerSwitchRemote> POWER_SWITCH
```
  - POWER_CONSUMPTION_SENSOR
```
public static final Class<? extends PowerConsumptionSensorRemote> POWER_CONSUMPTION_SENSOR
```
  - BUTTON
```
public static final Class<? extends ButtonRemote> BUTTON
```
  - TEMPERATURE_CONTROLLER
```
public static final Class<? extends TemperatureControllerRemote> TEMPERATURE_CONTROLLER
```
  - TEMPERATURE_SENSOR
```
public static final Class<? extends TemperatureSensorRemote> TEMPERATURE_SENSOR
```
  - BATTERY
```
public static final Class<? extends BatteryRemote> BATTERY
```
  - HANDLE
```
public static final Class<? extends HandleRemote> HANDLE
```
  - MONITOR
```
public static final Class<? extends MonitorRemote> MONITOR
```
  - REED_CONTACT
```
public static final Class<? extends ReedContactRemote> REED_CONTACT
```
  - ROLLER_SHUTTER
```
public static final Class<? extends RollerShutterRemote> ROLLER_SHUTTER
```
  - SMOKE_DETECTOR
```
public static final Class<? extends SmokeDetectorRemote> SMOKE_DETECTOR
```
  - TAMPER_DETECTOR
```
public static final Class<? extends TamperDetectorRemote> TAMPER_DETECTOR
```
  - instance
```
public static Units instance
```
  - UNIT_POOL_LOCK
```
public static final org.openbase.jul.schedule.SyncObject UNIT_POOL_LOCK
```
- Constructor Detail
  - Units
```
public Units()
```
- Method Detail
  - getUnitRegistry
```
public static org.openbase.bco.registry.unit.lib.UnitRegistry getUnitRegistry()
                                                                       throws InterruptedException,
                                                                              org.openbase.jul.exception.CouldNotPerformException
```
    Method returns an instance of the unit registry. If this method is called for the first time, a new registry instance will be created. This method only returns if the unit registry synchronization is finished otherwise this method blocks forever. In case you won't wait for the synchronization, request your own instance by calling: Registries.getUnitRegistry();
    
    Returns:
    
    the unit registry instance.
    
    Throws:
    
    InterruptedException - is thrown if the current thread was externally interrupted.
    
    org.openbase.jul.exception.CouldNotPerformException - Is thrown in case an error occurs during registry connection.
  - getUnit
```
public static UnitRemote<?> getUnit(String unitId,
                                    boolean waitForData)
                             throws org.openbase.jul.exception.NotAvailableException,
                                    InterruptedException
```
    Method establishes a connection to the unit referred by the given unit identifier. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    unitId - the unit identifier.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available.
    
    InterruptedException - is thrown in case the thread is externally interrupted
  - getUnit
```
public static UnitRemote<?> getUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig,
                                    boolean waitForData)
                             throws org.openbase.jul.exception.NotAvailableException,
                                    InterruptedException
```
    Method establishes a connection to the unit referred by the given unit identifier. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    unitConfig - the unit configuration.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available.
    
    InterruptedException - is thrown in case the thread is externally interrupted
  - getUnit
```
public static <UR extends UnitRemote<?>> UR getUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig,
                                                    boolean waitForData,
                                                    Class<UR> unitRemoteClass)
                                             throws org.openbase.jul.exception.NotAvailableException,
                                                    InterruptedException
```
    This method is a wrapper for getUnit(UnitConfig, boolean) and casts the result to the given unitRemoteClass.
    
    Type Parameters:
    
    UR - the unit remote class type.
    
    Parameters:
    
    unitConfig - Checkout wrapped method doc getUnit(UnitConfig, boolean)
    
    waitForData - Checkout wrapped method doc getUnit(UnitConfig, boolean)
    
    unitRemoteClass - the unit remote class.
    
    Returns:
    
    an instance of the given remote class.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - Is thrown if the remote instance is not compatible with the given class. See {getUnit(UnitConfig, boolean) for further cases.
    
    InterruptedException - Checkout wrapped method doc getUnit(UnitConfig, boolean)
    
    See Also:
    
    getUnit(rst.domotic.unit.UnitConfigType.UnitConfig, boolean)
  - getUnit
```
public static <UR extends UnitRemote<?>> UR getUnit(String unitId,
                                                    boolean waitForData,
                                                    Class<UR> unitRemoteClass)
                                             throws org.openbase.jul.exception.NotAvailableException,
                                                    InterruptedException
```
    This method is a wrapper for getUnit(String, boolean) and casts the result to the given unitRemoteClass.
    
    Type Parameters:
    
    UR - the unit remote class type.
    
    Parameters:
    
    unitId - Checkout wrapped method doc getUnit(String, boolean)
    
    waitForData - Checkout wrapped method doc getUnit(String, boolean)
    
    unitRemoteClass - the unit remote class.
    
    Returns:
    
    an instance of the given remote class.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - Is thrown if the remote instance is not compatible with the given class. See getUnit(String, boolean) for further cases.
    
    InterruptedException - Checkout wrapped method doc getUnit(String, boolean)
    
    See Also:
    
    getUnit(java.lang.String, boolean)
  - getUnitByLabelAndType
```
public static UnitRemote<?> getUnitByLabelAndType(String label,
                                                  rst.domotic.unit.UnitTemplateType.UnitTemplate.UnitType unitType,
                                                  boolean waitForData)
                                           throws org.openbase.jul.exception.NotAvailableException,
                                                  InterruptedException
```
    Method establishes a connection to the unit referred by the given unit label. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    label - the label to identify the unit.
    
    unitType - the type of the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getUnitByLabel
```
public static UnitRemote<?> getUnitByLabel(String label,
                                           boolean waitForData)
                                    throws org.openbase.jul.exception.NotAvailableException,
                                           InterruptedException
```
    Method establishes a connection to the unit referred by the given unit label. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    label - the label to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getUnitByLabel
```
public static <UR extends UnitRemote<?>> UR getUnitByLabel(String label,
                                                           boolean waitForData,
                                                           Class<UR> unitRemoteClass)
                                                    throws org.openbase.jul.exception.NotAvailableException,
                                                           InterruptedException
```
    This method is a wrapper for getUnit(String, boolean) and casts the result to the given unitRemoteClass.
    
    Type Parameters:
    
    UR - the unit remote class type.
    
    Parameters:
    
    label - Checkout wrapped method doc getUnit(String, boolean)
    
    waitForData - Checkout wrapped method doc getUnit(String, boolean)
    
    unitRemoteClass - the unit remote class.
    
    Returns:
    
    an instance of the given remote class.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - Is thrown if the remote instance is not compatible with the given class. See getUnit(String, boolean) for further cases.
    
    InterruptedException - Checkout wrapped method doc getUnit(String, boolean)
    
    See Also:
    
    getUnitByLabel(java.lang.String, boolean)
  - getUnitByScope
```
public static UnitRemote<?> getUnitByScope(rst.rsb.ScopeType.Scope scope,
                                           boolean waitForData)
                                    throws org.openbase.jul.exception.NotAvailableException,
                                           InterruptedException
```
    Method establishes a connection to the unit referred by the given unit scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    scope - the scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getUnitByScope
```
public static UnitRemote<?> getUnitByScope(rsb.Scope scope,
                                           boolean waitForData)
                                    throws org.openbase.jul.exception.NotAvailableException,
                                           InterruptedException
```
    Method establishes a connection to the unit referred by the given unit scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    scope - the scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getUnitByScope
```
public static UnitRemote<?> getUnitByScope(String scope,
                                           boolean waitForData)
                                    throws org.openbase.jul.exception.NotAvailableException,
                                           InterruptedException
```
    Method establishes a connection to the unit referred by the given unit scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    scope - the scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getUnitByLabelAndLocationScope
```
public UnitRemote<?> getUnitByLabelAndLocationScope(String label,
                                                    String locationScope,
                                                    boolean waitForData)
                                             throws org.openbase.jul.exception.NotAvailableException,
                                                    InterruptedException
```
    Method establishes a connection to the unit referred by the given unit label and location scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    label - the label to identify the unit.
    
    locationScope - the location scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getFutureUnit
```
public static Future<UnitRemote<?>> getFutureUnit(String unitId,
                                                  boolean waitForData)
                                           throws org.openbase.jul.exception.NotAvailableException,
                                                  InterruptedException
```
    Method establishes a connection to the unit referred by the given unit identifier. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    unitId - the unit identifier.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available.
    
    InterruptedException - is thrown in case the thread is externally interrupted
  - getFutureUnit
```
public static Future<UnitRemote<?>> getFutureUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig,
                                                  boolean waitForData)
                                           throws org.openbase.jul.exception.NotAvailableException,
                                                  InterruptedException
```
    Method establishes a connection to the unit referred by the given unit identifier. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    unitConfig - the unit configuration.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available.
    
    InterruptedException - is thrown in case the thread is externally interrupted
  - getFutureUnit
```
public static <UR extends UnitRemote<?>> Future<UR> getFutureUnit(rst.domotic.unit.UnitConfigType.UnitConfig unitConfig,
                                                                  boolean waitForData,
                                                                  Class<UR> unitRemoteClass)
                                                           throws org.openbase.jul.exception.NotAvailableException,
                                                                  InterruptedException
```
    This method is a wrapper for getUnit(UnitConfig, boolean) and casts the result to the given unitRemoteClass.
    
    Type Parameters:
    
    UR - the unit remote class type.
    
    Parameters:
    
    unitConfig - Checkout wrapped method doc getUnit(UnitConfig, boolean)
    
    waitForData - Checkout wrapped method doc getUnit(UnitConfig, boolean)
    
    unitRemoteClass - the unit remote class.
    
    Returns:
    
    an instance of the given remote class.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - Is thrown if the remote instance is not compatible with the given class. See {getUnit(UnitConfig, boolean) for further cases.
    
    InterruptedException - Checkout wrapped method doc getUnit(UnitConfig, boolean)
    
    See Also:
    
    getUnit(rst.domotic.unit.UnitConfigType.UnitConfig, boolean)
  - getFutureUnit
```
public static <UR extends UnitRemote<?>> Future<UR> getFutureUnit(String unitId,
                                                                  boolean waitForData,
                                                                  Class<UR> unitRemoteClass)
                                                           throws org.openbase.jul.exception.NotAvailableException,
                                                                  InterruptedException
```
    This method is a wrapper for getUnit(String, boolean) and casts the result to the given unitRemoteClass.
    
    Type Parameters:
    
    UR - the unit remote class type.
    
    Parameters:
    
    unitId - Checkout wrapped method doc getUnit(String, boolean)
    
    waitForData - Checkout wrapped method doc getUnit(String, boolean)
    
    unitRemoteClass - the unit remote class.
    
    Returns:
    
    an instance of the given remote class.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - Is thrown if the remote instance is not compatible with the given class. See getUnit(String, boolean) for further cases.
    
    InterruptedException - Checkout wrapped method doc getUnit(String, boolean)
    
    See Also:
    
    getUnit(java.lang.String, boolean)
  - getFutureUnitByLabelAndType
```
public static Future<UnitRemote> getFutureUnitByLabelAndType(String label,
                                                             rst.domotic.unit.UnitTemplateType.UnitTemplate.UnitType unitType,
                                                             boolean waitForData)
                                                      throws org.openbase.jul.exception.NotAvailableException,
                                                             InterruptedException
```
    Method establishes a connection to the unit referred by the given unit label. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    label - the label to identify the unit.
    
    unitType - the type of the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getFutureUnitByLabel
```
public static Future<UnitRemote> getFutureUnitByLabel(String label,
                                                      boolean waitForData)
                                               throws org.openbase.jul.exception.NotAvailableException,
                                                      InterruptedException
```
    Method establishes a connection to the unit referred by the given unit label. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    label - the label to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getFutureUnitByLabel
```
public static <UR extends UnitRemote<?>> Future<UR> getFutureUnitByLabel(String label,
                                                                         boolean waitForData,
                                                                         Class<UR> unitRemoteClass)
                                                                  throws org.openbase.jul.exception.NotAvailableException,
                                                                         InterruptedException
```
    This method is a wrapper for getUnit(String, boolean) and casts the result to the given unitRemoteClass.
    
    Type Parameters:
    
    UR - the unit remote class type.
    
    Parameters:
    
    label - Checkout wrapped method doc getUnit(String, boolean)
    
    waitForData - Checkout wrapped method doc getUnit(String, boolean)
    
    unitRemoteClass - the unit remote class.
    
    Returns:
    
    an instance of the given remote class.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - Is thrown if the remote instance is not compatible with the given class. See getUnit(String, boolean) for further cases.
    
    InterruptedException - Checkout wrapped method doc getUnit(String, boolean)
    
    See Also:
    
    getUnitByLabel(java.lang.String, boolean)
  - getFutureUnitByScope
```
public static Future<UnitRemote<?>> getFutureUnitByScope(rst.rsb.ScopeType.Scope scope,
                                                         boolean waitForData)
                                                  throws org.openbase.jul.exception.NotAvailableException,
                                                         InterruptedException
```
    Method establishes a connection to the unit referred by the given unit scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    scope - the scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getFutureUnitByScope
```
public static Future<UnitRemote<?>> getFutureUnitByScope(rsb.Scope scope,
                                                         boolean waitForData)
                                                  throws org.openbase.jul.exception.NotAvailableException,
                                                         InterruptedException
```
    Method establishes a connection to the unit referred by the given unit scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    scope - the scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getFutureUnitByScope
```
public static Future<UnitRemote<?>> getFutureUnitByScope(String scope,
                                                         boolean waitForData)
                                                  throws org.openbase.jul.exception.NotAvailableException,
                                                         InterruptedException
```
    Method establishes a connection to the unit referred by the given unit scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    scope - the scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getFutureUnitByLabelAndLocationScope
```
public Future<UnitRemote<?>> getFutureUnitByLabelAndLocationScope(String label,
                                                                  String locationScope,
                                                                  boolean waitForData)
                                                           throws org.openbase.jul.exception.NotAvailableException,
                                                                  InterruptedException
```
    Method establishes a connection to the unit referred by the given unit label and location scope. The returned unit remote object is fully synchronized with the unit controller and all states locally cached. Use the waitForData flag to block the current thread until the unit remote is fully synchronized with the unit controller during the startup phase. This synchronization is just done once and the current thread will not block if the unit remote was already synchronized before. To force a resynchronization call Remote.requestData() on the remote instance. Please avoid polling unit states! If you want to get informed about unit config or unit data state changes, please register new config or data observer on this remote instance.
    
    Parameters:
    
    label - the label to identify the unit.
    
    locationScope - the location scope to identify the unit.
    
    waitForData - if this flag is set to true the current thread will block until the unit remote is fully synchronized with the unit controller.
    
    Returns:
    
    a new or cached unit remote which can be used to control the unit or request all current unit states.
    
    Throws:
    
    org.openbase.jul.exception.NotAvailableException - is thrown in case the unit is not available or the label is not unique enough to identify the unit.
    
    InterruptedException - is thrown in case the thread is externally interrupted.
  - getUnitTypeByRemoteClass
```
public static rst.domotic.unit.UnitTemplateType.UnitTemplate.UnitType getUnitTypeByRemoteClass(Class<? extends UnitRemote<?>> unitRemoteClass)
                                                                                        throws org.openbase.jul.exception.CouldNotPerformException
```
    Method resolves the UnitType of the given unit remote class.
    
    Parameters:
    
    unitRemoteClass - the unit remote class to resolve the unit type.
    
    Returns:
    
    the detected UnitType
    
    Throws:
    
    org.openbase.jul.exception.CouldNotPerformException - is thrown in case if the UnitType could not be resolved.
  - contains
```
public static boolean contains(UnitRemote<? extends com.google.protobuf.GeneratedMessage> unitRemote)
                        throws org.openbase.jul.exception.CouldNotPerformException
```
    Method checks if the given unitRemote is managed by this unit remote pool.
    
    Parameters:
    
    unitRemote - the remote to check.
    
    Returns:
    
    true if the given remote is managed by this pool otherwise false is returned.
    
    Throws:
    
    org.openbase.jul.exception.CouldNotPerformException - is thrown if the given remote is not valid. For instance if the given unit remote is not initialized.

Class Units

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BASE_UNIT_AGENT

BASE_UNIT_APP

BASE_UNIT_SCENE

BASE_UNIT_USER

BASE_UNIT_DEVICE

BASE_UNIT_LOCATION

BASE_UNIT_CONNECTION

BASE_UNIT_CONNECTION_DOOR

BASE_UNIT_CONNECTION_WINDOW

BASE_UNIT_CONNECTION_PASSAGE

UNIT_BASE_AGENT

UNIT_BASE_APP

UNIT_BASE_SCENE

UNIT_BASE_USER

UNIT_BASE_DEVICE

UNIT_BASE_LOCATION

UNIT_BASE_CONNECTION

UNIT_BASE_CONNECTION_DOOR

UNIT_BASE_CONNECTION_WINDOW

UNIT_BASE_CONNECTION_PASSAGE

AGENT

APP

SCENE

USER

DEVICE

LOCATION

DOOR

WINDOW

PASSAGE

CONNECTION

DAL_UNIT_LIGHT

DAL_UNIT_COLORABLE_LIGHT

DAL_UNIT_DIMMABLE_LIGHT

DAL_UNIT_MOTION_DETECTOR

DAL_UNIT_POWER_SWITCH

DAL_UNIT_POWER_CONSUMPTION_SENSOR

DAL_UNIT_BUTTON

DAL_UNIT_TEMPERATURE_CONTROLLER

DAL_UNIT_TEMPERATURE_SENSOR

DAL_UNIT_BATTERY

DAL_UNIT_HANDLE

DAL_UNIT_MONITOR

DAL_UNIT_REED_CONTACT

DAL_UNIT_ROLLER_SHUTTER

DAL_UNIT_SMOKE_DETECTOR

DAL_UNIT_TAMPER_DETECTOR

UNIT_DAL_LIGHT

UNIT_DAL_LIGHT_COLORABLE

UNIT_DAL_LIGHT_DIMMABLE

UNIT_DAL_MOTION_DETECTOR

UNIT_DAL_POWER_SWITCH

UNIT_DAL_POWER_CONSUMPTION_SENSOR

UNIT_DAL_BUTTON

UNIT_DAL_TEMPERATURE_CONTROLLER

UNIT_DAL_TEMPERATURE_SENSOR

UNIT_DAL_BATTERY

UNIT_DAL_HANDLE

UNIT_DAL_MONITOR

UNIT_DAL_REED_CONTACT

UNIT_DAL_ROLLER_SHUTTER

UNIT_DAL_SMOKE_DETECTOR

UNIT_DAL_TAMPER_DETECTOR

LIGHT

LIGHT_COLORABLE

COLORABLE_LIGHT

LIGHT_DIMMABLE

DIMMABLE_LIGHT

MOTION_DETECTOR

POWER_SWITCH

POWER_CONSUMPTION_SENSOR

BUTTON

TEMPERATURE_CONTROLLER

TEMPERATURE_SENSOR

BATTERY