ziver/hal
1
1
Fork 0
Code Pull requests Releases Activity

Refactoring of of inheritance structure, ControllerManagers will now also be able to be provided through plugins

Browse source
This commit is contained in:
Ziver Koc 2021-03-16 22:24:43 +01:00
parent 28bc108921
commit c0188cd5cc
73 changed files with 1083 additions and 991 deletions
Download patch file Download diff file Expand all files Collapse all files

463
hal-core/src/se/hal/ControllerManager.java
View file

@ -1,463 +0,0 @@
package se.hal;
import se.hal.intf.*;
import se.hal.struct.Event;
import se.hal.struct.Sensor;
import zutil.db.DBConnection;
import zutil.log.LogUtil;
import zutil.plugin.PluginManager;
import zutil.ui.Configurator;
import zutil.ui.Configurator.PostConfigurationActionListener;
import zutil.ui.Configurator.PreConfigurationActionListener;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This class manages all SensorController and EventController objects
*/
public class ControllerManager implements HalSensorReportListener,
HalEventReportListener,
PreConfigurationActionListener,
PostConfigurationActionListener {
private static final Logger logger = LogUtil.getLogger();
private static ControllerManager instance;
/** All available sensor plugins **/
private List<Class<? extends HalSensorConfig>> availableSensors = new ArrayList<>();
/** List of all registered sensors **/
private List<Sensor> registeredSensors = Collections.synchronizedList(new ArrayList<>());
/** List of auto detected sensors **/
private List<Sensor> detectedSensors = Collections.synchronizedList(new ArrayList<>());
/** List of sensors that are currently being reconfigured **/
private List<Sensor> limboSensors = Collections.synchronizedList(new LinkedList<>());
/** All available event plugins **/
private List<Class<? extends HalEventConfig>> availableEvents = new ArrayList<>();
/** List of all registered events **/
private List<Event> registeredEvents = Collections.synchronizedList(new ArrayList<>());
/** List of auto detected events **/
private List<Event> detectedEvents = Collections.synchronizedList(new ArrayList<>());
/** List of all registered events **/
private List<Event> limboEvents = Collections.synchronizedList(new LinkedList<>());
/** A map of all instantiated controllers **/
private HashMap<Class,HalAbstractController> controllerMap = new HashMap<>();
/////////////////////////////// SENSORS ///////////////////////////////////
/**
* Register a Sensor instance on the manager.
* The manager will start to save reported data for the registered Sensor.
*/
public void register(Sensor sensor) {
if(sensor.getDeviceConfig() == null) {
logger.warning("Sensor config is null: "+ sensor);
return;
}
if(!availableSensors.contains(sensor.getDeviceConfig().getClass())) {
logger.warning("Sensor data plugin not available: "+ sensor.getDeviceConfig().getClass());
return;
}
logger.info("Registering new sensor(id: "+ sensor.getId() +"): "+ sensor.getDeviceConfig().getClass());
Class<? extends HalSensorController> c = sensor.getController();
HalSensorController controller = getControllerInstance(c);
if(controller != null)
controller.register(sensor.getDeviceConfig());
registeredSensors.add(sensor);
detectedSensors.remove(findSensor(sensor.getDeviceConfig(), detectedSensors)); // Remove if this device was detected
}
/**
* Deregisters a Sensor from the manager.
* Data reported on the Sensor will no longer be saved but already saved data will not be modified.
* The Controller that owns the Sensor will be deallocated if it has no more registered devices.
*/
public void deregister(Sensor sensor){
if(sensor.getDeviceConfig() == null) {
logger.warning("Sensor config is null: "+ sensor);
return;
}
Class<? extends HalSensorController> c = sensor.getController();
HalSensorController controller = (HalSensorController) controllerMap.get(c);
if (controller != null) {
logger.info("Deregistering sensor(id: "+ sensor.getId() +"): "+ sensor.getDeviceConfig().getClass());
controller.deregister(sensor.getDeviceConfig());
registeredSensors.remove(sensor);
removeControllerIfEmpty(controller);
} else {
logger.warning("Controller not instantiated:"+ sensor.getController());
}
}
/**
* Registers a Sensor class type as usable by the manager
*/
public void addAvailableSensor(Class<? extends HalSensorConfig> sensorClass) {
if ( ! availableSensors.contains(sensorClass))
availableSensors.add(sensorClass);
}
/**
* @return a List of all available Sensors that can be registered to this manager
*/
public List<Class<? extends HalSensorConfig>> getAvailableSensors(){
return availableSensors;
}
/**
* @return a List of Sensor instances that have been registered to this manager
*/
public List<Sensor> getRegisteredSensors(){
return registeredSensors;
}
/**
* @return a List of Sensor instances that have been reported but not registered on the manager
*/
public List<Sensor> getDetectedSensors(){
return detectedSensors;
}
/**
* Removes all auto detected sensors.
*/
public void clearDetectedSensors(){
detectedSensors.clear();
}
/**
* Called by Controllers to report received Sensor data
*/
@Override
public void reportReceived(HalSensorConfig sensorConfig, HalSensorData sensorData) {
try{
DBConnection db = HalContext.getDB();
Sensor sensor = findSensor(sensorConfig, registeredSensors);
if (sensor != null) {
logger.finest("Received report from sensor("+sensorConfig.getClass().getSimpleName()+"): "+ sensorConfig);
PreparedStatement stmt =
db.getPreparedStatement("INSERT INTO sensor_data_raw (timestamp, sensor_id, data) VALUES(?, ?, ?)");
stmt.setLong(1, sensorData.getTimestamp());
stmt.setLong(2, sensor.getId());
stmt.setDouble(3, sensorData.getData());
DBConnection.exec(stmt);
}
else { // unknown sensor
logger.finest("Received report from unregistered sensor" +
"("+sensorConfig.getClass().getSimpleName()+"): "+ sensorConfig);
sensor = findSensor(sensorConfig, detectedSensors);
if(sensor == null) {
sensor = new Sensor();
detectedSensors.add(sensor);
}
sensor.setDeviceConfig(sensorConfig);
}
sensor.setDeviceData(sensorData);
// call listeners
for(HalDeviceReportListener<Sensor> listener : sensor.getReportListeners())
listener.receivedReport(sensor);
}catch (SQLException e){
logger.log(Level.WARNING, "Unable to store sensor report", e);
}
}
private static Sensor findSensor(HalSensorConfig sensorData, List<Sensor> list){
for (int i=0; i<list.size(); ++i) { // Don't use foreach for concurrency reasons
Sensor s = list.get(i);
if (sensorData.equals(s.getDeviceConfig())) {
return s;
}
}
return null;
}
//////////////////////////////// EVENTS ///////////////////////////////////
/**
* Register a Event instance on the manager.
* The manager will start to save reported data for the registered Event.
*/
public void register(Event event) {
if(event.getDeviceConfig() == null) {
logger.warning("Event config is null: "+ event);
return;
}
if(!availableEvents.contains(event.getDeviceConfig().getClass())) {
logger.warning("Event data plugin not available: "+ event.getDeviceConfig().getClass());
return;
}
logger.info("Registering new event(id: "+ event.getId() +"): "+ event.getDeviceConfig().getClass());
Class<? extends HalEventController> c = event.getController();
HalEventController controller = getControllerInstance(c);
if(controller != null)
controller.register(event.getDeviceConfig());
registeredEvents.add(event);
detectedEvents.remove(findEvent(event.getDeviceConfig(), detectedEvents)); // Remove if this device was detected
}
/**
* Deregisters a Event from the manager.
* Data reported on the Event will no longer be saved but already saved data will not be modified.
* The Controller that owns the Event will be deallocated if it has no more registered devices.
*/
public void deregister(Event event){
if(event.getDeviceConfig() == null) {
logger.warning("Event config is null: "+ event);
return;
}
Class<? extends HalEventController> c = event.getController();
HalEventController controller = (HalEventController) controllerMap.get(c);
if (controller != null) {
logger.info("Deregistering event(id: "+ event.getId() +"): "+ event.getDeviceConfig().getClass());
controller.deregister(event.getDeviceConfig());
registeredEvents.remove(event);
removeControllerIfEmpty(controller);
} else {
logger.warning("Controller not instantiated: "+ event.getController());
}
}
/**
* Registers a Event class type as usable by the manager
*/
public void addAvailableEvent(Class<? extends HalEventConfig> eventClass) {
if ( ! availableEvents.contains(eventClass))
availableEvents.add(eventClass);
}
/**
* @return a List of all available Events that can be registered to this manager
*/
public List<Class<? extends HalEventConfig>> getAvailableEvents(){
return availableEvents;
}
/**
* @return a List of Sensor instances that have been registered to this manager
*/
public List<Event> getRegisteredEvents(){
return registeredEvents;
}
/**
* @return a List of Event instances that have been reported but not registered on the manager
*/
public List<Event> getDetectedEvents(){
return detectedEvents;
}
/**
* Removes all auto detected events.
*/
public void clearDetectedEvents(){
detectedEvents.clear();
}
/**
* Called by Controllers to report received Event data
*/
@Override
public void reportReceived(HalEventConfig eventConfig, HalEventData eventData) {
try {
DBConnection db = HalContext.getDB();
Event event = findEvent(eventConfig, registeredEvents);
if (event != null) {
logger.finest("Received report from event("+eventConfig.getClass().getSimpleName()+"): "+ eventConfig);
PreparedStatement stmt =
db.getPreparedStatement("INSERT INTO event_data_raw (timestamp, event_id, data) VALUES(?, ?, ?)");
stmt.setLong(1, eventData.getTimestamp());
stmt.setLong(2, event.getId());
stmt.setDouble(3, eventData.getData());
DBConnection.exec(stmt);
}
else { // unknown sensor
logger.info("Received report from unregistered event" +
"("+eventConfig.getClass().getSimpleName()+"): "+ eventConfig);
event = findEvent(eventConfig, detectedEvents);
if(event == null) {
event = new Event();
detectedEvents.add(event);
}
event.setDeviceConfig(eventConfig);
}
event.setDeviceData(eventData);
// call listeners
for(HalDeviceReportListener<Event> listener : event.getReportListeners())
listener.receivedReport(event);
}catch (SQLException e){
logger.log(Level.WARNING, "Unable to store event report", e);
}
}
private static Event findEvent(HalEventConfig eventData, List<Event> list){
for (int i=0; i<list.size(); ++i) { // Don't use foreach for concurrency reasons
Event e = list.get(i);
if (eventData.equals(e.getDeviceConfig())) {
return e;
}
}
return null;
}
public void send(Event event){
HalEventController controller = getControllerInstance(event.getController());
if(controller != null) {
controller.send(event.getDeviceConfig(), event.getDeviceData());
reportReceived(event.getDeviceConfig(), event.getDeviceData()); // save action to db
}
else
logger.warning("No controller found for event id: "+ event.getId());
}
/////////////////////////////// GENERAL ///////////////////////////////////
/**
* @return all instantiated controllers.
*/
public List<HalAbstractController> getControllers() {
return new ArrayList(controllerMap.values());
}
@Override
public void preConfigurationAction(Configurator configurator, Object obj) {
if(obj instanceof HalSensorConfig) {
Sensor sensor = findSensor((HalSensorConfig) obj, registeredSensors);
if(sensor != null){
deregister(sensor);
limboSensors.add(sensor);
}
}
else if(obj instanceof HalEventConfig) {
Event event = findEvent((HalEventConfig) obj, registeredEvents);
if(event != null){
deregister(event);
limboEvents.add(event);
}
}
}
@Override
public void postConfigurationAction(Configurator configurator, Object obj) {
if(obj instanceof HalSensorConfig) {
Sensor sensor = findSensor((HalSensorConfig) obj, limboSensors);
if(sensor != null){
register(sensor);
limboSensors.remove(sensor);
}
}
else if(obj instanceof HalEventConfig) {
Event event = findEvent((HalEventConfig) obj, limboEvents);
if(event != null){
register(event);
limboEvents.remove(event);
}
}
}
private <T extends HalAbstractController> T getControllerInstance(Class<T> c){
HalAbstractController controller;
if (controllerMap.containsKey(c)) {
controller = controllerMap.get(c);
} else {
try {
// Instantiate controller
controller = c.newInstance();
if (controller instanceof HalAutoScannableController &&
! ((HalAutoScannableController) controller).isAvailable()) {
logger.warning("Controller is not ready: " + c.getName());
return null;
}
logger.info("Instantiating new controller: " + c.getName());
controller.initialize();
if(controller instanceof HalSensorController) {
((HalSensorController) controller).setListener(this);
}
if(controller instanceof HalEventController) {
((HalEventController) controller).setListener(this);
}
controllerMap.put(c, controller);
} catch (Exception e){
logger.log(Level.SEVERE, "Unable to instantiate controller: " + c.getName(), e);
return null;
}
}
return (T) controller;
}
private void removeControllerIfEmpty(Object controller){
if (controller instanceof HalAutoScannableController)
return; // Don't do anything if controller is scannable
int size = Integer.MAX_VALUE;
if(controller instanceof HalSensorController)
size = ((HalSensorController) controller).size();
else if(controller instanceof HalEventController)
size = ((HalEventController) controller).size();
if(size < 0){
// Remove controller as it has no more registered sensors
logger.info("Closing controller as it has no more registered devices: " + controller.getClass().getName());
controllerMap.remove(controller.getClass());
if(controller instanceof HalSensorController)
((HalSensorController) controller).close();
else if(controller instanceof HalEventController)
((HalEventController) controller).close();
}
}
public static void initialize(PluginManager pluginManager){
ControllerManager manager = new ControllerManager();
for (Iterator<Class<? extends HalSensorConfig>> it = pluginManager.getClassIterator(HalSensorConfig.class);
it.hasNext(); ){
manager.addAvailableSensor(it.next());
}
for (Iterator<Class<? extends HalEventConfig>> it = pluginManager.getClassIterator(HalEventConfig.class);
it.hasNext(); ){
manager.addAvailableEvent(it.next());
}
for (Iterator<Class<? extends HalAutoScannableController>> it = pluginManager.getClassIterator(HalAutoScannableController.class);
it.hasNext(); ){
Class controller = it.next();
if (controller.isAssignableFrom(HalAbstractController.class))
manager.getControllerInstance(controller); // Instantiate controller
}
instance = manager;
}
public static ControllerManager getInstance(){
return instance;
}
}

