server

Better start at boot

Download Browse

+53 −52

Author

Debayan Sutradhar (rnayabed) 2021-06-28 23:44

Committer

Debayan Sutradhar (rnayabed) 2021-06-28 23:44

Hash 6de01d698523835e12b01696dcff65abea739877

Parent eb42c9fef8ee3879a73f4c4ca560bad33852ed4c

Reference git #server/6de01d698523835e12b01696dcff65abea739877

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/stream_pi/server/connection/MainServer.java

+29 −38

package com.stream_pi.server.connection;

import com.stream_pi.server.controller.ServerListener;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import javafx.application.Platform;

import java.io.IOException;

import java.net.*;

import java.util.Enumeration;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Logger;

public class MainServer extends Thread {

public class MainServer extends Thread

{

private ServerListener serverListener;

private Logger logger = Logger.getLogger(MainServer.class.getName());

private int port;

private ServerSocket serverSocket = null;

//private Server server;

private AtomicBoolean stop = new AtomicBoolean(false);

private ExceptionAndAlertHandler exceptionAndAlertHandler;

public MainServer(ServerListener serverListener, ExceptionAndAlertHandler exceptionAndAlertHandler)

{

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.serverListener = serverListener;

}

public void setPort(int port) {

this.port = port;

}

@Override

public synchronized void start() {

stop.set(false);

super.start();

}

public void stopListeningForConnections()

{

/*if(server !=null)

{

if(!server.isShutdown())

server.shutdown();

}*/

try

{

logger.info("Stopping listening for connections ...");

if(serverSocket!=null)

{

if(!serverSocket.isClosed())

{

stop.set(true);

serverSocket.close();

}

} catch (IOException e) {

}

catch (IOException e)

{

e.printStackTrace();

}

finally {

logger.info("... Done!");

}

@Override

public void run() {

public void run()

{

logger.warning("Starting main server on port "+port+" ...");

try {

try

{

logger.info("Starting server on port "+port+" ...");

serverSocket = new ServerSocket(port);

setupStageTitle(true);

setupStageTitle();

while(!stop.get())

{

Socket s = serverSocket.accept();

ClientConnections.getInstance().addConnection(new ClientConnection(s, serverListener, exceptionAndAlertHandler));

logger.info("New client connected ("+s.getRemoteSocketAddress()+") !");

}

catch (SocketException e)

{

if(!e.getMessage().contains("Socket closed") && !e.getMessage().contains("Interrupted function call: accept failed"))

{

logger.info("Main Server stopped accepting calls ...");

setupStageTitle(false);

serverListener.onServerStartFailure();

exceptionAndAlertHandler.handleMinorException(new MinorException("Sorry!","Server could not be started at "+port+".\n" +

"This could be due to another process or another instance of Stream-Pi Server using the same port. \n\n" +

"If another Server Instance probably running, close it. If not, try changing the port in settings and restart Stream-Pi Server." +

"If the problem still persists, consider contacting us. \n\nFull Message : "+e.getMessage()));

e.printStackTrace();

}

catch (IOException e)

{

exceptionAndAlertHandler.handleSevereException(new SevereException("MainServer io Exception occurred!"));

e.printStackTrace();

}

private void setupStageTitle(boolean isSuccess)

private void setupStageTitle()

{

try

{

if(isSuccess)

StringBuilder ips = new StringBuilder();

{

StringBuilder ips = new StringBuilder();

Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();

while(e.hasMoreElements())

{

NetworkInterface n = e.nextElement();

Enumeration<InetAddress> ee = n.getInetAddresses();

while (ee.hasMoreElements())

{

NetworkInterface n = e.nextElement();

InetAddress i = ee.nextElement();

Enumeration<InetAddress> ee = n.getInetAddresses();

String hostAddress = i.getHostAddress();

while (ee.hasMoreElements())

if(i instanceof Inet4Address)

{

InetAddress i = ee.nextElement();

ips.append(hostAddress);

String hostAddress = i.getHostAddress();

if(e.hasMoreElements())

if(i instanceof Inet4Address)

ips.append(" / ");

{

ips.append(hostAddress);

if(e.hasMoreElements())

ips.append(" / ");

}

Platform.runLater(()-> serverListener.getStage().setTitle("Stream-Pi Server - IP(s): "+ips+" | Port: "+ port));

}

else

{

Platform.runLater(()-> serverListener.getStage().setTitle("Stream-Pi Server - Offline"));

}

Platform.runLater(()-> serverListener.getStage().setTitle("Stream-Pi Server - IP(s): "+ips+" | Port: "+ port));

}

catch (Exception e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException("Error",e.getMessage()));

}

M src/main/java/com/stream_pi/server/controller/Controller.java

+10 −1

package com.stream_pi.server.controller;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.PropertySaver;

import com.stream_pi.action_api.action.ServerConnection;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.action_api.externalplugin.ToggleExtras;

import com.stream_pi.server.Main;

import com.stream_pi.server.action.ExternalPlugins;

import com.stream_pi.server.client.Client;

import com.stream_pi.server.client.ClientProfile;

import com.stream_pi.server.connection.ClientConnection;

import com.stream_pi.server.connection.ClientConnections;

import com.stream_pi.server.connection.MainServer;

import com.stream_pi.server.info.ServerInfo;

import com.stream_pi.server.info.StartupFlags;

import com.stream_pi.server.io.Config;

import com.stream_pi.server.window.Base;

import com.stream_pi.server.window.dashboard.DashboardBase;

import com.stream_pi.server.window.dashboard.DonatePopupContent;

import com.stream_pi.server.window.dashboard.actiongridpane.ActionBox;

import com.stream_pi.server.window.firsttimeuse.FirstTimeUse;

import com.stream_pi.server.window.settings.SettingsBase;

import com.stream_pi.util.alert.StreamPiAlert;

import com.stream_pi.util.alert.StreamPiAlertListener;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.exception.*;

import com.stream_pi.util.iohelper.IOHelper;

import javafx.animation.Animation;

import javafx.animation.Interpolator;

import javafx.animation.KeyFrame;

import javafx.animation.KeyValue;

import javafx.animation.Timeline;

import javafx.application.Platform;

import javafx.concurrent.Task;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.scene.image.Image;

import javafx.scene.media.AudioClip;

import javafx.stage.Modality;

import javafx.stage.Stage;

import javafx.stage.WindowEvent;

import javafx.util.Duration;

import java.awt.MenuItem;

import java.awt.PopupMenu;

import java.awt.SystemTray;

import java.awt.Toolkit;

import java.awt.TrayIcon;

import java.io.File;

import java.net.SocketAddress;

import java.util.Objects;

import java.util.Random;

import java.util.Timer;

import java.util.TimerTask;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.logging.Level;

public class Controller extends Base implements PropertySaver, ServerConnection, ToggleExtras

{

private final ExecutorService executor = Executors.newCachedThreadPool();

private MainServer mainServer;

private Animation openSettingsAnimation;

private Animation closeSettingsAnimation;

public Controller(){

mainServer = null;

}

public void setupDashWindow() throws SevereException

{

try

{

getStage().setOnCloseRequest(this::onCloseRequest);

}

catch (Exception e)

{

e.printStackTrace();

throw new SevereException(e.getMessage());

}

@Override

public void init()

{

try

{

initBase();

setupDashWindow();

setupSettingsWindowsAnimations();

ExternalPlugins.getInstance().setPropertySaver(this);

ExternalPlugins.getInstance().setToggleExtras(this);

ExternalPlugins.getInstance().setServerConnection(this);

getDashboardBase().getPluginsPane().getSettingsButton().setOnAction(event -> {

openSettingsAnimation.play();

});

getSettingsBase().getCloseButton().setOnAction(event -> {

closeSettingsAnimation.play();

});

getSettingsBase().getThemesSettings().setController(this);

mainServer = new MainServer(this, this);

if(getConfig().isFirstTimeUse())

{

firstTimeUse = new FirstTimeUse(this, this);

getChildren().add(firstTimeUse);

firstTimeUse.toFront();

getStage().setTitle("Stream-Pi Server");

getStage().show();

}

else

{

if(getConfig().isAllowDonatePopup())

{

if(new Random().nextInt(50) == 3)

new DonatePopupContent(getHostServices(), this).show();

}

othInit();

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void onServerStartFailure()

{

Platform.runLater(()-> getStage().setTitle("Stream-Pi Server - Offline"));

disableTrayIcon = true;

}

@Override

public void othInit()

{

try

{

if(StartupFlags.START_MINIMISED && SystemTray.isSupported())

{

minimiseApp();

}

else

{

getStage().show();

}

StreamPiAlert.setIsShowPopup(getConfig().isShowAlertsPopup());

}

catch(MinorException e)

{

handleMinorException(e);

}

if(getConfig().getSoundOnActionClickedStatus())

{

initSoundOnActionClicked();

}

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try

{

getSettingsBase().getGeneralSettings().loadDataFromConfig();

//themes

getSettingsBase().getThemesSettings().setThemes(getThemes());

getSettingsBase().getThemesSettings().setCurrentThemeFullName(getCurrentTheme().getFullName());

getSettingsBase().getThemesSettings().loadThemes();

//clients

getSettingsBase().getClientsSettings().loadData();

try

{

//Plugins

Platform.runLater(()->{

getDashboardBase().getPluginsPane().clearData();

getDashboardBase().getPluginsPane().loadOtherActions();

});

ExternalPlugins.setPluginsLocation(getConfig().getPluginsPath());

ExternalPlugins.getInstance().init();

Platform.runLater(()->getDashboardBase().getPluginsPane().loadData());

getSettingsBase().getPluginsSettings().loadPlugins();

}

catch (MinorException e)

{

getSettingsBase().getPluginsSettings().showPluginInitError();

handleMinorException(e);

}

//Server

mainServer.setPort(getConfig().getPort());

mainServer.start();

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

});

}

@Override

public void factoryReset()

{

getLogger().info("Reset to factory ...");

onQuitApp();

boolean result = IOHelper.deleteFile(getServerInfo().getPrePath());

if(result)

{

init();

}

else

{

handleSevereException(new SevereException("Unable to delete all files successfully. Installation corrupt. Re-install."));

}

private void setupSettingsWindowsAnimations()

{

Node settingsNode = getSettingsBase();

Node dashboardNode = getDashboardBase();

openSettingsAnimation = createOpenSettingsAnimation(settingsNode, dashboardNode);

closeSettingsAnimation = createCloseSettingsAnimation(settingsNode, dashboardNode);

}

private boolean disableTrayIcon = false;

public void onCloseRequest(WindowEvent event)

{

try

{

if(Config.getInstance().getMinimiseToSystemTrayOnClose() &&

SystemTray.isSupported())

SystemTray.isSupported() && !disableTrayIcon)

{

minimiseApp();

event.consume();

return;

}

onQuitApp();

exit();

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

public void onQuitApp()

{

getLogger().info("Shutting down ...");

try

{

if(getConfig() != null)

{

getConfig().setStartupWindowSize(getWidth(), getHeight());

getConfig().setRightDividerPositions(getDashboardBase().getDividerPositions());

getConfig().setLeftDividerPositions(getDashboardBase().getLeftSplitPane().getDividerPositions());

getConfig().save();

}

catch (SevereException e)

{

handleSevereException(e);

}

stopServerAndAllConnections();

ExternalPlugins.getInstance().shutDownActions();

closeLogger();

Config.nullify();

}

public void exit()

{

executor.shutdown();

Platform.exit();

}

private void stopServerAndAllConnections()

{

if(mainServer!=null)

mainServer.stopListeningForConnections();

ClientConnections.getInstance().disconnectAll();

}

@Override

public void restart()

{

getLogger().info("Restarting ...");

onQuitApp();

Platform.runLater(this::init);

}

public void minimiseApp() throws MinorException

{

try

{

SystemTray systemTray = SystemTray.getSystemTray();

if(getTrayIcon() == null)

initIconTray(systemTray);

systemTray.add(getTrayIcon());

getStage().hide();

getStage().setOnShown(windowEvent -> {

systemTray.remove(getTrayIcon());

});

}

catch(Exception e)

{

throw new MinorException(e.getMessage());

}

public void initIconTray(SystemTray systemTray)

{

Platform.setImplicitExit(false);

PopupMenu popup = new PopupMenu();

MenuItem exitItem = new MenuItem("Exit");

exitItem.addActionListener(l->{

systemTray.remove(getTrayIcon());

onQuitApp();

exit();

});

popup.add(exitItem);

TrayIcon trayIcon = new TrayIcon(

Toolkit.getDefaultToolkit().getImage(Main.class.getResource("app_icon.png")),

"Stream-Pi Server",

popup

);

trayIcon.addActionListener(l-> Platform.runLater(()-> {

getStage().show();

getStage().setAlwaysOnTop(true);

getStage().setAlwaysOnTop(false);

}));

trayIcon.setImageAutoSize(true);

this.trayIcon = trayIcon;

}

private TrayIcon trayIcon = null;

public TrayIcon getTrayIcon()

{

return trayIcon;

}

@Override

public void handleMinorException(MinorException e)

{

getLogger().log(Level.SEVERE, e.getShortMessage(), e);

e.printStackTrace();

new StreamPiAlert(e.getTitle(), e.getShortMessage(), StreamPiAlertType.WARNING).show();

}

@Override

public void handleSevereException(SevereException e)

{

getLogger().log(Level.SEVERE, e.getShortMessage(), e);

e.printStackTrace();

StreamPiAlert alert = new StreamPiAlert(e.getTitle(), e.getShortMessage(), StreamPiAlertType.ERROR);

alert.setOnClicked(new StreamPiAlertListener()

{

@Override

public void onClick(String txt)

{

onQuitApp();

exit();

}

});

alert.show();

}

private AudioClip audioClip = null;

private String audioFilePath = null;

private void playSound()

{

if(audioClip.isPlaying())

{

Platform.runLater(audioClip::stop);

return;

}

Platform.runLater(audioClip::play);

}

@Override

public void initSoundOnActionClicked()

{

audioFilePath = getConfig().getSoundOnActionClickedFilePath();

File file = new File(audioFilePath);

if(!file.exists())

{

audioFilePath = null;

audioClip = null;

getConfig().setSoundOnActionClickedStatus(false);

getConfig().setSoundOnActionClickedFilePath("");

handleMinorException(new MinorException("The sound file for on action click sound is missing."));

return;

}

audioClip = new AudioClip(file.toURI().toString());

}

@Override

public void onActionClicked(Client client, String profileID, String actionID, boolean toggle)

{

try

{

Action action = client.getProfileByID(profileID).getActionByID(actionID);

if(getConfig().getSoundOnActionClickedStatus())

{

playSound();

}

if(action.isInvalid())

{

throw new MinorException(

"The action isn't installed on the server."

);

}

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try

{

Thread.sleep(action.getDelayBeforeExecuting());

getLogger().info("action "+action.getID()+" clicked!");

if(action instanceof ToggleAction)

{

onToggleActionClicked((ToggleAction) action, toggle, profileID,

client.getRemoteSocketAddress());

}

else if (action instanceof NormalAction)

{

onNormalActionClicked((NormalAction) action, profileID,

client.getRemoteSocketAddress());

}

catch (InterruptedException e)

{

e.printStackTrace();

getLogger().info("onActionClicked scheduled task was interrupted ...");

}

return null;

}

});

}

catch (Exception e)

{

e.printStackTrace();

handleMinorException(new MinorException(e.getMessage()));

}

public synchronized void onNormalActionClicked(NormalAction action, String profileID, SocketAddress socketAddress)

{

try

{

action.onActionClicked();

}

catch (MinorException e)

{

sendActionFailed(e, socketAddress, profileID, action.getID());

}

public synchronized void onToggleActionClicked(ToggleAction action, boolean toggle, String profileID, SocketAddress socketAddress)

{

try

{

if(toggle)

{

action.onToggleOn();

}

else

{

action.onToggleOff();

}

catch (MinorException e)

{

sendActionFailed(e, socketAddress, profileID, action.getID());

}

@Override

public void clearTemp() {

Platform.runLater(() -> {

getDashboardBase().getClientAndProfileSelectorPane().refresh();

getDashboardBase().getActionGridPane().clear();

getDashboardBase().getActionGridPane().setFreshRender(true);

getDashboardBase().getActionDetailsPane().clear();

getSettingsBase().getClientsSettings().loadData();

});

}

@Override

public void saveServerProperties()

{

try

{

ExternalPlugins.getInstance().saveServerSettings();

getSettingsBase().getPluginsSettings().loadPlugins();

} catch (MinorException e) {

e.printStackTrace();

handleMinorException(e);

}

private void saveClientActionMain(String profileID, String actionID, SocketAddress socketAddress, boolean sendIcons)

{

try {

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress);

ClientProfile clientProfile = clientConnection.getClient().getProfileByID(profileID);

Action action = clientProfile.getActionByID(actionID);

clientConnection.saveActionDetails(profileID, action);

if(sendIcons && action.isHasIcon())

{

saveAllIcons(profileID, actionID, socketAddress, false);

}

Platform.runLater(()->{

try {

ActionBox actionBox = getDashboardBase().getActionGridPane().getActionBoxByIDAndProfileID(

action.getID(),

profileID

);

if(actionBox != null)

{

Platform.runLater(actionBox::init);

}

if(getDashboardBase().getActionDetailsPane().getAction() != null)

{

// This block is executed when no Action is selected.

if(getDashboardBase().getActionDetailsPane().getAction().getID().equals(actionID))

{

getDashboardBase().getActionDetailsPane().setAction(action);

getDashboardBase().getActionDetailsPane().refresh();

}

catch (Exception e)

{

e.printStackTrace();

}

});

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void saveClientAction(String profileID, String actionID, SocketAddress socketAddress, boolean sendIcons, boolean runAsync)

{

if(runAsync)

{

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

saveClientActionMain(profileID, actionID, socketAddress, sendIcons);

return null;

}

});

}

else

{

saveClientActionMain(profileID, actionID, socketAddress, sendIcons);

}

@Override

public void saveAllIcons(String profileID, String actionID, SocketAddress socketAddress)

{

saveAllIcons(profileID, actionID, socketAddress, true);

}

public void saveAllIcons(String profileID, String actionID, SocketAddress socketAddress, boolean async)

{

if(async)

{

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

saveAllIconsMain(profileID, actionID, socketAddress);

return null;

}

});

}

else

{

saveAllIconsMain(profileID, actionID, socketAddress);

}

private void saveAllIconsMain(String profileID, String actionID, SocketAddress socketAddress)

{

try {

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress);

ClientProfile clientProfile = clientConnection.getClient().getProfileByID(profileID);

Action action = clientProfile.getActionByID(actionID);

for(String eachState : action.getIcons().keySet())

{

clientConnection.sendIcon(profileID, actionID, eachState,

action.getIcon(eachState));

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public void saveIcon(String state, String profileID, String actionID, SocketAddress socketAddress) {

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try {

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress);

ClientProfile clientProfile = clientConnection.getClient().getProfileByID(profileID);

Action action = clientProfile.getActionByID(actionID);

clientConnection.sendIcon(profileID, actionID, state, action.getIcon(state));

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

});

}

@Override

public com.stream_pi.util.platform.Platform getPlatform() {

return ServerInfo.getInstance().getPlatform();

}

@Override

public void sendActionFailed(MinorException exception, SocketAddress socketAddress, String profileID, String actionID)

{

if(exception.getTitle() != null)

{

exception.setShortMessage(exception.getTitle()+"\n"+exception.getShortMessage());

}

exception.setTitle("Error while running action");

handleMinorException(exception);

executor.execute(new Task<Void>() {

@Override

protected Void call()

{

try {

ClientConnections.getInstance().getClientConnectionBySocketAddress(socketAddress)

.sendActionFailed(profileID, actionID);

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

});

}

private Animation createOpenSettingsAnimation(Node settingsNode, Node dashboardNode) {

Timeline openSettingsTimeline = new Timeline();

openSettingsTimeline.setCycleCount(1);

openSettingsTimeline.getKeyFrames().addAll(

new KeyFrame(Duration.millis(0.0D),

new KeyValue(settingsNode.opacityProperty(),

0.0D, Interpolator.EASE_IN),

new KeyValue(settingsNode.scaleXProperty(),

1.1D, Interpolator.EASE_IN),

new KeyValue(settingsNode.scaleYProperty(),

1.1D, Interpolator.EASE_IN),

new KeyValue(settingsNode.scaleZProperty(),

1.1D, Interpolator.EASE_IN)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(settingsNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleZProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(0.0D),

new KeyValue(dashboardNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(dashboardNode.opacityProperty(),

0.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

0.9D, Interpolator.LINEAR))

);

openSettingsTimeline.setOnFinished(e -> settingsNode.toFront());

return openSettingsTimeline;

}

private Animation createCloseSettingsAnimation(Node settingsNode, Node dashboardNode) {

Timeline closeSettingsTimeline = new Timeline();

closeSettingsTimeline.setCycleCount(1);

closeSettingsTimeline.getKeyFrames().addAll(

new KeyFrame(Duration.millis(0.0D),

new KeyValue(settingsNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleZProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(settingsNode.opacityProperty(),

0.0D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleXProperty(),

1.1D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleYProperty(),

1.1D, Interpolator.LINEAR),

new KeyValue(settingsNode.scaleZProperty(),

1.1D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(0.0D),

new KeyValue(dashboardNode.opacityProperty(),

0.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

0.9D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

0.9D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(dashboardNode.opacityProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleXProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleYProperty(),

1.0D, Interpolator.LINEAR),

new KeyValue(dashboardNode.scaleZProperty(),

1.0D, Interpolator.LINEAR))

);

closeSettingsTimeline.setOnFinished(event1 -> {

dashboardNode.toFront();

executor.execute(new Task<Void>() {

@Override

protected Void call() {

try {

getSettingsBase().getClientsSettings().loadData();

getSettingsBase().getGeneralSettings().loadDataFromConfig();

getSettingsBase().getPluginsSettings().loadPlugins();

getSettingsBase().getThemesSettings().setThemes(getThemes());

getSettingsBase().getThemesSettings().setCurrentThemeFullName(getCurrentTheme().getFullName());

getSettingsBase().getThemesSettings().loadThemes();

getSettingsBase().setDefaultTabToGeneral();

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

return null;

}

});

return closeSettingsTimeline;

}

@Override

public void setToggleStatus(boolean currentStatus, String profileID, String actionID, SocketAddress clientSocketAddress)

throws MinorException

{

ClientConnection clientConnection = ClientConnections.getInstance().getClientConnectionBySocketAddress(

clientSocketAddress

);

if(clientConnection == null)

throw new ClientNotFoundException("setToggleStatus failed because no client found with given socket address");

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

clientConnection.setToggleStatus(currentStatus, profileID, actionID);

}

catch (SevereException e)

{

handleSevereException(e);

}

return null;

}

}).start();

}

M src/main/java/com/stream_pi/server/controller/ServerListener.java

+1 −0

package com.stream_pi.server.controller;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.server.client.Client;

import com.stream_pi.server.window.dashboard.ClientAndProfileSelectorPane;

import com.stream_pi.server.window.dashboard.DashboardBase;

import com.stream_pi.server.window.settings.SettingsBase;

import com.stream_pi.util.exception.SevereException;

import javafx.stage.Stage;

import java.net.SocketAddress;

public interface ServerListener

{

void onActionClicked(Client client, String profileID, String actionID, boolean toggle);

void clearTemp();

void init();

void restart();

void othInit();

Stage getStage();

DashboardBase getDashboardBase();

SettingsBase getSettingsBase();

void initLogger() throws SevereException;

void factoryReset();

void initSoundOnActionClicked();

void onServerStartFailure();

}

M src/main/java/com/stream_pi/server/window/settings/GeneralSettings.java

+13 −13

package com.stream_pi.server.window.settings;

import com.stream_pi.action_api.actionproperty.property.FileExtensionFilter;

import com.stream_pi.server.controller.ServerListener;

import com.stream_pi.server.info.StartupFlags;

import com.stream_pi.server.io.Config;

import com.stream_pi.server.window.ExceptionAndAlertHandler;

import com.stream_pi.server.info.ServerInfo;

import com.stream_pi.util.alert.StreamPiAlert;

import com.stream_pi.util.alert.StreamPiAlertListener;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.checkforupdates.CheckForUpdates;

import com.stream_pi.util.checkforupdates.UpdateHyperlinkOnClick;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.platform.PlatformType;

import com.stream_pi.util.startatboot.StartAtBoot;

import com.stream_pi.util.uihelper.HBoxInputBox;

import com.stream_pi.util.uihelper.HBoxInputBoxWithDirectoryChooser;

import com.stream_pi.util.uihelper.HBoxInputBoxWithFileChooser;

import com.stream_pi.util.uihelper.HBoxWithSpaceBetween;

import javafx.application.HostServices;

import javafx.application.Platform;

import javafx.concurrent.Task;

import javafx.event.ActionEvent;

import javafx.geometry.Insets;

import javafx.geometry.Pos;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.control.TextField;

import javafx.scene.layout.*;

import javafx.stage.DirectoryChooser;

import javafx.stage.FileChooser;

import org.controlsfx.control.ToggleSwitch;

import org.kordamp.ikonli.javafx.FontIcon;

import org.w3c.dom.Text;

import java.awt.SystemTray;

import java.io.File;

import java.util.logging.Logger;

public class GeneralSettings extends VBox {

private final TextField serverNameTextField;

private final TextField portTextField;

private final TextField pluginsPathTextField;

private final TextField themesPathTextField;

private final TextField actionGridPaneActionBoxSize;

private final TextField actionGridPaneActionBoxGap;

private final ToggleSwitch startOnBootToggleSwitch;

private final HBoxWithSpaceBetween startOnBootHBox;

private final TextField soundOnActionClickedFilePathTextField;

private final ToggleSwitch soundOnActionClickedToggleSwitch;

private final HBoxWithSpaceBetween soundOnActionClickedToggleSwitchHBox;

private final ToggleSwitch minimizeToSystemTrayOnCloseToggleSwitch;

private final HBoxWithSpaceBetween minimizeToSystemTrayOnCloseHBox;

private final ToggleSwitch showAlertsPopupToggleSwitch;

private final HBoxWithSpaceBetween showAlertsPopupHBox;

private final Button saveButton;

private final Button checkForUpdatesButton;

private final Button factoryResetButton;

private Logger logger;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private ServerListener serverListener;

private HostServices hostServices;

public GeneralSettings(ExceptionAndAlertHandler exceptionAndAlertHandler, ServerListener serverListener, HostServices hostServices)

{

this.hostServices = hostServices;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.serverListener = serverListener;

logger = Logger.getLogger(GeneralSettings.class.getName());

serverNameTextField = new TextField();

portTextField = new TextField();

pluginsPathTextField = new TextField();

themesPathTextField = new TextField();

actionGridPaneActionBoxSize = new TextField();

actionGridPaneActionBoxGap = new TextField();

startOnBootToggleSwitch = new ToggleSwitch();

startOnBootHBox = new HBoxWithSpaceBetween("Start on Boot", startOnBootToggleSwitch);

startOnBootHBox.managedProperty().bind(startOnBootHBox.visibleProperty());

soundOnActionClickedToggleSwitch = new ToggleSwitch();

soundOnActionClickedToggleSwitchHBox = new HBoxWithSpaceBetween("Sound on Action Clicked", soundOnActionClickedToggleSwitch);

soundOnActionClickedFilePathTextField = new TextField();

HBoxInputBoxWithFileChooser soundHBoxInputBoxWithFileChooser = new HBoxInputBoxWithFileChooser("Sound File Path", soundOnActionClickedFilePathTextField,

new FileChooser.ExtensionFilter("Sounds","*.mp3","*.mp4", "*.m4a", "*.m4v","*.wav","*.aif", "*.aiff","*.fxm","*.flv","*.m3u8"));

soundHBoxInputBoxWithFileChooser.setUseLast(false);

soundHBoxInputBoxWithFileChooser.setRememberThis(false);

soundHBoxInputBoxWithFileChooser.getFileChooseButton().disableProperty().bind(soundOnActionClickedToggleSwitch.selectedProperty().not());

minimizeToSystemTrayOnCloseToggleSwitch = new ToggleSwitch();

minimizeToSystemTrayOnCloseHBox = new HBoxWithSpaceBetween("Minimise To Tray On Close", minimizeToSystemTrayOnCloseToggleSwitch);

showAlertsPopupToggleSwitch = new ToggleSwitch();

showAlertsPopupHBox = new HBoxWithSpaceBetween("Show Popup On Alert", showAlertsPopupToggleSwitch);

checkForUpdatesButton = new Button("Check for updates");

checkForUpdatesButton.setOnAction(event->checkForUpdates());

factoryResetButton = new Button("Factory Reset");

factoryResetButton.setOnAction(actionEvent -> onFactoryResetButtonClicked());

getStyleClass().add("general_settings");

prefWidthProperty().bind(widthProperty());

setAlignment(Pos.CENTER);

setSpacing(5);

getChildren().addAll(

new HBoxInputBox("Server Name", serverNameTextField),

new HBoxInputBox("Port", portTextField),

new HBoxInputBox("Grid Pane - Box Size", actionGridPaneActionBoxSize),

new HBoxInputBox("Grid Pane - Box Gap", actionGridPaneActionBoxGap),

new HBoxInputBoxWithDirectoryChooser("Plugins Path", pluginsPathTextField),

new HBoxInputBoxWithDirectoryChooser("Themes Path", themesPathTextField),

soundHBoxInputBoxWithFileChooser,

soundOnActionClickedToggleSwitchHBox,

minimizeToSystemTrayOnCloseHBox,

startOnBootHBox,

showAlertsPopupHBox

);

serverNameTextField.setPrefWidth(200);

saveButton = new Button("Save");

saveButton.setOnAction(event->save());

getChildren().addAll(factoryResetButton, checkForUpdatesButton, saveButton);

setPadding(new Insets(10));

}

private void checkForUpdates()

{

new CheckForUpdates(checkForUpdatesButton,

PlatformType.SERVER, ServerInfo.getInstance().getVersion(), new UpdateHyperlinkOnClick() {

@Override

public void handle(ActionEvent actionEvent) {

hostServices.showDocument(getURL());

}

});

}

public void loadDataFromConfig() throws SevereException {

Config config = Config.getInstance();

Platform.runLater(()->

{

serverNameTextField.setText(config.getServerName());

portTextField.setText(config.getPort()+"");

pluginsPathTextField.setText(config.getPluginsPath());

themesPathTextField.setText(config.getThemesPath());

actionGridPaneActionBoxSize.setText(config.getActionGridActionSize()+"");

actionGridPaneActionBoxGap.setText(config.getActionGridActionGap()+"");

minimizeToSystemTrayOnCloseToggleSwitch.setSelected(config.getMinimiseToSystemTrayOnClose());

showAlertsPopupToggleSwitch.setSelected(config.isShowAlertsPopup());

startOnBootToggleSwitch.setSelected(config.getStartOnBoot());

soundOnActionClickedToggleSwitch.setSelected(config.getSoundOnActionClickedStatus());

soundOnActionClickedFilePathTextField.setText(config.getSoundOnActionClickedFilePath());

});

}

public void save()

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try {

boolean toBeReloaded = false;

boolean dashToBeReRendered = false;

Platform.runLater(()->{

saveButton.setDisable(true);

});

String serverNameStr = serverNameTextField.getText();

String serverPortStr = portTextField.getText();

String pluginsPathStr = pluginsPathTextField.getText();

String themesPathStr = themesPathTextField.getText();

String actionGridActionBoxSize = actionGridPaneActionBoxSize.getText();

String actionGridActionBoxGap = actionGridPaneActionBoxGap.getText();

boolean minimizeToSystemTrayOnClose = minimizeToSystemTrayOnCloseToggleSwitch.isSelected();

boolean showAlertsPopup = showAlertsPopupToggleSwitch.isSelected();

boolean startOnBoot = startOnBootToggleSwitch.isSelected();

boolean soundOnActionClicked = soundOnActionClickedToggleSwitch.isSelected();

String soundOnActionClickedFilePath = soundOnActionClickedFilePathTextField.getText();

Config config = Config.getInstance();

StringBuilder errors = new StringBuilder();

if(serverNameStr.isBlank())

{

errors.append("* Server Name cannot be blank.\n");

}

else

{

if(!config.getServerName().equals(serverNameStr))

{

toBeReloaded = true;

}

int serverPort=-1;

try {

serverPort = Integer.parseInt(serverPortStr);

if (serverPort < 1024)

errors.append("* Server Port must be more than 1024\n");

else if(serverPort > 65535)

errors.append("* Server Port must be lesser than 65535\n");

if(config.getPort()!=serverPort)

{

toBeReloaded = true;

}

catch (NumberFormatException e)

{

errors.append("* Server Port must be integer.\n");

}

int actionSize=-1;

try {

actionSize = Integer.parseInt(actionGridActionBoxSize);

if(config.getActionGridActionSize() != actionSize)

{

dashToBeReRendered = true;

}

catch (NumberFormatException e)

{

errors.append("* action Size must be integer.\n");

}

int actionGap=-1;

try {

actionGap = Integer.parseInt(actionGridActionBoxGap);

if(config.getActionGridActionGap() != actionGap)

{

dashToBeReRendered = true;

}

catch (NumberFormatException e)

{

errors.append("* action Gap must be integer.\n");

}

if(pluginsPathStr.isBlank())

{

errors.append("* Plugins Path must not be blank.\n");

}

else

{

if(!config.getPluginsPath().equals(pluginsPathStr))

{

toBeReloaded = true;

}

if(themesPathStr.isBlank())

{

errors.append("* Themes Path must not be blank.\n");

}

else

{

if(!config.getThemesPath().equals(themesPathStr))

{

toBeReloaded = true;

}

if(!errors.toString().isEmpty())

{

throw new MinorException("Uh Oh!", "Please rectify the following errors and try again :\n"+errors.toString());

}

if(config.getStartOnBoot() != startOnBoot)

{

if(StartupFlags.RUNNER_FILE_NAME == null)

StartAtBoot startAtBoot = new StartAtBoot(PlatformType.SERVER, ServerInfo.getInstance().getPlatform());

if(startOnBoot)

{

new StreamPiAlert("Uh Oh", "No Runner File Name Specified as startup arguments. Cant set run at boot.", StreamPiAlertType.ERROR).show();

try

startOnBoot = false;

}

else

{

StartAtBoot startAtBoot = new StartAtBoot(PlatformType.SERVER, ServerInfo.getInstance().getPlatform());

if(startOnBoot)

{

startAtBoot.create(new File(StartupFlags.RUNNER_FILE_NAME));

startAtBoot.create(StartupFlags.RUNNER_FILE_NAME);

}

else

catch (MinorException e)

{

boolean result = startAtBoot.delete();

exceptionAndAlertHandler.handleMinorException(e);

if(!result)

startOnBoot = false;

new StreamPiAlert("Uh Oh!", "Unable to delete starter file", StreamPiAlertType.ERROR).show();

}

else

{

boolean result = startAtBoot.delete();

if(!result)

new StreamPiAlert("Uh Oh!", "Unable to delete starter file", StreamPiAlertType.ERROR).show();

}

if(minimizeToSystemTrayOnClose)

{

if(!SystemTray.isSupported())

{

StreamPiAlert alert = new StreamPiAlert("Not Supported", "Tray System not supported on this platform ", StreamPiAlertType.ERROR);

alert.show();

minimizeToSystemTrayOnClose = false;

}

if(soundOnActionClicked)

{

if(soundOnActionClickedFilePath.isBlank())

{

StreamPiAlert alert = new StreamPiAlert("No sound file specified",

"Sound File cannot be empty", StreamPiAlertType.ERROR);

alert.show();

soundOnActionClicked = false;

}

else

{

File soundFile = new File(soundOnActionClickedFilePath);

if(!soundFile.exists() || !soundFile.isFile())

{

StreamPiAlert alert = new StreamPiAlert("File not found",

"No sound file at \n"+soundOnActionClickedFilePath+"\n" +

"Unable to set sound on action clicked.", StreamPiAlertType.ERROR);

alert.show();

soundOnActionClicked = false;

}

config.setServerName(serverNameStr);

config.setServerPort(serverPort);

config.setActionGridGap(actionGap);

config.setActionGridSize(actionSize);

config.setPluginsPath(pluginsPathStr);

config.setThemesPath(themesPathStr);

config.setMinimiseToSystemTrayOnClose(minimizeToSystemTrayOnClose);

StreamPiAlert.setIsShowPopup(showAlertsPopup);

config.setShowAlertsPopup(showAlertsPopup);

config.setStartupOnBoot(startOnBoot);

if(soundOnActionClicked)

{

serverListener.initSoundOnActionClicked();

}

config.setSoundOnActionClickedStatus(soundOnActionClicked);

config.setSoundOnActionClickedFilePath(soundOnActionClickedFilePath);

config.save();

loadDataFromConfig();

if(toBeReloaded)

{

StreamPiAlert restartPrompt = new StreamPiAlert(

"Warning",

"Stream-Pi Server needs to be restarted for these changes to take effect. Restart?\n" +

"All your current connections will be disconnected.",

StreamPiAlertType.WARNING

);

String yesOption = "Yes";

String noOption = "No";

restartPrompt.setButtons(yesOption, noOption);

restartPrompt.setOnClicked(new StreamPiAlertListener() {

@Override

public void onClick(String s) {

if(s.equals(yesOption))

{

serverListener.restart();

}

});

restartPrompt.show();

}

if(dashToBeReRendered)

{

serverListener.clearTemp();

}

catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

finally {

Platform.runLater(()->{

saveButton.setDisable(false);

});

}

return null;

}

}).start();

}

private void onFactoryResetButtonClicked()

{

StreamPiAlert confirmation = new StreamPiAlert("Warning","Are you sure?\n" +

"This will erase everything.",StreamPiAlertType.WARNING);

String yesButton = "Yes";

String noButton = "No";

confirmation.setButtons(yesButton, noButton);

confirmation.setOnClicked(new StreamPiAlertListener() {

@Override

public void onClick(String s) {

if(s.equals(yesButton))

{

serverListener.factoryReset();

}

});

confirmation.show();

}

Public

server

Clone or download

Better start at boot

Modified Files