561 lines
15 KiB
Java
561 lines
15 KiB
Java
package org.hwo.pulscounter;
|
|
|
|
import static org.hwo.logging.Logging.log;
|
|
import static org.hwo.logging.LogLevel.*;
|
|
|
|
import java.awt.Component;
|
|
import java.awt.EventQueue;
|
|
import java.awt.Frame;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Constructor;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashSet;
|
|
import java.util.InvalidPropertiesFormatException;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Properties;
|
|
import java.util.Vector;
|
|
import java.util.prefs.BackingStoreException;
|
|
import java.util.prefs.Preferences;
|
|
|
|
import javax.swing.JFrame;
|
|
|
|
import org.hsqldb.persist.EventLogInterface;
|
|
import org.hwo.StringHelper;
|
|
import org.hwo.configuration.ConfigurableObjects;
|
|
import org.hwo.i18n.Messages;
|
|
import org.hwo.io.NewSerialPort.NewSerialPort;
|
|
import org.hwo.logging.Logging;
|
|
import org.hwo.platform.Platform;
|
|
import org.hwo.servicelink.ServiceLink;
|
|
import org.hwo.servicelink.ServiceLinkListener;
|
|
import org.hwo.pulscounter.db.PulsCounterDatabase;
|
|
import org.hwo.pulscounter.device.IDeviceConnector;
|
|
import org.hwo.pulscounter.device.ServiceLinkDeviceConnector;
|
|
import org.hwo.pulscounter.device.SimpleLinkDeviceConnector;
|
|
import org.hwo.pulscounter.device.SimulatedCounter;
|
|
import org.hwo.pulscounter.ui.AppSettingsListener;
|
|
import org.hwo.pulscounter.ui.BatchRunner;
|
|
import org.hwo.pulscounter.ui.NewMainWindow;
|
|
import org.hwo.pulscounter.ui.ShutdownNotification;
|
|
import org.hwo.scheduler.Scheduler;
|
|
|
|
public class PulsCounterApplication implements ServiceLinkListener{
|
|
|
|
static PulsCounterApplication _application;
|
|
public static PulsCounterApplication getApplication(){
|
|
if (_application == null)
|
|
_application = new PulsCounterApplication(null);
|
|
|
|
return _application;
|
|
}
|
|
|
|
private Properties applicationConfiguration,
|
|
defaultConfiguration;
|
|
|
|
private Object uiSynchronization;
|
|
private boolean uiIsFinished;
|
|
private boolean shouldSaveConfiguration;
|
|
|
|
private boolean dontLoadTranslations;
|
|
|
|
private List<PulsCounterApplicationListener>
|
|
applicationListeners;
|
|
|
|
private Vector<String> unseenMessages;
|
|
|
|
private List<Class<IDeviceConnector>>
|
|
interfaceClasses;
|
|
private List<IDeviceConnector> interfaces;
|
|
|
|
private PulsCounterDatabase database;
|
|
|
|
private List<String> batchCommands;
|
|
|
|
|
|
|
|
|
|
private NewSerialPort serialPort;
|
|
private ServiceLink serviceLink;
|
|
|
|
private List<AppSettingsListener> appSettingsListeners;
|
|
|
|
private boolean snapshotLock;
|
|
|
|
|
|
private List<ExportSetting> exportSettings;
|
|
|
|
private Scheduler scheduler;
|
|
|
|
private String[] channelDescriptions;
|
|
|
|
public PulsCounterApplication(String[] args) {
|
|
/* Initialize Logging Framework */
|
|
logStartup();
|
|
|
|
/* Check... */
|
|
if (_application != null){
|
|
throw new InstantiationError("Only one Instance of PulsCounterApplication can exist!");
|
|
} else {
|
|
_application = this;
|
|
}
|
|
|
|
/* Initialize fields... */
|
|
uiIsFinished = false;
|
|
uiSynchronization = new Object();
|
|
applicationListeners = new LinkedList<PulsCounterApplicationListener>();
|
|
unseenMessages = new Vector<String>();
|
|
exportSettings = new ArrayList<>();
|
|
|
|
interfaceClasses = new ArrayList<>();
|
|
interfaces = new ArrayList<>();
|
|
|
|
batchCommands = new ArrayList<>();
|
|
|
|
/* Prepare Translation Framework */
|
|
Messages i18n = Messages.getInstance();
|
|
i18n.setMissingKeysFileName("missing-translation.txt");
|
|
|
|
/* Prepare for Startup */
|
|
loadApplicationConfiguration();
|
|
|
|
/* Parse Command Line Arguments */
|
|
Iterator<String> options = Arrays.asList(args).iterator();
|
|
|
|
while (options.hasNext()){
|
|
String option = options.next();
|
|
|
|
switch (option){
|
|
case "--gui":
|
|
if (!options.hasNext()){
|
|
log(FATAL,"Argument to --gui is missing");
|
|
throw new IllegalArgumentException("Argument to --gui is missing");
|
|
} else {
|
|
applicationConfiguration.setProperty("ui.class", options.next());
|
|
}
|
|
break;
|
|
case "--batch":
|
|
case "-B":
|
|
applicationConfiguration.setProperty("ui.class", BatchRunner.class.getCanonicalName());
|
|
break;
|
|
case "-G":
|
|
applicationConfiguration.setProperty("ui.class", NewMainWindow.class.getCanonicalName());
|
|
break;
|
|
case "--batch-execute":
|
|
batchCommands.add( options.next() );
|
|
break;
|
|
case "--no-translation":
|
|
dontLoadTranslations = true;
|
|
break;
|
|
default:
|
|
log(WARN,"Unknown command line parameter: %s", option);
|
|
}
|
|
}
|
|
|
|
if (!dontLoadTranslations){
|
|
Messages.loadMessages(PulsCounterApplication.class);
|
|
} else {
|
|
log(INFO,"Translation text fragments are NOT loaded, due to command line switch (--no-translation)");
|
|
}
|
|
|
|
/* Old stuff... */
|
|
// this.initialize();
|
|
}
|
|
|
|
|
|
private Properties createDefaultApplicationConfiguration(){
|
|
|
|
defaultConfiguration = new Properties();
|
|
|
|
defaultConfiguration.setProperty("ui.class", NewMainWindow.class.getCanonicalName());
|
|
defaultConfiguration.setProperty("interface.classes", StringHelper.join(new String[]{
|
|
ServiceLinkDeviceConnector.class.getCanonicalName(),
|
|
SimulatedCounter.class.getCanonicalName(),
|
|
SimpleLinkDeviceConnector.class.getCanonicalName()
|
|
}, ","));
|
|
|
|
return defaultConfiguration;
|
|
}
|
|
|
|
private void loadApplicationConfiguration(){
|
|
createDefaultApplicationConfiguration();
|
|
|
|
applicationConfiguration = new Properties(defaultConfiguration);
|
|
|
|
|
|
try {
|
|
/* Try to load configuration from file */
|
|
FileInputStream fis = new FileInputStream("synololog.cfg");
|
|
applicationConfiguration.loadFromXML(fis);
|
|
fis.close();
|
|
|
|
} catch (InvalidPropertiesFormatException e) {
|
|
log(WARN,"synololog.cfg is misformated");
|
|
} catch (FileNotFoundException e) {
|
|
log(WARN,"synololog.cfg not found");
|
|
} catch (IOException e) {
|
|
log(ERROR,"I/O Error reading synololog.cfg");
|
|
}
|
|
|
|
applicationConfiguration.setProperty("ui.class", NewMainWindow.class.getCanonicalName());
|
|
|
|
}
|
|
|
|
public Properties getApplicationConfiguration(){
|
|
return this.applicationConfiguration;
|
|
}
|
|
|
|
private static void logStartup(){
|
|
log("Synololog Application Startup");
|
|
|
|
log("JAVA Environment: %s (%s)", System.getProperty("java.version"),
|
|
System.getProperty("java.vendor"));
|
|
|
|
log("Operating System: %s [%s] %s", System.getProperty("os.name"),
|
|
System.getProperty("os.arch"),
|
|
System.getProperty("os.version"));
|
|
|
|
log("User Environment: %s (%s) (CWD:%s)", System.getProperty("user.name"),
|
|
System.getProperty("user.home"),
|
|
System.getProperty("user.dir"));
|
|
|
|
log("Hostname: %s",Platform.getHostName());
|
|
log("OS Search Path: %s", System.getenv("PATH"));
|
|
}
|
|
|
|
public String[] getBatchCommands(){
|
|
return batchCommands.toArray(new String[0]);
|
|
}
|
|
|
|
|
|
public void start(){
|
|
|
|
initialize();
|
|
|
|
String uiClassName = applicationConfiguration.getProperty("ui.class");
|
|
Object ui = null;
|
|
|
|
try {
|
|
Class uiClazz = PulsCounterApplication.class.getClassLoader().loadClass(uiClassName);
|
|
|
|
Constructor<?> constructor = uiClazz.getConstructor(PulsCounterApplication.class);
|
|
ui = (Object) constructor.newInstance(this);
|
|
|
|
} catch (ClassNotFoundException e) {
|
|
log(FATAL,"user interface class could not be loaded [%s] %s",uiClassName,e.getMessage());
|
|
} catch (NoSuchMethodException e) {
|
|
log(FATAL,"user interface class misses valid constructor [%s] %s",uiClassName,e.getMessage());
|
|
} catch (SecurityException e) {
|
|
e.printStackTrace();
|
|
} catch (Exception e) {
|
|
log(FATAL,"user interface class could not be instantiated. [%s] %s",uiClassName,e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
|
|
waitUiFinished();
|
|
|
|
// ShutdownNotification sn = new ShutdownNotification();
|
|
// if (Component.class.isInstance(ui)){
|
|
// sn.setLocationRelativeTo((Component)ui);
|
|
// }
|
|
// sn.setVisible(true);
|
|
|
|
try {
|
|
|
|
shutdown();
|
|
|
|
} catch (Exception e){
|
|
log(e);
|
|
}
|
|
|
|
// sn.setVisible(false);
|
|
}
|
|
|
|
private void initialize(){
|
|
|
|
/* Interface Classes should be merged with application well known*/
|
|
HashSet<String> interfaceClassNames = new HashSet<>();
|
|
for (String icn: applicationConfiguration.getProperty("interface.classes").split(",")){
|
|
interfaceClassNames.add(icn);
|
|
}
|
|
for (String icn: defaultConfiguration.getProperty("interface.classes").split(",")){
|
|
interfaceClassNames.add(icn);
|
|
}
|
|
|
|
|
|
for (String interfaceClassName: interfaceClassNames){
|
|
|
|
try {
|
|
|
|
Class<IDeviceConnector> clazz = (Class<IDeviceConnector>)PulsCounterApplication.class.getClassLoader().loadClass(interfaceClassName);
|
|
interfaceClasses.add(clazz);
|
|
|
|
} catch (ClassNotFoundException e) {
|
|
log(ERROR,"Interface class could not be loaded: %s",interfaceClassName);
|
|
}
|
|
|
|
}
|
|
|
|
Integer nIntf = Integer.parseInt(applicationConfiguration.getProperty("interfaces.n","0"));
|
|
for (int n=0;n<nIntf;n++){
|
|
Class<IDeviceConnector> clazz = getInterfaceClass(applicationConfiguration.getProperty(String.format("interfaces.%d.class",n)));
|
|
addInterface(clazz, applicationConfiguration.getProperty(String.format("interfaces.%d.settings",n)));
|
|
}
|
|
|
|
database = new PulsCounterDatabase();
|
|
log(INFO,"Database Schema Version: %s", database.getSchemaVersion());
|
|
|
|
|
|
String sProfiles = database.getProperty("export.profiles");
|
|
if (sProfiles != null){
|
|
Integer nProfiles = new Integer(sProfiles);
|
|
for (int n=0;n<nProfiles;n++){
|
|
String profileConf = database.getProperty(String.format("export.profiles.%d",n));
|
|
log(INFO,"Export Profile %d: %s",n,profileConf);
|
|
|
|
if (profileConf != null){
|
|
ExportSetting es = new ExportSetting();
|
|
ConfigurableObjects.setConfiguration(es, profileConf);
|
|
exportSettings.add(es);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
private void shutdown(){
|
|
|
|
log(INFO,"Application shutdown...");
|
|
|
|
for (IDeviceConnector c: interfaces){
|
|
c.shutdown();
|
|
}
|
|
|
|
|
|
/* Dispose all left frames */
|
|
for (Frame frame: JFrame.getFrames()){
|
|
frame.setVisible(false);
|
|
frame.dispose();
|
|
}
|
|
|
|
if (shouldSaveConfiguration){
|
|
|
|
applicationConfiguration.setProperty("interfaces.n", Integer.toString(interfaces.size()));
|
|
for (int n=0;n<interfaces.size();n++){
|
|
applicationConfiguration.setProperty(String.format("interfaces.%d.class", n), interfaces.get(n).getClass().getCanonicalName());
|
|
applicationConfiguration.setProperty(String.format("interfaces.%d.settings", n), interfaces.get(n).getConnectionSettings());
|
|
}
|
|
|
|
for (int n=0;n<exportSettings.size();n++){
|
|
String conf = ConfigurableObjects.getConfiguration(exportSettings.get(n));
|
|
if (conf != null){
|
|
database.setProperty(String.format("export.profiles.%d", n), conf);
|
|
}
|
|
}
|
|
database.setProperty("export.profiles", new Integer(exportSettings.size()).toString());
|
|
|
|
|
|
|
|
try {
|
|
log(INFO,"Save application configuration");
|
|
FileOutputStream fos = new FileOutputStream("synololog.cfg");
|
|
applicationConfiguration.storeToXML(fos, "Synololog Application Configuration");
|
|
fos.flush();
|
|
fos.close();
|
|
} catch (FileNotFoundException e) {
|
|
log(ERROR,"synololog.cfg could not be created/opened for writing");
|
|
} catch (IOException e) {
|
|
log(ERROR,"synololog.cfg could not be written");
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
database.close();
|
|
|
|
Messages.getInstance().saveMissingStrings();
|
|
|
|
}
|
|
|
|
|
|
private void waitUiFinished(){
|
|
|
|
synchronized (uiSynchronization) {
|
|
|
|
while (!uiIsFinished){
|
|
try {
|
|
uiSynchronization.wait(250);
|
|
} catch (InterruptedException e){
|
|
log(e);
|
|
}
|
|
}
|
|
}
|
|
log(INFO,"UI notified finish");
|
|
|
|
}
|
|
|
|
public void notifyUiIsFinished(boolean saveApplicationConfiguration){
|
|
synchronized (uiSynchronization) {
|
|
uiIsFinished = true;
|
|
shouldSaveConfiguration = saveApplicationConfiguration;
|
|
uiSynchronization.notify();
|
|
}
|
|
}
|
|
|
|
|
|
/* Interface Types */
|
|
public List<Class<IDeviceConnector>> getInterfaceClasses(){
|
|
return this.interfaceClasses;
|
|
}
|
|
|
|
private Class<IDeviceConnector> getInterfaceClass(String className){
|
|
for (Class<IDeviceConnector> c:interfaceClasses){
|
|
if (c.getCanonicalName().equals(className))
|
|
return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* Physical Interfaces */
|
|
public List<IDeviceConnector> getInterfaces(){
|
|
return this.interfaces;
|
|
}
|
|
public void addInterface(Class<IDeviceConnector> clazz,String connectionSettings){
|
|
|
|
try {
|
|
IDeviceConnector idc = clazz.newInstance();
|
|
idc.setConnectionSettings(connectionSettings);
|
|
interfaces.add(idc);
|
|
fireinterfacesChanged();
|
|
|
|
} catch (InstantiationException e) {
|
|
e.printStackTrace();
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
}
|
|
public void removeInterface(IDeviceConnector intf){
|
|
interfaces.remove(intf);
|
|
fireinterfacesChanged();
|
|
}
|
|
|
|
private void fireinterfacesChanged(){
|
|
log(INFO,"interfaces changed");
|
|
|
|
for (PulsCounterApplicationListener l: applicationListeners){
|
|
l.interfacesChanged(this);
|
|
}
|
|
}
|
|
|
|
public PulsCounterDatabase getDatabase() {
|
|
return database;
|
|
}
|
|
|
|
|
|
/* Snapshots */
|
|
public void checkForSnapShots(){
|
|
|
|
for (IDeviceConnector idc: this.interfaces){
|
|
Integer deviceSerial = idc.getDeviceSerial();
|
|
Integer highestIndex = database.highestSnapShot(deviceSerial);
|
|
|
|
log(INFO,"Highest known snapshot index for device #%d is %d", deviceSerial, highestIndex);
|
|
|
|
SnapShot[] snapshots = idc.readSnapShots(highestIndex+1);
|
|
if (snapshots != null){
|
|
getDatabase().storeSnapshots(snapshots);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public void addSnapshotToDatabase(SnapShot snapShot){
|
|
getDatabase().storeSnapshots(new SnapShot[]{ snapShot });
|
|
}
|
|
|
|
|
|
/* ToDO: Upgrade the old stuff ... */
|
|
|
|
/*
|
|
private void initialize(){
|
|
appSettingsListeners = new LinkedList<AppSettingsListener>();
|
|
exportSettings = new LinkedList<ExportSetting>();
|
|
scheduler = new Scheduler();
|
|
|
|
channelDescriptions = new String[32];
|
|
|
|
loadPrefs();
|
|
|
|
try {
|
|
snapshotManager = new SnapshotManager();
|
|
snapshotManager.notify(Notification.INITIALIZE);
|
|
|
|
} catch (FileNotFoundException e){
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
*/
|
|
|
|
public void addAppSettingsListener(AppSettingsListener listener){
|
|
appSettingsListeners.add(listener);
|
|
}
|
|
public void removeAppSettingsListener(AppSettingsListener listener){
|
|
appSettingsListeners.remove(listener);
|
|
}
|
|
|
|
public void addPulsCounterApplicationListener(PulsCounterApplicationListener listener){
|
|
applicationListeners.add(listener);
|
|
}
|
|
public void removePulsCounterApplicationListener(PulsCounterApplicationListener listener){
|
|
applicationListeners.remove(listener);
|
|
}
|
|
|
|
|
|
public void fireServiceLinkChanged(){
|
|
for (AppSettingsListener l: appSettingsListeners){
|
|
l.ServiceLinkChanged(serviceLink);
|
|
}
|
|
}
|
|
|
|
|
|
public void message(String message){
|
|
log(INFO, message);
|
|
|
|
if (applicationListeners.size() == 0){
|
|
unseenMessages.addElement(message);
|
|
} else {
|
|
while (!unseenMessages.isEmpty()){
|
|
String msg = unseenMessages.remove(0);
|
|
for (PulsCounterApplicationListener listener: applicationListeners){
|
|
listener.messageArrived(msg);
|
|
}
|
|
}
|
|
|
|
for (PulsCounterApplicationListener listener: applicationListeners){
|
|
listener.messageArrived(message);
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public void connectionStateChanged(Boolean connected) {
|
|
}
|
|
|
|
|
|
public List<ExportSetting> getExportSettings() {
|
|
return exportSettings;
|
|
}
|
|
|
|
|
|
|
|
}
|