229
hal-core/src/se/hal/EventControllerManager.java Normal file
View file

@ -0,0 +1,229 @@
package se.hal;
import se.hal.intf.*;
import se.hal.struct.Event;
import zutil.db.DBConnection;
import zutil.log.LogUtil;
import zutil.plugin.PluginManager;
import zutil.ui.Configurator;
import zutil.ui.Configurator.PostConfigurationActionListener;
import zutil.ui.Configurator.PreConfigurationActionListener;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This class manages all SensorController and EventController objects
*/
public class EventControllerManager extends HalAbstractControllerManager<HalEventController,Event,HalEventConfig> implements
HalDeviceReportListener<HalEventConfig,HalEventData>,
PreConfigurationActionListener,
PostConfigurationActionListener {
private static final Logger logger = LogUtil.getLogger();
private static EventControllerManager instance;
/** All available event plugins **/
private List<Class<? extends HalEventConfig>> availableEvents = new ArrayList<>();
/** List of all registered events **/
private List<Event> registeredEvents = Collections.synchronizedList(new ArrayList<>());
/** List of auto detected events **/
private List<Event> detectedEvents = Collections.synchronizedList(new ArrayList<>());
/** List of all registered events **/
private List<Event> limboEvents = Collections.synchronizedList(new LinkedList<>());
// ----------------------------------------------------
// EVENTS
// ----------------------------------------------------
/**
* Register a Event instance on the manager.
* The manager will start to save reported data for the registered Event.
*/
@Override
public void register(Event event) {
if(event.getDeviceConfig() == null) {
logger.warning("Event config is null: " + event);
return;
}
if(!availableEvents.contains(event.getDeviceConfig().getClass())) {
logger.warning("Event data plugin not available: " + event.getDeviceConfig().getClass());
return;
}
logger.info("Registering new event(id: " + event.getId() + "): " + event.getDeviceConfig().getClass());
Class<? extends HalEventController> c = event.getController();
HalEventController controller = getControllerInstance(c);
if(controller != null)
controller.register(event.getDeviceConfig());
registeredEvents.add(event);
detectedEvents.remove(findEvent(event.getDeviceConfig(), detectedEvents)); // Remove if this device was detected
}
/**
* Deregisters a Event from the manager.
* Data reported on the Event will no longer be saved but already saved data will not be modified.
* The Controller that owns the Event will be deallocated if it has no more registered devices.
*/
@Override
public void deregister(Event event){
if(event.getDeviceConfig() == null) {
logger.warning("Event config is null: "+ event);
return;
}
Class<? extends HalEventController> c = event.getController();
HalEventController controller = controllerMap.get(c);
if (controller != null) {
logger.info("Deregistering event(id: " + event.getId() + "): " + event.getDeviceConfig().getClass());
controller.deregister(event.getDeviceConfig());
registeredEvents.remove(event);
removeControllerIfEmpty(controller);
} else {
logger.warning("Controller not instantiated: "+ event.getController());
}
}
/**
* Registers a Event class type as usable by the manager
*/
@Override
public void addAvailableDevice(Class<? extends HalEventConfig> eventClass) {
if (!availableEvents.contains(eventClass))
availableEvents.add(eventClass);
}
/**
* @return a List of all available Events that can be registered to this manager
*/
@Override
public List<Class<? extends HalEventConfig>> getAvailableDeviceConfigs(){
return availableEvents;
}
/**
* @return a List of Sensor instances that have been registered to this manager
*/
@Override
public List<Event> getRegisteredDevices(){
return registeredEvents;
}
/**
* @return a List of Event instances that have been reported but not registered on the manager
*/
@Override
public List<Event> getDetectedDevices(){
return detectedEvents;
}
/**
* Removes all auto detected events.
*/
@Override
public void clearDetectedDevices(){
detectedEvents.clear();
}
/**
* Called by Controllers to report received Event data
*/
@Override
public void reportReceived(HalEventConfig eventConfig, HalEventData eventData) {
try {
DBConnection db = HalContext.getDB();
Event event = findEvent(eventConfig, registeredEvents);
if (event != null) {
logger.finest("Received report from event(" + eventConfig.getClass().getSimpleName() + "): " + eventConfig);
PreparedStatement stmt =
db.getPreparedStatement("INSERT INTO event_data_raw (timestamp, event_id, data) VALUES(?, ?, ?)");
stmt.setLong(1, eventData.getTimestamp());
stmt.setLong(2, event.getId());
stmt.setDouble(3, eventData.getData());
DBConnection.exec(stmt);
}
else { // unknown sensor
logger.info("Received report from unregistered event" +
"(" + eventConfig.getClass().getSimpleName() + "): " + eventConfig);
event = findEvent(eventConfig, detectedEvents);
if(event == null) {
event = new Event();
detectedEvents.add(event);
}
event.setDeviceConfig(eventConfig);
}
event.setDeviceData(eventData);
// call listeners
for(HalDeviceReportListener<HalEventConfig,HalEventData> listener : event.getReportListeners())
listener.reportReceived(event.getDeviceConfig(), eventData);
}catch (SQLException e){
logger.log(Level.WARNING, "Unable to store event report", e);
}
}
private static Event findEvent(HalEventConfig eventData, List<Event> list){
for (int i=0; i<list.size(); ++i) { // Don't use foreach for concurrency reasons
Event e = list.get(i);
if (eventData.equals(e.getDeviceConfig())) {
return e;
}
}
return null;
}
public void send(Event event){
HalEventController controller = getControllerInstance(event.getController());
if(controller != null) {
controller.send(event.getDeviceConfig(), event.getDeviceData());
reportReceived(event.getDeviceConfig(), event.getDeviceData()); // save action to db
}
else
logger.warning("No controller found for event id: "+ event.getId());
}
/**
* @return all instantiated controllers.
*/
@Override
public Collection<HalEventController> getControllers() {
return controllerMap.values();
}
@Override
public void preConfigurationAction(Configurator configurator, Object obj) {
if(obj instanceof HalEventConfig) {
Event event = findEvent((HalEventConfig) obj, registeredEvents);
if(event != null){
deregister(event);
limboEvents.add(event);
}
}
}
@Override
public void postConfigurationAction(Configurator configurator, Object obj) {
if (obj instanceof HalEventConfig) {
Event event = findEvent((HalEventConfig) obj, limboEvents);
if(event != null){
register(event);
limboEvents.remove(event);
}
}
}
public void initialize(PluginManager pluginManager){
super.initialize(pluginManager);
instance = this;
}
public static EventControllerManager getInstance(){
return instance;
}
}

11
hal-core/src/se/hal/HalServer.java
View file

@ -1,6 +1,7 @@
package se.hal;
import se.hal.intf.HalAbstractControllerManager;
import se.hal.intf.HalDaemon;
import se.hal.intf.HalWebPage;
import se.hal.intf.HalJsonPage;
@ -85,9 +86,13 @@ public class HalServer {
logger.info("Initializing managers.");
HalAlertManager.initialize();
ControllerManager.initialize(pluginManager);
TriggerManager.initialize(pluginManager);
for (Iterator<HalAbstractControllerManager> it = pluginManager.getSingletonIterator(HalAbstractControllerManager.class); it.hasNext(); ) {
HalAbstractControllerManager manager = it.next();
manager.initialize(pluginManager);
}
// ------------------------------------
// Import sensors,events and triggers
// ------------------------------------
@ -95,10 +100,10 @@ public class HalServer {
logger.info("Initializing Sensors and Events.");
for (Sensor sensor : Sensor.getLocalSensors(db)) {
ControllerManager.getInstance().register(sensor);
SensorControllerManager.getInstance().register(sensor);
}
for (Event event : Event.getLocalEvents(db)) {
ControllerManager.getInstance().register(event);
EventControllerManager.getInstance().register(event);
}
// Import triggers
for (TriggerFlow flow : TriggerFlow.getTriggerFlows(db)) {

213
hal-core/src/se/hal/SensorControllerManager.java Normal file
View file

@ -0,0 +1,213 @@
package se.hal;
import se.hal.intf.*;
import se.hal.struct.Sensor;
import zutil.db.DBConnection;
import zutil.log.LogUtil;
import zutil.plugin.PluginManager;
import zutil.ui.Configurator;
import zutil.ui.Configurator.PostConfigurationActionListener;
import zutil.ui.Configurator.PreConfigurationActionListener;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This class manages all SensorController and EventController objects
*/
public class SensorControllerManager extends HalAbstractControllerManager<HalAbstractController, Sensor, HalSensorConfig> implements
HalDeviceReportListener<HalSensorConfig, HalSensorData>,
PreConfigurationActionListener,
PostConfigurationActionListener {
private static final Logger logger = LogUtil.getLogger();
private static SensorControllerManager instance;
/** All available sensor plugins **/
private List<Class<? extends HalSensorConfig>> availableSensors = new ArrayList<>();
/** List of all registered sensors **/
private List<Sensor> registeredSensors = Collections.synchronizedList(new ArrayList<>());
/** List of auto detected sensors **/
private List<Sensor> detectedSensors = Collections.synchronizedList(new ArrayList<>());
/** List of sensors that are currently being reconfigured **/
private List<Sensor> limboSensors = Collections.synchronizedList(new LinkedList<>());
// ----------------------------------------------------
// SENSORS
// ----------------------------------------------------
/**
* Register a Sensor instance on the manager.
* The manager will start to save reported data for the registered Sensor.
*/
@Override
public void register(Sensor sensor) {
if(sensor.getDeviceConfig() == null) {
logger.warning("Sensor config is null: " + sensor);
return;
}
if(!availableSensors.contains(sensor.getDeviceConfig().getClass())) {
logger.warning("Sensor data plugin not available: " + sensor.getDeviceConfig().getClass());
return;
}
logger.info("Registering new sensor(id: " + sensor.getId() + "): " + sensor.getDeviceConfig().getClass());
Class<? extends HalAbstractController> c = sensor.getController();
HalAbstractController controller = getControllerInstance(c);
if(controller != null)
controller.register(sensor.getDeviceConfig());
registeredSensors.add(sensor);
detectedSensors.remove(findSensor(sensor.getDeviceConfig(), detectedSensors)); // Remove if this device was detected
}
/**
* Deregisters a Sensor from the manager.
* Data reported on the Sensor will no longer be saved but already saved data will not be modified.
* The Controller that owns the Sensor will be deallocated if it has no more registered devices.
*/
@Override
public void deregister(Sensor sensor){
if(sensor.getDeviceConfig() == null) {
logger.warning("Sensor config is null: "+ sensor);
return;
}
Class<? extends HalAbstractController> c = sensor.getController();
HalAbstractController controller = controllerMap.get(c);
if (controller != null) {
logger.info("Deregistering sensor(id: " + sensor.getId() + "): " + sensor.getDeviceConfig().getClass());
controller.deregister(sensor.getDeviceConfig());
registeredSensors.remove(sensor);
removeControllerIfEmpty(controller);
} else {
logger.warning("Controller not instantiated: " + sensor.getController());
}
}
/**
* Registers a Sensor class type as usable by the manager
*/
@Override
public void addAvailableDevice(Class<? extends HalSensorConfig> sensorConfigClass) {
if (!availableSensors.contains(sensorConfigClass))
availableSensors.add(sensorConfigClass);
}
/**
* @return a List of all available Sensors that can be registered to this manager
*/
@Override
public List<Class<? extends HalSensorConfig>> getAvailableDeviceConfigs(){
return availableSensors;
}
/**
* @return a List of Sensor instances that have been registered to this manager
*/
@Override
public List<Sensor> getRegisteredDevices(){
return registeredSensors;
}
/**
* @return a List of Sensor instances that have been reported but not registered on the manager
*/
@Override
public List<Sensor> getDetectedDevices(){
return detectedSensors;
}
/**
* Removes all auto detected sensors.
*/
@Override
public void clearDetectedDevices(){
detectedSensors.clear();
}
/**
* Called by Controllers to report received Sensor data
*/
@Override
public void reportReceived(HalSensorConfig sensorConfig, HalSensorData sensorData) {
try{
DBConnection db = HalContext.getDB();
Sensor sensor = findSensor(sensorConfig, registeredSensors);
if (sensor != null) {
logger.finest("Received report from sensor(" + sensorConfig.getClass().getSimpleName() + "): " + sensorConfig);
PreparedStatement stmt =
db.getPreparedStatement("INSERT INTO sensor_data_raw (timestamp, sensor_id, data) VALUES(?, ?, ?)");
stmt.setLong(1, sensorData.getTimestamp());
stmt.setLong(2, sensor.getId());
stmt.setDouble(3, sensorData.getData());
DBConnection.exec(stmt);
}
else { // unknown sensor
logger.finest("Received report from unregistered sensor" +
"(" + sensorConfig.getClass().getSimpleName() + "): " + sensorConfig);
sensor = findSensor(sensorConfig, detectedSensors);
if(sensor == null) {
sensor = new Sensor();
detectedSensors.add(sensor);
}
sensor.setDeviceConfig(sensorConfig);
}
sensor.setDeviceData(sensorData);
// call listeners
for(HalDeviceReportListener<HalSensorConfig,HalSensorData> listener : sensor.getReportListeners())
listener.reportReceived(sensorConfig, sensorData);
} catch (SQLException e){
logger.log(Level.WARNING, "Unable to store sensor report", e);
}
}
private static Sensor findSensor(HalSensorConfig sensorData, List<Sensor> list){
for (int i=0; i<list.size(); ++i) { // Don't use foreach for concurrency reasons
Sensor s = list.get(i);
if (sensorData.equals(s.getDeviceConfig())) {
return s;
}
}
return null;
}
@Override
public void preConfigurationAction(Configurator configurator, Object obj) {
if (obj instanceof HalSensorConfig) {
Sensor sensor = findSensor((HalSensorConfig) obj, registeredSensors);
if (sensor != null){
deregister(sensor);
limboSensors.add(sensor);
}
}
}
@Override
public void postConfigurationAction(Configurator configurator, Object obj) {
if (obj instanceof HalSensorConfig) {
Sensor sensor = findSensor((HalSensorConfig) obj, limboSensors);
if (sensor != null){
register(sensor);
limboSensors.remove(sensor);
}
}
}
@Override
public void initialize(PluginManager pluginManager){
super.initialize(pluginManager);
instance = this;
}
public static SensorControllerManager getInstance(){
return instance;
}
}

8
hal-core/src/se/hal/action/SendEventAction.java
View file

@ -1,6 +1,6 @@
package se.hal.action;
import se.hal.ControllerManager;
import se.hal.EventControllerManager;
import se.hal.HalContext;
import se.hal.intf.HalAction;
import se.hal.intf.HalEventData;
@ -30,11 +30,11 @@ public class SendEventAction implements HalAction {
DBConnection db = HalContext.getDB();
Event event = Event.getEvent(db, eventId);
if (event != null) {
HalEventData dataObj = event.getDeviceConfig().getEventDataClass().newInstance();
HalEventData dataObj = (HalEventData) event.getDeviceConfig().getDeviceDataClass().newInstance();
dataObj.setData(data);
event.setDeviceData(dataObj);
// Send
ControllerManager.getInstance().send(event);
EventControllerManager.getInstance().send(event);
}
else
logger.warning("Unable to find event with id: "+ eventId);
@ -49,7 +49,7 @@ public class SendEventAction implements HalAction {
Event event = null;
try{ event = Event.getEvent(db, eventId); } catch (Exception e){} //ignore exception
return "Send event: "+ eventId +
" ("+(event!=null ? event.getName() : null)+")" +
" (" + (event!=null ? event.getName() : null) + ")" +
" with data: "+ data;
}
}

18
hal-core/src/se/hal/intf/HalAbstractController.java
View file

@ -25,7 +25,7 @@
package se.hal.intf;
public interface HalAbstractController<C, L> {
public interface HalAbstractController {
/**
* The framework might create dummy objects so any type of
@ -34,11 +34,27 @@ public interface HalAbstractController<C, L> {
*/
void initialize() throws Exception;
/**
* Will register an device type to be handled by this controller
*/
void register(HalDeviceConfig deviceConfig);
/**
* Deregisters an device from this controller, the controller
* will no longer handle that type of event
*/
void deregister(HalDeviceConfig deviceConfig);
/**
* @return the number of registered devices.
*/
int size();
/**
* Set a listener that will receive all reports from the the registered devices
*/
void setListener(HalDeviceReportListener listener);
/**
* Close any resources associated with this controller.
* This method could be called multiple times, first time

158
hal-core/src/se/hal/intf/HalAbstractControllerManager.java Normal file
View file

@ -0,0 +1,158 @@
package se.hal.intf;
import se.hal.struct.AbstractDevice;
import zutil.ClassUtil;
import zutil.log.LogUtil;
import zutil.plugin.PluginManager;
import java.lang.reflect.ParameterizedType;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @param <T> is the device controller class
* @param <C> is the device configuration class
*/
public abstract class HalAbstractControllerManager<T extends HalAbstractController, V extends AbstractDevice, C extends HalDeviceConfig> {
private static final Logger logger = LogUtil.getLogger();
/** A map of all instantiated controllers **/
protected HashMap<Class, T> controllerMap = new HashMap<>();
// ----------------------------------------------------
// Abstract methods
// ----------------------------------------------------
/**
* Register a device instance on the manager.
* The manager will start to track and save reported data for the registered device.
*/
public abstract void register(V device);
/**
* Deregisters a device from the manager.
* Data reported on the device will no longer be saved but already saved data will not be modified.
* The Controller that owns the device will be deallocated if it has no more registered devices.
*/
public abstract void deregister(V device);
/**
* Registers a device configuration class type as usable by the manager
*/
public abstract void addAvailableDevice(Class<? extends C> deviceConfigClass);
/**
* @return a List of all available devices that can be registered with this manager
*/
public abstract List<Class<? extends C>> getAvailableDeviceConfigs();
/**
* @return a List of device instances that have been registered on this manager
*/
public abstract List<V> getRegisteredDevices();
/**
* @return a List of device instances that have reported data but have not yet been registered on the manager
*/
public abstract List<V> getDetectedDevices();
/**
* Removes all auto detected devices.
*/
public abstract void clearDetectedDevices();
// ----------------------------------------------------
// Common Logic
// ----------------------------------------------------
/**
* @return all active instantiated controllers.
*/
public Collection<T> getControllers() {
return controllerMap.values();
}
/**
* Will return a singleton controller instance of the given class.
* If a instance does not exist yet the a new instance will be allocated
* depending on if the controller is ready thorough the {@link HalAutoScannableController#isAvailable()} method.
*
* @param clazz is the class of the wanted object instance wanted
* @return A singleton instance of the input clazz or null if the class is unavailable or not ready to be instantiated.
*/
protected T getControllerInstance(Class<? extends T> clazz){
T controller;
if (controllerMap.containsKey(clazz)) {
controller = controllerMap.get(clazz);
} else {
try {
// Instantiate controller
controller = clazz.newInstance();
if (controller instanceof HalAutoScannableController &&
! ((HalAutoScannableController) controller).isAvailable()) {
logger.warning("Controller is not ready: " + clazz.getName());
return null;
}
logger.info("Instantiating new controller: " + clazz.getName());
controller.initialize();
if (this instanceof HalDeviceReportListener)
controller.setListener((HalDeviceReportListener)this);
controllerMap.put(clazz, controller);
} catch (Exception e){
logger.log(Level.SEVERE, "Unable to instantiate controller: " + clazz.getName(), e);
return null;
}
}
return controller;
}
/**
* Will check if a controller no longer has any managed devices,
* in that case the controller will be deallocated.
*
* @param controller is the controller instance.
*/
protected void removeControllerIfEmpty(HalAbstractController controller){
if (controller instanceof HalAutoScannableController)
return; // Don't do anything if controller is scannable
if (controller.size() < 0){
// Remove controller as it has no more registered sensors
logger.info("Closing controller as it has no more registered devices: " + controller.getClass().getName());
controllerMap.remove(controller.getClass());
controller.close();
}
}
/**
* Will instantiate a generic ControllerManager.
*
* @param pluginManager a PluginManager instance that will be used to find Controller plugins.
*/
public void initialize(PluginManager pluginManager) {
Class[] genericClasses = ClassUtil.getGenericClasses(HalAbstractControllerManager.class);
if (genericClasses.length >= 1 && genericClasses[0] != null) {
for (Iterator<Class<C>> it = pluginManager.getClassIterator(genericClasses[0]); it.hasNext(); ) {
addAvailableDevice(it.next());
}
} else {
logger.severe("Unable to retrieve Controller class from generics.");
}
for (Iterator<Class<? extends HalAutoScannableController>> it = pluginManager.getClassIterator(HalAutoScannableController.class); it.hasNext(); ){
Class controller = it.next();
getControllerInstance(controller); // Instantiate controller
}
}
}

21
hal-core/src/se/hal/intf/HalDeviceConfig.java Normal file
View file

@ -0,0 +1,21 @@
package se.hal.intf;
/**
* Interface representing a generic device configuration data.
*/
public interface HalDeviceConfig {
Class<? extends HalAbstractController> getDeviceControllerClass();
/**
* @return the class that should be instantiated and used for data received from this event
*/
Class<? extends HalDeviceData> getDeviceDataClass();
/**
* This method needs to be implemented.
* NOTE: it should not compare data and timestamp, only static or unique data for the event type.
*/
boolean equals(Object obj);
}

8
hal-core/src/se/hal/intf/HalDeviceReportListener.java
View file

@ -1,14 +1,14 @@
package se.hal.intf;
import se.hal.struct.AbstractDevice;
/**
* A listener interface that will be called when the
* Event or Sensor that it is registered to receives a report
*
* @param <T> is the device type
* @param <C> is the device configuration class
* @param <D> is the device data class
*/
public interface HalDeviceReportListener<T extends AbstractDevice> {
public interface HalDeviceReportListener<C extends HalDeviceConfig, D extends HalDeviceData> {
void receivedReport(T device);
void reportReceived(C deviceConfig, D deviceData);
}

15
hal-core/src/se/hal/intf/HalEventConfig.java
View file

@ -3,19 +3,6 @@ package se.hal.intf;
/**
* Interface representing event type specific configuration data.
*/
public interface HalEventConfig {
Class<? extends HalEventController> getEventControllerClass();
/**
* @return the class that should be instantiated and used for data received from this event
*/
Class<? extends HalEventData> getEventDataClass();
/**
* This method needs to be implemented.
* NOTE: it should not compare data and timestamp, only static or unique data for the event type.
*/
boolean equals(Object obj);
public interface HalEventConfig extends HalDeviceConfig {
}

16
hal-core/src/se/hal/intf/HalEventController.java
View file

@ -5,25 +5,9 @@ package se.hal.intf;
*/
public interface HalEventController extends HalAbstractController {
/**
* Will register an event type to be handled by this controller
*/
void register(HalEventConfig eventConfig);
/**
* Deregisters an event from this controller, the controller
* will no longer handle that type of event
*/
void deregister(HalEventConfig eventConfig);
/**
* @param eventConfig the event configuration to target when sending
* @param eventData the data to send
*/
void send(HalEventConfig eventConfig, HalEventData eventData);
/**
* Set a listener that will receive all reports from the the registered Events
*/
void setListener(HalEventReportListener listener);
}

10
hal-core/src/se/hal/intf/HalEventReportListener.java
View file

@ -1,10 +0,0 @@
package se.hal.intf;
/**
* Listener to be called by the {@link HalEventController} to report that a event has been received.
*/
public interface HalEventReportListener {
void reportReceived(HalEventConfig e, HalEventData d);
}

19
hal-core/src/se/hal/intf/HalSensorConfig.java
View file

@ -3,7 +3,7 @@ package se.hal.intf;
/**
* Interface representing sensor type specific configuration data.
*/
public interface HalSensorConfig {
public interface HalSensorConfig extends HalDeviceConfig {
enum AggregationMethod{
SUM,
AVERAGE
@ -19,21 +19,4 @@ public interface HalSensorConfig {
* @return which aggregation method that should be used to aggregate the reported data.
*/
AggregationMethod getAggregationMethod();
/**
* @return the Controller class where SensorData should be registered on
*/
Class<? extends HalSensorController> getSensorControllerClass();
/**
* @return the class that should be instantiated and used for data received from this sensor
*/
Class<? extends HalSensorData> getSensorDataClass();
/**
* NOTE: it should only static or unique data for the sensor type.
* This method is used to associate reported data with registered sensors
*/
boolean equals(Object obj);
}

15
hal-core/src/se/hal/intf/HalSensorController.java
View file

@ -5,19 +5,4 @@ package se.hal.intf;
*/
public interface HalSensorController extends HalAbstractController {
/**
* Will register a sensor type to be handled by this controller
*/
void register(HalSensorConfig sensorConfig);
/**
* Deregisters a sensor from this controller, the controller
* will no longer handle that type of sensor
*/
void deregister(HalSensorConfig sensorConfig);
/**
* Set a listener that will receive all reports from the the registered Sensors
*/
void setListener(HalSensorReportListener listener);
}

10
hal-core/src/se/hal/intf/HalSensorReportListener.java
View file

@ -1,10 +0,0 @@
package se.hal.intf;
/**
* Listener to be called by the {@link HalSensorController} to report that sensor data has been received.
*/
public interface HalSensorReportListener {
void reportReceived(HalSensorConfig s, HalSensorData d);
}

14
hal-core/src/se/hal/page/EventConfigWebPage.java
View file

@ -1,6 +1,6 @@
package se.hal.page;
import se.hal.ControllerManager;
import se.hal.EventControllerManager;
import se.hal.HalContext;
import se.hal.intf.HalWebPage;
import se.hal.struct.ClassConfigurationData;
@ -30,7 +30,7 @@ public class EventConfigWebPage extends HalWebPage {
super.getRootNav().createSubNav("Settings").createSubNav(this.getId(), "Event Settings").setWeight(200);
eventConfigurations = new ArrayList<>();
for(Class c : ControllerManager.getInstance().getAvailableEvents())
for(Class c : EventControllerManager.getInstance().getAvailableDeviceConfigs())
eventConfigurations.add(new ClassConfigurationData(c));
}
@ -59,7 +59,7 @@ public class EventConfigWebPage extends HalWebPage {
event.setUser(localUser);
event.getDeviceConfigurator().setValues(request).applyConfiguration();
event.save(db);
ControllerManager.getInstance().register(event);
EventControllerManager.getInstance().register(event);
HalAlertManager.getInstance().addAlert(new UserMessage(
MessageLevel.SUCCESS, "Successfully created new event: " + event.getName(), MessageTTL.ONE_VIEW));
@ -88,7 +88,7 @@ public class EventConfigWebPage extends HalWebPage {
event = Event.getEvent(db, id);
if (event != null) {
logger.info("Removing event: " + event.getName());
ControllerManager.getInstance().deregister(event);
EventControllerManager.getInstance().deregister(event);
event.delete(db);
HalAlertManager.getInstance().addAlert(new UserMessage(
@ -101,7 +101,7 @@ public class EventConfigWebPage extends HalWebPage {
break;
case "remove_all_detected_events":
ControllerManager.getInstance().clearDetectedEvents();
EventControllerManager.getInstance().clearDetectedDevices();
break;
}
}
@ -111,8 +111,8 @@ public class EventConfigWebPage extends HalWebPage {
tmpl.set("user", localUser);
tmpl.set("localEvents", Event.getLocalEvents(db));
tmpl.set("localEventConf", eventConfigurations);
tmpl.set("detectedEvents", ControllerManager.getInstance().getDetectedEvents());
tmpl.set("availableEvents", ControllerManager.getInstance().getAvailableEvents());
tmpl.set("detectedEvents", EventControllerManager.getInstance().getDetectedDevices());
tmpl.set("availableEvents", EventControllerManager.getInstance().getAvailableDeviceConfigs());
return tmpl;
}

4
hal-core/src/se/hal/page/EventOverviewWebPage.java
View file

@ -1,6 +1,6 @@
package se.hal.page;
import se.hal.ControllerManager;
import se.hal.EventControllerManager;
import se.hal.HalContext;
import se.hal.intf.HalWebPage;
import se.hal.struct.Event;
@ -54,7 +54,7 @@ public class EventOverviewWebPage extends HalWebPage {
logger.info("Modifying Event(" + id + ") state: " + eventData.toString());
Event event = Event.getEvent(db, id);
event.setDeviceData(eventData);
ControllerManager.getInstance().send(event);
EventControllerManager.getInstance().send(event);
}
int id = (ObjectUtil.isEmpty(request.get("id")) ? -1 : Integer.parseInt(request.get("id")));

5
hal-core/src/se/hal/page/PluginConfigWebPage.java
View file

@ -1,17 +1,16 @@
package se.hal.page;
import se.hal.ControllerManager;
import se.hal.HalContext;
import se.hal.HalServer;
import se.hal.intf.HalWebPage;
import zutil.io.file.FileUtil;
import zutil.parser.Templator;
import zutil.ui.UserMessageManager;
import java.util.Map;
import static zutil.ui.UserMessageManager.*;
public class PluginConfigWebPage extends HalWebPage {
private static final String TEMPLATE = HalContext.RESOURCE_WEB_ROOT + "/plugin_config.tmpl";
@ -39,7 +38,7 @@ public class PluginConfigWebPage extends HalWebPage {
Templator tmpl = new Templator(FileUtil.find(TEMPLATE));
tmpl.set("plugins", HalServer.getAllPlugins());
tmpl.set("controllers", ControllerManager.getInstance().getControllers());
//tmpl.set("controllers", ControllerManager.getInstance().getControllers()); // TODO: Get all controllers
return tmpl;
}
}

15
hal-core/src/se/hal/page/SensorConfigWebPage.java
View file

@ -1,7 +1,7 @@
package se.hal.page;
import se.hal.ControllerManager;
import se.hal.HalContext;
import se.hal.SensorControllerManager;
import se.hal.intf.HalWebPage;
import se.hal.struct.ClassConfigurationData;
import se.hal.struct.Sensor;
@ -18,6 +18,7 @@ import java.util.logging.Logger;
import static zutil.ui.UserMessageManager.*;
public class SensorConfigWebPage extends HalWebPage {
private static final Logger logger = LogUtil.getLogger();
private static final String TEMPLATE = HalContext.RESOURCE_WEB_ROOT + "/sensor_config.tmpl";
@ -30,7 +31,7 @@ public class SensorConfigWebPage extends HalWebPage {
super.getRootNav().createSubNav("Settings").createSubNav(this.getId(), "Sensor Settings").setWeight(100);
sensorConfigurations = new ArrayList<>();
for(Class c : ControllerManager.getInstance().getAvailableSensors())
for(Class c : SensorControllerManager.getInstance().getAvailableDeviceConfigs())
sensorConfigurations.add(new ClassConfigurationData(c));
}
@ -61,7 +62,7 @@ public class SensorConfigWebPage extends HalWebPage {
sensor.setUser(localUser);
sensor.getDeviceConfigurator().setValues(request).applyConfiguration();
sensor.save(db);
ControllerManager.getInstance().register(sensor);
SensorControllerManager.getInstance().register(sensor);
HalAlertManager.getInstance().addAlert(new UserMessage(
MessageLevel.SUCCESS, "Successfully created new sensor: "+sensor.getName(), MessageTTL.ONE_VIEW));
@ -90,7 +91,7 @@ public class SensorConfigWebPage extends HalWebPage {
sensor = Sensor.getSensor(db, id);
if(sensor != null) {
logger.warning("Removing sensor: " + sensor.getName());
ControllerManager.getInstance().deregister(sensor);
SensorControllerManager.getInstance().deregister(sensor);
sensor.delete(db);
HalAlertManager.getInstance().addAlert(new UserMessage(
@ -103,7 +104,7 @@ public class SensorConfigWebPage extends HalWebPage {
break;
case "remove_all_detected_sensors":
ControllerManager.getInstance().clearDetectedSensors();
SensorControllerManager.getInstance().clearDetectedDevices();
break;
// External Users
@ -174,10 +175,10 @@ public class SensorConfigWebPage extends HalWebPage {
tmpl.set("user", localUser);
tmpl.set("localSensors", Sensor.getLocalSensors(db));
tmpl.set("localSensorConf", sensorConfigurations);
tmpl.set("detectedSensors", ControllerManager.getInstance().getDetectedSensors());
tmpl.set("detectedSensors", SensorControllerManager.getInstance().getDetectedDevices());
tmpl.set("extUsers", User.getExternalUsers(db));
tmpl.set("extSensor", Sensor.getExternalSensors(db));
tmpl.set("availableSensors", ControllerManager.getInstance().getAvailableSensors());
tmpl.set("availableSensors", SensorControllerManager.getInstance().getAvailableDeviceConfigs());
return tmpl;

4
hal-core/src/se/hal/page/SensorJsonPage.java
View file

@ -62,7 +62,7 @@ public class SensorJsonPage extends HalJsonPage {
else if (req_ids != null && ArrayUtil.contains(req_ids, ""+sensor.getId())) // id filtering
sensors.add(sensor);
else if (req_type != null && !req_type.isEmpty() &&
sensor.getDeviceConfig().getSensorDataClass().getSimpleName().contains(req_type)) // device type filtering
sensor.getDeviceConfig().getDeviceDataClass().getSimpleName().contains(req_type)) // device type filtering
sensors.add(sensor);
}
@ -96,7 +96,7 @@ public class SensorJsonPage extends HalJsonPage {
deviceNode.set("id", sensor.getId());
deviceNode.set("name", sensor.getName());
deviceNode.set("user", sensor.getUser().getUsername());
deviceNode.set("type", sensor.getDeviceConfig().getSensorDataClass().getSimpleName());
deviceNode.set("type", sensor.getDeviceConfig().getDeviceDataClass().getSimpleName());
deviceNode.set("x", sensor.getX());
deviceNode.set("y", sensor.getY());

3
hal-core/src/se/hal/plugin.json
View file

@ -3,6 +3,9 @@
"name": "Hal-Core",
"description": "Plugin contains core logic for running Hal.",
"interfaces": [
{"se.hal.intf.HalAbstractControllerManager": "se.hal.EventControllerManager"},
{"se.hal.intf.HalAbstractControllerManager": "se.hal.SensorControllerManager"},
{"se.hal.intf.HalDaemon": "se.hal.daemon.SensorDataAggregatorDaemon"},
{"se.hal.intf.HalDaemon": "se.hal.daemon.SensorDataCleanupDaemon"},

24
hal-core/src/se/hal/struct/AbstractDevice.java
View file

@ -1,8 +1,8 @@
package se.hal.struct;
import se.hal.ControllerManager;
import se.hal.HalContext;
import se.hal.intf.HalAbstractController;
import se.hal.intf.HalDeviceConfig;
import se.hal.intf.HalDeviceData;
import se.hal.intf.HalDeviceReportListener;
import zutil.db.DBConnection;
@ -21,11 +21,11 @@ import java.util.logging.Logger;
/**
* Contains logic and data common to devices (Events and Sensors)
*
* @param <T> is the device type
* @param <V> is the device type
* @param <C> is the device configuration class
* @param <D> is the device data class
*/
public abstract class AbstractDevice<T extends AbstractDevice, C,D extends HalDeviceData> extends DBBean {
public abstract class AbstractDevice<V extends AbstractDevice,C extends HalDeviceConfig,D extends HalDeviceData> extends DBBean {
private static final Logger logger = LogUtil.getLogger();
// Sensor specific data
@ -48,7 +48,7 @@ public abstract class AbstractDevice<T extends AbstractDevice, C,D extends HalDe
@DBColumn("map_y")
private double y;
protected transient List<HalDeviceReportListener<T>> listeners = new LinkedList<>();
protected transient List<HalDeviceReportListener<C,D>> listeners = new LinkedList<>();
// ----------------------------------------------------
@ -59,8 +59,8 @@ public abstract class AbstractDevice<T extends AbstractDevice, C,D extends HalDe
C obj = getDeviceConfig();
if (obj != null) {
Configurator<C> configurator = new Configurator<>(obj);
configurator.setPreConfigurationListener(ControllerManager.getInstance());
configurator.setPostConfigurationListener(ControllerManager.getInstance());
//configurator.setPreConfigurationListener(ControllerManager.getInstance()); // TODO:
//configurator.setPostConfigurationListener(ControllerManager.getInstance()); // TODO:
return configurator;
}
return null;
@ -118,7 +118,7 @@ public abstract class AbstractDevice<T extends AbstractDevice, C,D extends HalDe
* This method will configure the current DeviceData with the
* configuration from the config String.
*/
private void applyConfig(){
private void applyConfig() {
if (config != null && !config.isEmpty()) {
Configurator<C> configurator = getDeviceConfigurator();
configurator.setValues(JSONParser.read(config));
@ -135,11 +135,11 @@ public abstract class AbstractDevice<T extends AbstractDevice, C,D extends HalDe
/**
* @return the latest known data from the device
*/
public D getDeviceData(){
public D getDeviceData() {
return deviceData;
}
public void setDeviceData(D latest){
public void setDeviceData(D latest) {
this.deviceData = latest;
}
@ -198,13 +198,13 @@ public abstract class AbstractDevice<T extends AbstractDevice, C,D extends HalDe
this.y = y;
}
public void addReportListener(HalDeviceReportListener<T> listener){
public void addReportListener(HalDeviceReportListener<C,D> listener) {
listeners.add(listener);
}
public void removeReportListener(HalDeviceReportListener<T> listener){
public void removeReportListener(HalDeviceReportListener<C,D> listener) {
listeners.remove(listener);
}
public List<HalDeviceReportListener<T>> getReportListeners(){
public List<HalDeviceReportListener<C,D>> getReportListeners() {
return listeners;
}
}

15
hal-core/src/se/hal/struct/Event.java
View file

@ -1,27 +1,20 @@
package se.hal.struct;
import se.hal.intf.HalDeviceData;
import se.hal.intf.HalEventController;
import se.hal.intf.HalEventConfig;
import se.hal.intf.HalEventData;
import se.hal.intf.*;
import se.hal.util.DeviceDataSqlResult;
import zutil.db.DBConnection;
import zutil.db.SQLResultHandler;
import zutil.db.bean.DBBean;
import zutil.db.bean.DBBeanSQLResultHandler;
import zutil.db.handler.SimpleSQLResult;
import zutil.log.LogUtil;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
@DBBean.DBTable(value="event", superBean=true)
public class Event extends AbstractDevice<Event, HalEventConfig,HalEventData>{
public class Event extends AbstractDevice<Event,HalEventConfig,HalEventData> {
private static final Logger logger = LogUtil.getLogger();
@ -39,13 +32,13 @@ public class Event extends AbstractDevice<Event, HalEventConfig,HalEventData>{
@Override
public Class<? extends HalEventController> getController(){
return getDeviceConfig().getEventControllerClass();
return (Class<? extends HalEventController>) getDeviceConfig().getDeviceControllerClass();
}
@Override
protected HalEventData getLatestDeviceData(DBConnection db) {
try {
Class deviceDataClass = getDeviceConfig().getEventDataClass();
Class deviceDataClass = getDeviceConfig().getDeviceDataClass();
if (deviceDataClass == null)
throw new ClassNotFoundException("Unknown event data class for: " + getDeviceConfig().getClass());

11
hal-core/src/se/hal/struct/Sensor.java
View file

@ -1,8 +1,7 @@
package se.hal.struct;
import se.hal.HalContext;
import se.hal.intf.HalDeviceReportListener;
import se.hal.intf.HalSensorController;
import se.hal.intf.HalAbstractController;
import se.hal.intf.HalSensorConfig;
import se.hal.intf.HalSensorData;
import se.hal.util.DeviceDataSqlResult;
@ -20,7 +19,7 @@ import java.util.logging.Logger;
@DBBean.DBTable(value="sensor", superBean=true)
public class Sensor extends AbstractDevice<Sensor, HalSensorConfig,HalSensorData>{
public class Sensor extends AbstractDevice<Sensor,HalSensorConfig,HalSensorData> {
private static final Logger logger = LogUtil.getLogger();
private long external_id = -1;
@ -111,14 +110,14 @@ public class Sensor extends AbstractDevice<Sensor, HalSensorConfig,HalSensorData
@Override
public Class<? extends HalSensorController> getController(){
return getDeviceConfig().getSensorControllerClass();
public Class<? extends HalAbstractController> getController(){
return (Class<? extends HalAbstractController>) getDeviceConfig().getDeviceControllerClass();
}
@Override
protected HalSensorData getLatestDeviceData(DBConnection db) {
try {
Class deviceDataClass = getDeviceConfig().getSensorDataClass();
Class deviceDataClass = getDeviceConfig().getDeviceDataClass();
if (deviceDataClass == null)
throw new ClassNotFoundException("Unknown sensor data class for: " + getDeviceConfig().getClass());

8
hal-core/src/se/hal/trigger/DeviceTrigger.java
View file

@ -1,6 +1,7 @@
package se.hal.trigger;
import se.hal.TriggerManager;
import se.hal.intf.HalDeviceConfig;
import se.hal.intf.HalDeviceData;
import se.hal.intf.HalDeviceReportListener;
import se.hal.intf.HalTrigger;
@ -14,7 +15,8 @@ import zutil.ui.Configurator.PreConfigurationActionListener;
*/
public abstract class DeviceTrigger implements HalTrigger,
PreConfigurationActionListener,
PostConfigurationActionListener, HalDeviceReportListener<AbstractDevice> {
PostConfigurationActionListener,
HalDeviceReportListener<HalDeviceConfig,HalDeviceData> {
@Configurator.Configurable("Device ID")
protected int deviceId = -1;
@ -42,8 +44,8 @@ public abstract class DeviceTrigger implements HalTrigger,
}
@Override
public void receivedReport(AbstractDevice device) {
receivedData = device.getDeviceData();
public void reportReceived(HalDeviceConfig deviceConfig, HalDeviceData deviceData) {
receivedData = deviceData;
// Instant trigger evaluation
if (triggerOnChange)
TriggerManager.getInstance().evaluateAndExecute();

2
hal-core/src/se/hal/util/AggregateDataListSqlResult.java
View file

@ -94,7 +94,7 @@ public class AggregateDataListSqlResult implements SQLResultHandler<ArrayList<Ag
list.add(new AggregateData(id, previousTimestampEnd + 1, null /*Float.NaN*/, username));
}
if (sensor.getDeviceConfig().getSensorDataClass() == PowerConsumptionSensorData.class)
if (sensor.getDeviceConfig().getDeviceDataClass() == PowerConsumptionSensorData.class)
estimatedData = (estimatedData/1000f);
list.add(new AggregateData(id, timestampEnd, estimatedData, username)); //add this data point to list

54
hal-core/test/se/hal/EventControllerManagerTest.java
View file

@ -13,51 +13,51 @@ import static org.junit.Assert.assertTrue;
public class EventControllerManagerTest {
private ControllerManager manager = new ControllerManager();
private EventControllerManager manager = new EventControllerManager();
@Test
public void addAvailableEvent(){
assertEquals(0, manager.getAvailableEvents().size());
public void addAvailableEventDevice(){
assertEquals(0, manager.getAvailableDeviceConfigs().size());
manager.addAvailableEvent(TestEvent1.class);
assertEquals(1, manager.getAvailableEvents().size());
assertTrue(manager.getAvailableEvents().contains(TestEvent1.class));
manager.addAvailableDevice(TestEvent1.class);
assertEquals(1, manager.getAvailableDeviceConfigs().size());
assertTrue(manager.getAvailableDeviceConfigs().contains(TestEvent1.class));
manager.addAvailableEvent(TestEvent2.class);
assertEquals(2, manager.getAvailableEvents().size());
assertTrue(manager.getAvailableEvents().contains(TestEvent1.class));
assertTrue(manager.getAvailableEvents().contains(TestEvent2.class));
manager.addAvailableDevice(TestEvent2.class);
assertEquals(2, manager.getAvailableDeviceConfigs().size());
assertTrue(manager.getAvailableDeviceConfigs().contains(TestEvent1.class));
assertTrue(manager.getAvailableDeviceConfigs().contains(TestEvent2.class));
// Add duplicate Event
manager.addAvailableEvent(TestEvent1.class);
assertEquals("No duplicate check",2, manager.getAvailableEvents().size());
manager.addAvailableDevice(TestEvent1.class);
assertEquals("No duplicate check",2, manager.getAvailableDeviceConfigs().size());
}
@Test
public void registerUnavailableEvent(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableEvents());
assertEquals(Collections.EMPTY_LIST, manager.getAvailableDeviceConfigs());
Event Event = new Event();
Event.setDeviceConfig(new TestEvent1());
manager.register(Event);
assertEquals("No Event registered", Collections.EMPTY_LIST, manager.getRegisteredEvents());
assertEquals("No Event registered", Collections.EMPTY_LIST, manager.getRegisteredDevices());
}
@Test
public void registerOneEvent() {
Event Event1 = registerEvent(new TestEvent1());
assertEquals(1, manager.getRegisteredEvents().size());
assertTrue(manager.getRegisteredEvents().contains(Event1));
assertEquals(1, manager.getRegisteredDevices().size());
assertTrue(manager.getRegisteredDevices().contains(Event1));
}
public void registerTwoEvents(){
Event Event1 = registerEvent(new TestEvent1());
Event Event2 = registerEvent(new TestEvent2());
assertEquals(2, manager.getRegisteredEvents().size());
assertTrue(manager.getRegisteredEvents().contains(Event1));
assertTrue(manager.getRegisteredEvents().contains(Event2));
assertEquals(2, manager.getRegisteredDevices().size());
assertTrue(manager.getRegisteredDevices().contains(Event1));
assertTrue(manager.getRegisteredDevices().contains(Event2));
}
@ -65,7 +65,7 @@ public class EventControllerManagerTest {
public void deregisterEvent(){
Event Event1 = registerEvent(new TestEvent1());
manager.deregister(Event1);
assertEquals(Collections.EMPTY_LIST, manager.getRegisteredEvents());
assertEquals(Collections.EMPTY_LIST, manager.getRegisteredDevices());
}
@ -76,7 +76,7 @@ public class EventControllerManagerTest {
private Event registerEvent(HalEventConfig config){
Event Event = new Event();
Event.setDeviceConfig(config);
manager.addAvailableEvent(config.getClass());
manager.addAvailableDevice(config.getClass());
manager.register(Event);
return Event;
}
@ -84,12 +84,12 @@ public class EventControllerManagerTest {
public static class TestEvent1 implements HalEventConfig {
@Override
public Class<? extends HalEventController> getEventControllerClass() {
public Class<? extends HalEventController> getDeviceControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalEventData> getEventDataClass() {
public Class<? extends HalEventData> getDeviceDataClass() {
return OnOffEventData.class;
}
}
@ -97,12 +97,12 @@ public class EventControllerManagerTest {
public static class TestEvent2 implements HalEventConfig {
@Override
public Class<? extends HalEventController> getEventControllerClass() {
public Class<? extends HalEventController> getDeviceControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalEventData> getEventDataClass() {
public Class<? extends HalEventData> getDeviceDataClass() {
return OnOffEventData.class;
}
}
@ -111,7 +111,7 @@ public class EventControllerManagerTest {
int size;
@Override
public void initialize() throws Exception { }
public void initialize() { }
@Override
public void register(HalEventConfig event) {
@ -134,7 +134,7 @@ public class EventControllerManagerTest {
}
@Override
public void setListener(HalEventReportListener listener) { }
public void setListener(HalDeviceReportListener listener) { }
@Override
public void close() { }

59
hal-core/test/se/hal/SensorControllerManagerTest.java
View file

@ -1,10 +1,11 @@
package se.hal;
import org.junit.Test;
import se.hal.intf.HalAbstractController;
import se.hal.intf.HalDeviceReportListener;
import se.hal.intf.HalSensorConfig;
import se.hal.intf.HalSensorController;
import se.hal.intf.HalSensorData;
import se.hal.intf.HalSensorReportListener;
import se.hal.struct.Sensor;
import se.hal.struct.devicedata.HumiditySensorData;
import se.hal.struct.devicedata.TemperatureSensorData;
@ -16,52 +17,52 @@ import static org.junit.Assert.*;
public class SensorControllerManagerTest {
private ControllerManager manager = new ControllerManager();
private SensorControllerManager manager = new SensorControllerManager();
@Test
public void addAvailableSensor(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableSensors());
public void addAvailableDevice(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableDeviceConfigs());
manager.addAvailableSensor(TestSensor1.class);
assertEquals(1, manager.getAvailableSensors().size());
assertTrue(manager.getAvailableSensors().contains(TestSensor1.class));
manager.addAvailableDevice(TestSensor1.class);
assertEquals(1, manager.getAvailableDeviceConfigs().size());
assertTrue(manager.getAvailableDeviceConfigs().contains(TestSensor1.class));
manager.addAvailableSensor(TestSensor2.class);
assertEquals(2, manager.getAvailableSensors().size());
assertTrue(manager.getAvailableSensors().contains(TestSensor1.class));
assertTrue(manager.getAvailableSensors().contains(TestSensor2.class));
manager.addAvailableDevice(TestSensor2.class);
assertEquals(2, manager.getAvailableDeviceConfigs().size());
assertTrue(manager.getAvailableDeviceConfigs().contains(TestSensor1.class));
assertTrue(manager.getAvailableDeviceConfigs().contains(TestSensor2.class));
// Add duplicate sensor
manager.addAvailableSensor(TestSensor1.class);
assertEquals("No duplicate check",2, manager.getAvailableSensors().size());
manager.addAvailableDevice(TestSensor1.class);
assertEquals("No duplicate check",2, manager.getAvailableDeviceConfigs().size());
}
@Test
public void registerUnavailableSensor(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableSensors());
assertEquals(Collections.EMPTY_LIST, manager.getAvailableDeviceConfigs());
Sensor sensor = new Sensor();
sensor.setDeviceConfig(new TestSensor1());
manager.register(sensor);
assertEquals("No Sensor registered", Collections.EMPTY_LIST, manager.getRegisteredSensors());
assertEquals("No Sensor registered", Collections.EMPTY_LIST, manager.getRegisteredDevices());
}
@Test
public void registerOneSensor() {
Sensor sensor1 = registerSensor(new TestSensor1());
assertEquals(1, manager.getRegisteredSensors().size());
assertTrue(manager.getRegisteredSensors().contains(sensor1));
assertEquals(1, manager.getRegisteredDevices().size());
assertTrue(manager.getRegisteredDevices().contains(sensor1));
}
@Test
public void registerTwoSensors(){
Sensor sensor1 = registerSensor(new TestSensor1());
Sensor sensor2 = registerSensor(new TestSensor2());
assertEquals(2, manager.getRegisteredSensors().size());
assertTrue(manager.getRegisteredSensors().contains(sensor1));
assertTrue(manager.getRegisteredSensors().contains(sensor2));
assertEquals(2, manager.getRegisteredDevices().size());
assertTrue(manager.getRegisteredDevices().contains(sensor1));
assertTrue(manager.getRegisteredDevices().contains(sensor2));
}
@ -69,7 +70,7 @@ public class SensorControllerManagerTest {
public void deregisterSensor(){
Sensor sensor1 = registerSensor(new TestSensor1());
manager.deregister(sensor1);
assertEquals(Collections.EMPTY_LIST, manager.getRegisteredEvents());
assertEquals(Collections.EMPTY_LIST, manager.getRegisteredDevices());
}
@ -80,7 +81,7 @@ public class SensorControllerManagerTest {
private Sensor registerSensor(HalSensorConfig config){
Sensor sensor = new Sensor();
sensor.setDeviceConfig(config);
manager.addAvailableSensor(config.getClass());
manager.addAvailableDevice(config.getClass());
manager.register(sensor);
return sensor;
}
@ -99,12 +100,12 @@ public class SensorControllerManagerTest {
}
@Override
public Class<? extends HalSensorController> getSensorControllerClass() {
public Class<? extends HalAbstractController> getDeviceControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalSensorData> getSensorDataClass() {
public Class<? extends HalSensorData> getDeviceDataClass() {
return TemperatureSensorData.class;
}
}
@ -122,21 +123,21 @@ public class SensorControllerManagerTest {
}
@Override
public Class<? extends HalSensorController> getSensorControllerClass() {
public Class<? extends HalAbstractController> getDeviceControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalSensorData> getSensorDataClass() {
public Class<? extends HalSensorData> getDeviceDataClass() {
return HumiditySensorData.class;
}
}
public static class TestController implements HalSensorController{
public static class TestController implements HalSensorController {
int size;
@Override
public void initialize() throws Exception { }
public void initialize() { }
@Override
public void register(HalSensorConfig sensor) {
@ -152,7 +153,7 @@ public class SensorControllerManagerTest {
}
@Override
public void setListener(HalSensorReportListener listener) { }
public void setListener(HalDeviceReportListener listener) { }
@Override
public void close() { }