client

Auto reconnect, Refactored some messages, Added ready method

Download Browse

+94 −25

Author

Debayan Sutradhar (rnayabed) 2021-04-29 17:59

Committer

Debayan Sutradhar (rnayabed) 2021-04-29 17:59

Hash 07986db99c6e15fcc1bec8841b4e3ebfae33aaaf

Parent 4348f491f79c46bd61c7b7b927563b518cc846f4

Reference git #client/07986db99c6e15fcc1bec8841b4e3ebfae33aaaf

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/stream_pi/client/connection/Client.java

+34 −15

package com.stream_pi.client.connection;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.DisplayTextAlignment;

import com.stream_pi.action_api.action.Location;

import com.stream_pi.action_api.actionproperty.ClientProperties;

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

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

import com.stream_pi.client.io.Config;

import com.stream_pi.client.info.ClientInfo;

import com.stream_pi.client.profile.ClientProfile;

import com.stream_pi.client.window.ExceptionAndAlertHandler;

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

import com.stream_pi.theme_api.Theme;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.comms.Message;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.version.Version;

import javafx.application.Platform;

import javafx.concurrent.Task;

import java.io.*;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.util.ArrayList;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Logger;

public class Client extends Thread

{

private Socket socket;

private ObjectOutputStream oos;

private ObjectInputStream ois;

private final AtomicBoolean stop = new AtomicBoolean(false);

private AtomicBoolean stop = new AtomicBoolean(false);

private final ClientListener clientListener;

private ClientListener clientListener;

private final ExceptionAndAlertHandler exceptionAndAlertHandler;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private final ClientInfo clientInfo;

private ClientInfo clientInfo;

private final String serverIP;

private String serverIP;

private final int serverPort;

private int serverPort;

private final Logger logger;

private Logger logger;

public Client(String serverIP, int serverPort, ClientListener clientListener, ExceptionAndAlertHandler exceptionAndAlertHandler)

private Runnable onConnectAndSetupToBeRun;

public Client(String serverIP, int serverPort, ClientListener clientListener,

ExceptionAndAlertHandler exceptionAndAlertHandler, Runnable onConnectAndSetupToBeRun)

{

this.serverIP = serverIP;

this.serverPort = serverPort;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.clientInfo = ClientInfo.getInstance();

this.clientListener = clientListener;

this.onConnectAndSetupToBeRun = onConnectAndSetupToBeRun;

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

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

try

{

logger.info("Trying to connect to server at "+serverIP+":"+serverPort);

socket = new Socket();

socket.connect(new InetSocketAddress(serverIP, serverPort), 5000);

clientListener.setConnected(true);

clientListener.updateSettingsConnectDisconnectButton();

logger.info("Connected to "+socket.getRemoteSocketAddress()+" !");

}

catch (IOException e)

{

e.printStackTrace();

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

throw new MinorException("Connection Error", "Unable to connect to server. Please check settings and connection and try again.");

}

try

{

oos = new ObjectOutputStream(socket.getOutputStream());

ois = new ObjectInputStream(socket.getInputStream());

}

catch (IOException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

throw new MinorException("Unable to set up io Streams to server. Check connection and try again.");

}

start();

} catch (MinorException e)

{

exceptionAndAlertHandler.handleMinorException(e);

}

return null;

}

}).start();

}

public synchronized void exit()

{

if(stop.get())

return;

logger.info("Stopping ...");

try

{

if(socket!=null)

{

disconnect();

}

catch (SevereException e)

{

logger.severe(e.getMessage());

exceptionAndAlertHandler.handleSevereException(e);

e.printStackTrace();

}

public synchronized void sendMessage(Message message) throws SevereException

{

try

{

oos.writeObject(message);

oos.flush();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to io Stream!");

}

@Override

public void run() {

try

{

while(!stop.get())

{

try

{

Message message = (Message) ois.readObject();

String header = message.getHeader();

logger.info("Message Received. Heading : "+header);

switch (header)

{

case "ready" : onServerReady();

break;

case "action_icon" : onActionIconReceived(message);

break;

case "disconnect" : serverDisconnected(message);

break;

case "get_client_details" : sendClientDetails();

break;

case "get_client_screen_details" : sendClientScreenDetails();

break;

case "get_profiles" : sendProfileNamesToServer();

break;

case "get_profile_details": sendProfileDetailsToServer(message);

break;

case "save_action_details": saveActionDetails(message);

break;

case "delete_action": deleteAction(message);

break;

case "get_themes": sendThemesToServer();

break;

case "save_client_details": saveClientDetails(message);

break;

case "save_client_profile": saveProfileDetails(message);

break;

case "delete_profile": deleteProfile(message);

break;

case "action_failed": actionFailed(message);

break;

case "set_toggle_status": onSetToggleStatus(message);

break;

default: logger.warning("Command '"+header+"' does not match records. Make sure client and server versions are equal.");

}

catch (IOException | ClassNotFoundException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

clientListener.onDisconnect();

if(!stop.get())

{

//isDisconnect.set(true); //Prevent running disconnect

throw new MinorException("Accidentally disconnected from Server! (Failed at readUTF)");

}

exit();

return;

}

catch (SevereException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

catch (MinorException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

private void onSetToggleStatus(Message message)

{

String[] arr = message.getStringArrValue();

String profileID = arr[0];

String actionID = arr[1];

boolean newStatus = arr[2].equals("true");

boolean currentStatus = clientListener.getToggleStatus(profileID,actionID);

if(currentStatus == newStatus)

{

return;

}

ActionBox actionBox = clientListener.getActionBoxByProfileAndID(profileID, actionID);

if(actionBox!=null)

{

actionBox.setCurrentToggleStatus(newStatus);

Platform.runLater(()-> actionBox.toggle(newStatus));

}

private void onActionIconReceived(Message message) throws MinorException

{

String profileID = message.getStringArrValue()[0];

String actionID = message.getStringArrValue()[1];

String state = message.getStringArrValue()[2];

clientListener.getClientProfiles().getProfileFromID(profileID).saveActionIcon(

actionID,

message.getByteArrValue(),

state

);

Action a = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID);

clientListener.renderAction(profileID, a);

}

//commands

public synchronized void sendIcon(String profileID, String actionID, String state, byte[] icon) throws SevereException

{

try

{

Thread.sleep(50);

}

catch (InterruptedException e)

{

e.printStackTrace();

}

Message message = new Message("action_icon");

message.setStringArrValue(profileID, actionID, state);

message.setByteArrValue(icon);

sendMessage(message);

}

public void disconnect() throws SevereException

{

disconnect("");

}

public void disconnect(String message) throws SevereException

{

if(stop.get())

return;

stop.set(true);

logger.info("Sending server disconnect message ...");

Message m = new Message("disconnect");

m.setStringValue(message);

sendMessage(m);

try

{

if(!socket.isClosed())

socket.close();

clientListener.setConnected(false);

clientListener.updateSettingsConnectDisconnectButton();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to close socket");

}

public void onServerReady()

{

if(onConnectAndSetupToBeRun!=null)

{

onConnectAndSetupToBeRun.run();

onConnectAndSetupToBeRun = null;

}

public void sendThemesToServer() throws SevereException

{

Message message = new Message("themes");

String[] arr = new String[clientListener.getThemes().getThemeList().size()*4];

int x = 0;

for(int i = 0;i<clientListener.getThemes().getThemeList().size();i++)

{

Theme theme = clientListener.getThemes().getThemeList().get(i);

arr[x] = theme.getFullName();

arr[x+1] = theme.getShortName();

arr[x+2] = theme.getAuthor();

arr[x+3] = theme.getVersion().getText();

x+=4;

}

message.setStringArrValue(arr);

sendMessage(message);

}

public void sendActionIcon(String clientProfileID, String actionID, String state) throws SevereException

{

sendIcon(clientProfileID,

actionID,

state,

clientListener.getClientProfiles()

.getProfileFromID(clientProfileID)

.getActionFromID(actionID).getIcon(state));

}

public void serverDisconnected(Message message)

{

stop.set(true);

String txt = "Disconnected!";

String m = message.getStringValue();

if(!m.isBlank())

txt = "Message : "+m;

exceptionAndAlertHandler.onAlert("Disconnected from Server", txt, StreamPiAlertType.WARNING);

if(!socket.isClosed()) {

try {

socket.close();

} catch (IOException e) {

e.printStackTrace();

}

clientListener.setConnected(false);

clientListener.onDisconnect();

clientListener.updateSettingsConnectDisconnectButton();

}

public void sendClientScreenDetails() throws SevereException

{

String screenWidth = clientListener.getStageWidth() + "";

String screenHeight = clientListener.getStageHeight() + "";

Message toBeSent = new Message("client_screen_details");

toBeSent.setStringArrValue(

screenWidth,

toBeSent.setDoubleArrValue(

screenHeight

clientListener.getStageWidth(),

clientListener.getStageHeight()

);

sendMessage(toBeSent);

}

public void sendClientDetails() throws SevereException

{

sendClientDetails("register_client_details");

}

public void updateClientDetails() throws SevereException

{

sendClientDetails("update_client_details");

}

public void sendClientDetails(String header) throws SevereException

{

String clientVersion = clientInfo.getVersion().getText();

String releaseStatus = clientInfo.getReleaseStatus().toString();

String clientCommStandard = clientInfo.getCommStandardVersion().getText();

String clientMinThemeStandard = clientInfo.getMinThemeSupportVersion().getText();

String clientNickname = Config.getInstance().getClientNickName();

String screenWidth = clientListener.getStageWidth()+"";

String screenHeight = clientListener.getStageHeight()+"";

String OS = clientInfo.getPlatform()+"";

String defaultProfileID = Config.getInstance().getStartupProfileID();

Message toBeSent = new Message(header);

toBeSent.setStringArrValue(

clientVersion,

releaseStatus,

clientCommStandard,

clientMinThemeStandard,

clientNickname,

screenWidth,

screenHeight,

OS,

defaultProfileID,

clientListener.getDefaultThemeFullName()

);

sendMessage(toBeSent);

}

public void sendProfileNamesToServer() throws SevereException

{

Message message = new Message("profiles");

String[] arr = new String[clientListener.getClientProfiles().getClientProfiles().size()];

int totalActions = 0;

for(int i = 0;i<arr.length;i++)

{

ClientProfile clientProfile = clientListener.getClientProfiles().getClientProfiles().get(i);

totalActions += clientProfile.getActions().size();

arr[i] = clientProfile.getID();

}

message.setStringArrValue(arr);

message.setIntValue(totalActions);

sendMessage(message);

}

public void sendProfileDetailsToServer(Message message) throws SevereException

{

String ID = message.getStringValue();

logger.info("IDDDD : "+ID);

Message tbs1 = new Message("profile_details");

ClientProfile clientProfile = clientListener.getClientProfiles().getProfileFromID(ID);

String[] arr = new String[]{

ID,

clientProfile.getName(),

clientProfile.getRows()+"",

clientProfile.getCols()+"",

clientProfile.getActionSize()+"",

clientProfile.getActionGap()+""

};

tbs1.setStringArrValue(arr);

sendMessage(tbs1);

for(Action action : clientProfile.getActions())

{

sendActionDetails(clientProfile.getID(), action);

}

for(Action action : clientProfile.getActions())

{

if(action.isHasIcon())

{

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

{

sendActionIcon(clientProfile.getID(), action.getID(), key);

}

public void sendActionDetails(String profileID, Action action) throws SevereException {

if(action == null)

{

logger.info("NO SUCH ACTION");

return;

}

ArrayList<String> a = new ArrayList<>();

a.add(profileID);

a.add(action.getID());

a.add(action.getActionType()+"");

if(action.getActionType() == ActionType.NORMAL ||

action.getActionType() == ActionType.TOGGLE) {

a.add(action.getVersion().getText());

}

else

{

a.add("no");

}

if(action.getActionType() ==ActionType.NORMAL ||

action.getActionType() == ActionType.TOGGLE)

{

a.add(action.getModuleName());

}

else

{

a.add("nut");

}

//display

a.add(action.getBgColourHex());

//icon

StringBuilder allIconStatesNames = new StringBuilder();

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

{

allIconStatesNames.append(eachState).append("::");

}

a.add(allIconStatesNames.toString());

a.add(action.getCurrentIconState()+"");

//text

a.add(action.isShowDisplayText()+"");

a.add(action.getDisplayTextFontColourHex());

a.add(action.getDisplayText());

a.add(action.getDisplayTextAlignment()+"");

//location

if(action.getLocation() == null)

{

a.add("-1");

}

else

{

a.add(action.getLocation().getRow()+"");

a.add(action.getLocation().getCol()+"");

}

a.add(action.getParent());

a.add(action.getDelayBeforeExecuting()+"");

//client properties

ClientProperties clientProperties = action.getClientProperties();

a.add(clientProperties.getSize()+"");

for(Property property : clientProperties.get())

{

a.add(property.getName());

a.add(property.getRawValue());

}

Message message = new Message("action_details");

String[] x = new String[a.size()];

x = a.toArray(x);

message.setStringArrValue(x);

sendMessage(message);

}

public void saveActionDetails(Message message)

{

String[] r = message.getStringArrValue();

String profileID = r[0];

String actionID = r[1];

ActionType actionType = ActionType.valueOf(r[2]);

//3 - Version

//4 - ModuleName

//display

String bgColorHex = r[5];

String[] iconStates = r[6].split("::");

String currentIconState = r[7];

//text

boolean isShowDisplayText = r[8].equals("true");

String displayFontColor = r[9];

String displayText = r[10];

DisplayTextAlignment displayTextAlignment = DisplayTextAlignment.valueOf(r[11]);

//location

String row = r[12];

String col = r[13];

Location location = new Location(Integer.parseInt(row), Integer.parseInt(col));

Action action = new Action(actionID, actionType);

if(actionType == ActionType.NORMAL || actionType == ActionType.TOGGLE)

{

try

{

action.setVersion(new Version(r[3]));

action.setModuleName(r[4]);

}

catch (Exception e)

{

logger.severe(e.getMessage());

e.printStackTrace();

}

action.setBgColourHex(bgColorHex);

action.setShowDisplayText(isShowDisplayText);

action.setDisplayTextFontColourHex(displayFontColor);

action.setDisplayText(displayText);

action.setDisplayTextAlignment(displayTextAlignment);

action.setCurrentIconState(currentIconState);

action.setLocation(location);

String parent = r[14];

action.setParent(parent);

//client properties

action.setDelayBeforeExecuting(Integer.parseInt(r[15]));

int clientPropertiesSize = Integer.parseInt(r[16]);

ClientProperties clientProperties = new ClientProperties();

if(actionType == ActionType.FOLDER)

clientProperties.setDuplicatePropertyAllowed(true);

for(int i = 17;i<((clientPropertiesSize*2) + 17); i+=2)

{

Property property = new Property(r[i], Type.STRING);

property.setRawValue(r[i+1]);

clientProperties.addProperty(property);

}

action.setClientProperties(clientProperties);

for(String state : iconStates)

{

action.addIcon(state, null);

}

try

{

Action old = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(action.getID());

if(old != null)

{

for(String oldState : old.getIcons().keySet())

{

boolean isPresent = false;

for(String state : iconStates)

{

if(state.equals(oldState))

{

isPresent = true;

break;

}

if(!isPresent)

{

// State no longer exists. Delete.

new File(Config.getInstance().getIconsPath()+"/"+actionID+"___"+oldState).delete();

}

clientListener.getClientProfiles().getProfileFromID(profileID).addAction(action);

clientListener.getClientProfiles().getProfileFromID(profileID).saveAction(action);

clientListener.renderAction(profileID, action);

}

catch (Exception e)

{

e.printStackTrace();

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

}

public void deleteAction(Message message)

{

try

{

String[] arr = message.getStringArrValue();

String profileID = arr[0];

String actionID = arr[1];

Action acc = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID);

if(acc == null)

{

exceptionAndAlertHandler.handleMinorException(new MinorException("Unable to delete action "+actionID+" since it does not exist."));

return;

}

if(acc.getActionType() == ActionType.FOLDER)

{

ArrayList<String> idsToBeRemoved = new ArrayList<>();

ArrayList<String> folders = new ArrayList<>();

String folderToBeDeletedID = clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID).getID();

folders.add(folderToBeDeletedID);

boolean startOver = true;

while(startOver)

{

startOver = false;

for(Action action : clientListener.getClientProfiles().getProfileFromID(profileID).getActions())

{

if(folders.contains(action.getParent()))

{

if(!idsToBeRemoved.contains(action.getID()))

{

idsToBeRemoved.add(action.getID());

if(action.getActionType() == ActionType.FOLDER)

{

folders.add(action.getID());

startOver = true;

}

for(String ids : idsToBeRemoved)

{

clientListener.getClientProfiles().getProfileFromID(profileID).removeAction(ids);

}

Platform.runLater(clientListener::renderRootDefaultProfile);

}

else if (acc.getActionType() == ActionType.COMBINE)

{

for(Property property : acc.getClientProperties().get())

{

clientListener.getClientProfiles().getProfileFromID(profileID).removeAction(property.getRawValue());

}

clientListener.getClientProfiles().getProfileFromID(profileID).removeAction(acc.getID());

clientListener.getClientProfiles().getProfileFromID(profileID).saveActions();

if(acc.getLocation().getCol()!=-1)

{

Platform.runLater(()-> {

if (clientListener.getCurrentProfile().getID().equals(profileID)

&& clientListener.getCurrentParent().equals(acc.getParent()))

{

clientListener.clearActionBox(

acc.getLocation().getCol(),

acc.getLocation().getRow()

);

}

});

}

catch (Exception e)

{

e.printStackTrace();

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

}

public void saveClientDetails(Message message)

{

try

{

boolean reInit = false;

String[] sep = message.getStringArrValue();

Config.getInstance().setNickName(sep[0]);

Config.getInstance().setStartupProfileID(sep[1]);

String oldThemeFullName = Config.getInstance().getCurrentThemeFullName();

String newThemeFullName = sep[2];

if(!oldThemeFullName.equals(newThemeFullName))

{

reInit = true;

}

Config.getInstance().setCurrentThemeFullName(sep[2]);

Config.getInstance().save();

if(reInit)

{

Platform.runLater(clientListener::init);

}

else

{

Platform.runLater(clientListener::loadSettings);

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

public void saveProfileDetails(Message message) throws SevereException, MinorException

{

String[] sep = message.getStringArrValue();

ClientProfile clientProfile = clientListener.getClientProfiles().getProfileFromID(sep[0]);

if(clientProfile == null)

{

clientProfile = new ClientProfile(new File(Config.getInstance().getProfilesPath()+"/"+sep[0]+".xml"),

Config.getInstance().getIconsPath());

}

clientProfile.setName(sep[1]);

clientProfile.setRows(Integer.parseInt(sep[2]));

clientProfile.setCols(Integer.parseInt(sep[3]));

clientProfile.setActionSize(Integer.parseInt(sep[4]));

clientProfile.setActionGap(Integer.parseInt(sep[5]));

try

{

clientListener.getClientProfiles().addProfile(clientProfile);

clientProfile.saveProfileDetails();

clientListener.refreshGridIfCurrentProfile(sep[0]);

Platform.runLater(clientListener::loadSettings);

}

catch (Exception e)

{

e.printStackTrace();

throw new SevereException(e.getMessage());

}

public void deleteProfile(Message message)

{

clientListener.getClientProfiles().deleteProfile(clientListener.getClientProfiles().getProfileFromID(

message.getStringValue()

));

if(clientListener.getCurrentProfile().getID().equals(message.getStringValue()))

{

Platform.runLater(clientListener::renderRootDefaultProfile);

}

public void onActionClicked(String profileID, String actionID, boolean toggleState) throws SevereException

{

Message m = new Message("action_clicked");

m.setStringArrValue(profileID, actionID, toggleState+"");

sendMessage(m);

}

public void actionFailed(Message message)

{

String[] r = message.getStringArrValue();

String profileID = r[0];

String actionID = r[1];

clientListener.onActionFailed(profileID, actionID);

}

M src/main/java/com/stream_pi/client/connection/ClientListener.java

+2 −0

package com.stream_pi.client.connection;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.client.profile.ClientProfile;

import com.stream_pi.client.profile.ClientProfiles;

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

import com.stream_pi.client.window.dashboard.actiongridpane.ActionGridPaneListener;

import com.stream_pi.theme_api.Theme;

import com.stream_pi.theme_api.Themes;

import com.stream_pi.util.exception.SevereException;

public interface ClientListener

{

void onActionFailed(String profileID, String actionID);

void onActionClicked(String profileID, String actionID, boolean toggleState);

ClientProfiles getClientProfiles();

Themes getThemes();

String getDefaultThemeFullName();

Client getClient();

void renderRootDefaultProfile();

void setConnected(boolean isConnected);

boolean isConnected();

void renderProfile(ClientProfile clientProfile, boolean freshRender);

void clearActionBox(int col, int row);

void addBlankActionBox(int col, int row);

void renderAction(String currentProfileID, Action action);

void refreshGridIfCurrentProfile(String currentProfileID);

ActionBox getActionBox(int col, int row);

ClientProfile getCurrentProfile();

String getCurrentParent();

Theme getCurrentTheme();

void initLogger() throws SevereException;

void init();

void disconnect(String message) throws SevereException;

void setupClientConnection();

void setupClientConnection(Runnable onConnect);

void updateSettingsConnectDisconnectButton();

void onCloseRequest();

void loadSettings();

double getStageWidth();

double getStageHeight();

void onDisconnect();

boolean getToggleStatus(String profileID, String actionID);

ActionBox getActionBoxByProfileAndID(String profileID, String actionID);

}

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

+10 −3

package com.stream_pi.client.controller;

import com.gluonhq.attach.vibration.VibrationService;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.client.connection.Client;

import com.stream_pi.client.io.Config;

import com.stream_pi.client.info.ClientInfo;

import com.stream_pi.client.profile.ClientProfile;

import com.stream_pi.client.profile.ClientProfiles;

import com.stream_pi.client.window.Base;

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

import com.stream_pi.client.window.dashboard.actiongridpane.ActionGridPaneListener;

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.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.gluonhq.attach.lifecycle.LifecycleService;

import com.gluonhq.attach.util.Services;

import com.stream_pi.util.platform.PlatformType;

import com.stream_pi.util.startatboot.StartAtBoot;

import javafx.animation.Interpolator;

import javafx.animation.KeyFrame;

import javafx.animation.KeyValue;

import javafx.animation.Timeline;

import javafx.application.Platform;

import javafx.beans.value.ChangeListener;

import javafx.scene.Node;

import javafx.scene.input.KeyCombination;

import javafx.util.Duration;

import java.io.*;

import java.util.logging.Level;

public class Controller extends Base

{

private Client client;

public Controller()

{

client = null;

}

private boolean firstRun = true;

@Override

public void init()

{

try

{

if(firstRun)

initBase();

if(getClientInfo().getPlatform() != com.stream_pi.util.platform.Platform.ANDROID)

{

if(getConfig().isStartOnBoot())

{

if(getClientInfo().isXMode() != getConfig().isStartupXMode())

{

StartAtBoot startAtBoot = new StartAtBoot(PlatformType.CLIENT, ClientInfo.getInstance().getPlatform());

boolean result = startAtBoot.delete();

if(!result)

new StreamPiAlert("Uh Oh!", "Unable to delete the previous starter file.\n" +

"This was probably because you ran Stream-Pi as root before. Restart stream pi as root, " +

"delete the old starter file, then exit and restart Stream-Pi as normal user.", StreamPiAlertType.ERROR).show();

else

{

startAtBoot.create(new File(ClientInfo.getInstance().getRunnerFileName()),

ClientInfo.getInstance().isXMode());

getConfig().setStartupIsXMode(ClientInfo.getInstance().isXMode());

}

setupFlags();

if(!getConfig().getIsFullScreenMode())

{

getStage().setWidth(getConfig().getStartupWindowWidth());

getStage().setHeight(getConfig().getStartupWindowHeight());

getStage().centerOnScreen();

}

applyDefaultTheme();

setupDashWindow();

getStage().show();

requestFocus();

if(Config.getInstance().isFirstTimeUse())

return;

setupSettingsWindowsAnimations();

getDashboardPane().getSettingsButton().setOnAction(event -> {

openSettingsTimeLine.play();

});

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

closeSettingsTimeLine.play();

});

setClientProfiles(new ClientProfiles(new File(getConfig().getProfilesPath()), getConfig().getStartupProfileID()));

if(getClientProfiles().getLoadingErrors().size() > 0)

{

StringBuilder errors = new StringBuilder("Please rectify the following errors and try again");

for(MinorException exception : getClientProfiles().getLoadingErrors())

{

errors.append("\n * ")

.append(exception.getMessage());

}

throw new MinorException("Profiles", errors.toString());

}

renderRootDefaultProfile();

loadSettings();

if(firstRun)

{

if(getConfig().isConnectOnStartup())

{

setupClientConnection();

}

firstRun = false;

}

ChangeListener<Number> windowResizeListener = (observableValue, number, t1) -> {

if(isConnected())

{

try {

client.sendClientScreenDetails();

} catch (SevereException e) {

e.printStackTrace();

}

};

getStage().widthProperty().addListener(windowResizeListener);

getStage().heightProperty().addListener(windowResizeListener);

}

catch (SevereException e)

{

handleSevereException(e);

}

catch (MinorException e)

{

handleMinorException(e);

}

@Override

public void setupClientConnection()

{

setupClientConnection(null);

}

@Override

public void setupClientConnection(Runnable onConnect)

{

if(getSettingsPane().getConnectDisconnectButton().isDisabled()) //probably already connecting

return;

Platform.runLater(()->getSettingsPane().setDisableStatus(true));

client = new Client(getConfig().getSavedServerHostNameOrIP(), getConfig().getSavedServerPort(), this, this);

client = new Client(getConfig().getSavedServerHostNameOrIP(), getConfig().getSavedServerPort(), this, this, onConnect);

}

@Override

public void updateSettingsConnectDisconnectButton() {

getSettingsPane().setConnectDisconnectButtonStatus();

}

@Override

public void disconnect(String message) throws SevereException {

client.disconnect(message);

}

public void setupDashWindow()

{

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

getStage().setOnCloseRequest(e->onCloseRequest());

}

@Override

public void onCloseRequest()

{

try

{

if(isConnected())

client.exit();

getConfig().setStartupWindowSize(getStageWidth(), getStageHeight());

getConfig().save();

}

catch (SevereException e)

{

handleSevereException(e);

}

finally

{

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

closeLogger();

if (ClientInfo.getInstance().getPlatform() == com.stream_pi.util.platform.Platform.ANDROID)

Services.get(LifecycleService.class).ifPresent(LifecycleService::shutdown);

}

@Override

public void loadSettings() {

try {

getSettingsPane().loadData();

} catch (SevereException e) {

e.printStackTrace();

handleSevereException(e);

}

@Override

public Client getClient() {

return client;

}

@Override

public void onDisconnect() {

Platform.runLater(()->getDashboardPane().getActionGridPane().toggleOffAllToggleActions());

}

@Override

public boolean getToggleStatus(String profileID, String actionID)

{

return getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID).getCurrentToggleStatus();

}

private Timeline openSettingsTimeLine;

private Timeline closeSettingsTimeLine;

private void setupSettingsWindowsAnimations()

{

Node settingsNode = getSettingsPane();

Node dashboardNode = getDashboardPane();

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 KeyFrame(Duration.millis(90.0D),

new KeyValue(settingsNode.opacityProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(0.0D),

new KeyValue(dashboardNode.opacityProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(dashboardNode.opacityProperty(),

0.0D, Interpolator.LINEAR))

);

openSettingsTimeLine.setOnFinished(event1 -> settingsNode.toFront());

closeSettingsTimeLine = new Timeline();

closeSettingsTimeLine.setCycleCount(1);

closeSettingsTimeLine.getKeyFrames().addAll(

new KeyFrame(Duration.millis(0.0D),

new KeyValue(settingsNode.opacityProperty(),

1.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(settingsNode.opacityProperty(),

0.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(0.0D),

new KeyValue(dashboardNode.opacityProperty(),

0.0D, Interpolator.LINEAR)),

new KeyFrame(Duration.millis(90.0D),

new KeyValue(dashboardNode.opacityProperty(),

1.0D, Interpolator.LINEAR))

);

closeSettingsTimeLine.setOnFinished(event1 -> {

dashboardNode.toFront();

Platform.runLater(()-> {

try {

getSettingsPane().loadData();

} catch (SevereException e) {

e.printStackTrace();

handleSevereException(e);

}

});

}

@Override

public void handleMinorException(MinorException e)

{

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

e.printStackTrace();

Platform.runLater(()-> genNewAlert(e.getTitle(), e.getShortMessage(), StreamPiAlertType.WARNING).show());

}

@Override

public void handleSevereException(SevereException e)

{

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

e.printStackTrace();

Platform.runLater(()->

{

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

alert.setOnClicked(new StreamPiAlertListener()

{

@Override

public void onClick(String txt)

{

onCloseRequest();

Platform.exit();

}

});

alert.show();

});

}

@Override

public void onAlert(String title, String body, StreamPiAlertType alertType) {

Platform.runLater(()-> genNewAlert(title, body, alertType).show());

}

public StreamPiAlert genNewAlert(String title, String message, StreamPiAlertType alertType)

{

StreamPiAlert alert = new StreamPiAlert(title, message, alertType);

return alert;

}

private boolean isConnected = false;

@Override

public void onActionFailed(String profileID, String actionID) {

Platform.runLater(()-> getDashboardPane().getActionGridPane().actionFailed(profileID, actionID));

}

@Override

public void onActionClicked(String profileID, String actionID, boolean toggleState)

{

try {

vibratePhone();

client.onActionClicked(profileID, actionID, toggleState);

} catch (SevereException e) {

e.printStackTrace();

handleSevereException(e);

}

public void vibratePhone()

{

if(getConfig().isVibrateOnActionClicked())

{

VibrationService.create().ifPresent(VibrationService::vibrate);

}

@Override

public void setConnected(boolean isConnected) {

this.isConnected = isConnected;

}

@Override

public ActionBox getActionBox(int col, int row)

{

return getDashboardPane().getActionGridPane().getActionBox(col, row);

}

@Override

public boolean isConnected()

{

return isConnected;

}

@Override

public void renderProfile(ClientProfile clientProfile, boolean freshRender)

{

getDashboardPane().renderProfile(clientProfile, freshRender);

}

@Override

public void clearActionBox(int col, int row)

{

Platform.runLater(()->getDashboardPane().getActionGridPane().clearActionBox(col, row));

}

@Override

public void addBlankActionBox(int col, int row)

{

Platform.runLater(()->getDashboardPane().getActionGridPane().addBlankActionBox(col, row));

}

@Override

public void renderAction(String currentProfileID, Action action)

{

Platform.runLater(()->{

try {

if(getDashboardPane().getActionGridPane().getCurrentParent().equals(action.getParent()) &&

getCurrentProfile().getID().equals(currentProfileID))

{

getDashboardPane().getActionGridPane().renderAction(action);

}

catch (Exception e)

{

e.printStackTrace();

}

});

}

@Override

public void refreshGridIfCurrentProfile(String profileID) {

if(getCurrentProfile().getID().equals(profileID))

{

Platform.runLater(()-> getDashboardPane().renderProfile(getClientProfiles().getProfileFromID(profileID), true));

}

@Override

public ClientProfile getCurrentProfile() {

return getDashboardPane().getActionGridPane().getClientProfile();

}

@Override

public String getCurrentParent()

{

return getDashboardPane().getActionGridPane().getCurrentParent();

}

@Override

public ActionBox getActionBoxByProfileAndID(String profileID, String actionID)

{

Action action = getClientProfiles().getProfileFromID(profileID).getActionFromID(actionID);

if(!getCurrentProfile().getID().equals(profileID) && !getCurrentParent().equals(action.getParent()))

return null;

return getDashboardPane().getActionGridPane().getActionBoxByLocation(action.getLocation());

}

M src/main/java/com/stream_pi/client/window/dashboard/actiongridpane/ActionBox.java

+26 −5

package com.stream_pi.client.window.dashboard.actiongridpane;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.DisplayTextAlignment;

import com.stream_pi.client.connection.ClientListener;

import com.stream_pi.client.io.Config;

import com.stream_pi.client.window.ExceptionAndAlertHandler;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.exception.SevereException;

import javafx.animation.Interpolator;

import javafx.animation.KeyFrame;

import javafx.animation.KeyValue;

import javafx.animation.Timeline;

import javafx.geometry.Pos;

import javafx.scene.CacheHint;

import javafx.scene.control.Label;

import javafx.scene.image.Image;

import javafx.scene.layout.Background;

import javafx.scene.layout.BackgroundImage;

import javafx.scene.layout.BackgroundPosition;

import javafx.scene.layout.BackgroundRepeat;

import javafx.scene.layout.BackgroundSize;

import javafx.scene.layout.StackPane;

import javafx.scene.text.TextAlignment;

import javafx.util.Duration;

import org.kordamp.ikonli.javafx.FontIcon;

import java.io.ByteArrayInputStream;

import java.io.ObjectInputStream;

import java.nio.ByteBuffer;

public class ActionBox extends StackPane

{

private Label displayTextLabel;

private int row;

private int col;

public int getRow() {

return row;

}

public int getCol() {

return col;

}

public void clear()

{

setStyle(null);

setAction(null);

setCurrentToggleStatus(false);

getStyleClass().clear();

setBackground(Background.EMPTY);

removeFontIcon();

getChildren().clear();

baseInit();

}

private FontIcon statusIcon;

public void baseInit()

{

displayTextLabel = new Label();

displayTextLabel.setWrapText(true);

displayTextLabel.setTextAlignment(TextAlignment.CENTER);

displayTextLabel.getStyleClass().add("action_box_display_text_label");

displayTextLabel.prefHeightProperty().bind(heightProperty());

displayTextLabel.prefWidthProperty().bind(widthProperty());

statusIcon = new FontIcon("fas-exclamation-triangle");

statusIcon.getStyleClass().add("action_box_error_icon");

statusIcon.setOpacity(0);

statusIcon.setCache(true);

statusIcon.setCacheHint(CacheHint.SPEED);

statusIcon.setIconSize(size - 30);

getChildren().addAll(statusIcon, displayTextLabel);

setMinSize(size, size);

setMaxSize(size, size);

getStyleClass().clear();

getStyleClass().add("action_box");

getStyleClass().add("action_box_"+row+"_"+col);

setIcon(null);

setOnMouseClicked(touchEvent -> actionClicked());

setOnMousePressed(TouchEvent -> {

if(action != null)

{

getStyleClass().add("action_box_onclick");

}

});

setOnMouseReleased(TouchEvent ->{

if(action != null)

{

getStyleClass().remove("action_box_onclick");

}

});

statusIconAnimation = new Timeline(

new KeyFrame(

Duration.millis(0.0D),

new KeyValue(statusIcon.opacityProperty(), 0.0D, Interpolator.EASE_IN)),

new KeyFrame(

Duration.millis(100.0D),

new KeyValue(statusIcon.opacityProperty(), 1.0D, Interpolator.EASE_IN)),

new KeyFrame(

Duration.millis(600.0D),

new KeyValue(statusIcon.opacityProperty(), 1.0D, Interpolator.EASE_OUT)),

new KeyFrame(

Duration.millis(700.0D),

new KeyValue(statusIcon.opacityProperty(), 0.0D, Interpolator.EASE_OUT))

);

statusIconAnimation.setOnFinished(event -> {

statusIcon.toBack();

});

setCache(true);

setCacheHint(CacheHint.QUALITY);

}

public void actionClicked()

{

if(action!=null)

{

if(!getActionGridPaneListener().isConnected())

{

exceptionAndAlertHandler.onAlert("Not Connected", "Not Connected to any Server", StreamPiAlertType.ERROR);

try

return;

{

if(Config.getInstance().isTryConnectingWhenActionClicked())

{

clientListener.setupClientConnection(this::actionClicked);

}

else

{

exceptionAndAlertHandler.onAlert("Not Connected", "Not Connected to any Server", StreamPiAlertType.ERROR);

}

return;

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

if(action.getActionType() == ActionType.FOLDER)

{

getActionGridPaneListener().renderFolder(action.getID());

}

else

{

if(action.getActionType() == ActionType.COMBINE)

{

getActionGridPaneListener().combineActionClicked(action.getID());

}

else if(action.getActionType() == ActionType.NORMAL)

{

getActionGridPaneListener().normalActionClicked(action.getID());

}

else if(action.getActionType() == ActionType.TOGGLE)

{

toggle();

getActionGridPaneListener().toggleActionClicked(action.getID(), getCurrentToggleStatus());

}

private Timeline statusIconAnimation;

public Timeline getStatusIconAnimation() {

return statusIconAnimation;

}

public ActionGridPaneListener getActionGridPaneListener() {

return actionGridPaneListener;

}

private int size;

private ActionGridPaneListener actionGridPaneListener;

private ClientListener clientListener;

public ActionBox(int size, ExceptionAndAlertHandler exceptionAndAlertHandler, ActionGridPaneListener actionGridPaneListener, int row, int col)

public ActionBox(int size, ExceptionAndAlertHandler exceptionAndAlertHandler,

ClientListener clientListener, ActionGridPaneListener actionGridPaneListener, int row, int col)

{

this.actionGridPaneListener = actionGridPaneListener;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.size = size;

this.row = row;

this.col = col;

this.clientListener = clientListener;

baseInit();

}

public static Action deserialize(ByteBuffer buffer) {

try {

ByteArrayInputStream is = new ByteArrayInputStream(buffer.array());

ObjectInputStream ois = new ObjectInputStream(is);

return (Action) ois.readObject();

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

public void setIcon(byte[] iconByteArray)

{

removeFontIcon();

if(iconByteArray == null)

{

getStyleClass().remove("action_box_icon_present");

getStyleClass().add("action_box_icon_not_present");

setBackground(null);

}

else

{

getStyleClass().add("action_box_icon_present");

getStyleClass().remove("action_box_icon_not_present");

setBackground(

new Background(

new BackgroundImage(new Image(

new ByteArrayInputStream(iconByteArray), size, size, false, true

), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT, BackgroundPosition.CENTER,

new BackgroundSize(100, 100, true, true, true, false))

)

);

}

private Action action = null;

public Action getAction() {

return action;

}

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private String parent;

public String getStreamPiParent() {

return parent;

}

public void setStreamPiParent(String parent) {

this.parent = parent;

}

public ActionBox(int size, Action action, ExceptionAndAlertHandler exceptionAndAlertHandler,

ActionGridPaneListener actionGridPaneListener, int row, int col)

ClientListener clientListener, ActionGridPaneListener actionGridPaneListener, int row, int col)

{

this.actionGridPaneListener = actionGridPaneListener;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.action = action;

this.size = size;

this.row = row;

this.col = col;

baseInit();

init();

}

}*/

public void setAction(Action action)

{

this.action = action;

}

public void init()

{

setDisplayTextFontColour(action.getDisplayTextFontColourHex());

if(action.isShowDisplayText())

setDisplayTextLabel(action.getDisplayText());

else

setDisplayTextLabel("");

setDisplayTextAlignment(action.getDisplayTextAlignment());

setBackgroundColour(action.getBgColourHex());

try

{

if(action.getActionType() == ActionType.TOGGLE)

{

toggle(getCurrentToggleStatus());

}

else

{

if(action.isHasIcon())

{

if(!action.getCurrentIconState().isBlank())

{

setIcon(action.getCurrentIcon());

}

else

{

setIcon(null);

}

catch (Exception e)

{

e.printStackTrace();

}

public void setCurrentToggleStatus(boolean currentToggleStatus)

{

if(getAction() != null)

getAction().setCurrentToggleStatus(currentToggleStatus);

}

public boolean getCurrentToggleStatus()

{

if(getAction() == null)

return false;

return getAction().getCurrentToggleStatus();

}

public void toggle()

{

setCurrentToggleStatus(!getCurrentToggleStatus());

toggle(getCurrentToggleStatus());

}

public void toggle(boolean isON)

{

String[] toggleStatesHiddenStatus = action.getCurrentIconState().split("__");

boolean isToggleOffHidden = toggleStatesHiddenStatus[0].equals("true");

boolean isToggleOnHidden = toggleStatesHiddenStatus[1].equals("true");

if(isON) // ON

{

if(action.isHasIcon())

{

boolean isToggleOnPresent = action.getIcons().containsKey("toggle_on");

if(isToggleOnPresent)

{

if(isToggleOnHidden)

{

setDefaultToggleIcon(true);

}

else

{

setIcon(action.getIcons().get("toggle_on"));

}

else

{

setDefaultToggleIcon(true);

}

else

{

setDefaultToggleIcon(true);

}

else // OFF

{

if(action.isHasIcon())

{

boolean isToggleOffPresent = action.getIcons().containsKey("toggle_off");

if(isToggleOffPresent)

{

if(isToggleOffHidden)

{

setDefaultToggleIcon(false);

}

else

{

setIcon(action.getIcons().get("toggle_off"));

}

else

{

setDefaultToggleIcon(false);

}

else

{

setDefaultToggleIcon(false);

}

public void setDefaultToggleIcon(boolean isToggleOn)

{

String styleClass;

if(isToggleOn)

{

styleClass = "action_box_toggle_on";

}

else

{

styleClass = "action_box_toggle_off";

}

setBackground(null);

removeFontIcon();

fontIcon = new FontIcon();

fontIcon.getStyleClass().add(styleClass);

fontIcon.setIconSize((int) (size * 0.8));

getChildren().add(fontIcon);

fontIcon.toBack();

}

public void removeFontIcon()

{

if(fontIcon!=null)

{

getChildren().remove(fontIcon);

fontIcon = null;

}

FontIcon fontIcon = null;

public void animateStatus()

{

statusIcon.toFront();

statusIconAnimation.play();

}

public void setDisplayTextLabel(String text)

{

displayTextLabel.setText(text);

}

public void setDisplayTextAlignment(DisplayTextAlignment displayTextAlignment)

{

if(displayTextAlignment == DisplayTextAlignment.CENTER)

displayTextLabel.setAlignment(Pos.CENTER);

else if (displayTextAlignment == DisplayTextAlignment.BOTTOM)

displayTextLabel.setAlignment(Pos.BOTTOM_CENTER);

else if (displayTextAlignment == DisplayTextAlignment.TOP)

displayTextLabel.setAlignment(Pos.TOP_CENTER);

}

public void setDisplayTextFontColour(String colour)

{

System.out.println("'"+colour+"'COLOR");

if(!colour.isEmpty())

{

System.out.println(

"putting ..." + Thread.currentThread().getName()

);

displayTextLabel.setStyle("-fx-text-fill : "+colour+";");

}

public void setBackgroundColour(String colour)

{

System.out.println("COLOr : "+colour);

if(!colour.isEmpty())

setStyle("-fx-background-color : "+colour);

}

M src/main/java/com/stream_pi/client/window/dashboard/actiongridpane/ActionGridPane.java

+1 −1

package com.stream_pi.client.window.dashboard.actiongridpane;

import java.util.logging.Logger;

import com.stream_pi.action_api.action.Action;

import com.stream_pi.action_api.action.ActionType;

import com.stream_pi.action_api.action.Location;

import com.stream_pi.client.connection.ClientListener;

import com.stream_pi.client.profile.ClientProfile;

import com.stream_pi.client.profile.ClientProfiles;

import com.stream_pi.client.window.ExceptionAndAlertHandler;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import javafx.concurrent.Task;

import javafx.geometry.Insets;

import javafx.geometry.Pos;

import javafx.scene.CacheHint;

import javafx.scene.Node;

import javafx.scene.layout.GridPane;

import javafx.scene.layout.Priority;

import javafx.scene.layout.StackPane;

import javafx.scene.layout.VBox;

import javafx.scene.paint.Color;

import org.kordamp.ikonli.javafx.FontIcon;

public class ActionGridPane extends GridPane implements ActionGridPaneListener

{

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private ClientListener clientListener;

private ActionBox[][] actionBoxes;

public ActionGridPane(ExceptionAndAlertHandler exceptionAndAlertHandler, ClientListener clientListener)

{

this.clientListener = clientListener;

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

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

getStyleClass().add("action_grid_pane");

setPadding(new Insets(5.0));

setPrefSize(USE_COMPUTED_SIZE, USE_COMPUTED_SIZE);

setAlignment(Pos.CENTER);

VBox.setVgrow(this, Priority.ALWAYS);

setCache(true);

setCacheHint(CacheHint.SPEED);

}

private String currentParent;

public void setCurrentParent(String currentParent) {

this.currentParent = currentParent;

}

public ClientProfile getClientProfile() {

return clientProfile;

}

private int rows, cols;

private ClientProfile clientProfile;

public void setClientProfile(ClientProfile clientProfile)

{

this.clientProfile = clientProfile;

setCurrentParent("root");

setRows(clientProfile.getRows());

setCols(clientProfile.getCols());

}

public void actionFailed(String profileID, String actionID)

{

if(getClientProfile().getID().equals(profileID))

{

Action action = getClientProfile().getActionFromID(actionID);

if(action != null)

{

if(currentParent.equals(action.getParent()))

{

failShow(action);

}

else

{

if(action.getLocation().getCol() == -1)

{

failShow(getClientProfile().getActionFromID(action.getParent()));

}

public void failShow(Action action)

{

/*for(Node node : getChildren())

{

if(GridPane.getColumnIndex(node) == action.getLocation().getRow() &&

GridPane.getRowIndex(node) == action.getLocation().getCol())

{

ActionBox actionBox = (ActionBox) node;

actionBox.animateStatus();

break;

}

}*/

actionBoxes[action.getLocation().getCol()][action.getLocation().getRow()].animateStatus();

}

public String getCurrentParent() {

return currentParent;

}

public StackPane getFolderBackButton()

{

StackPane stackPane = new StackPane();

stackPane.getStyleClass().add("action_box");

stackPane.getStyleClass().add("action_box_valid");

stackPane.setPrefSize(

getClientProfile().getActionSize(),

getClientProfile().getActionSize()

);

FontIcon fontIcon = new FontIcon("fas-chevron-left");

fontIcon.getStyleClass().add("folder_action_back_button_icon");

fontIcon.setIconSize(getClientProfile().getActionSize() - 30);

stackPane.setAlignment(Pos.CENTER);

stackPane.getChildren().add(fontIcon);

stackPane.setOnMouseClicked(e->returnToPreviousParent());

return stackPane;

}

private boolean isFreshRender = true;

private Node folderBackButton = null;

public void renderGrid()

{

setHgap(getClientProfile().getActionGap());

setVgap(getClientProfile().getActionGap());

if(isFreshRender)

{

clear();

actionBoxes = new ActionBox[cols][rows];

}

boolean isFolder = false;

if(getCurrentParent().equals("root"))

{

if(folderBackButton != null)

{

getChildren().remove(folderBackButton);

folderBackButton = null;

actionBoxes[0][0] = addBlankActionBox(0,0);

}

else

{

isFolder = true;

if(folderBackButton != null)

{

getChildren().remove(folderBackButton);

folderBackButton = null;

}

else

{

getChildren().remove(actionBoxes[0][0]);

}

folderBackButton = getFolderBackButton();

add(folderBackButton, 0,0);

}

for(int row = 0; row<rows; row++)

{

for(int col = 0; col<cols; col++)

{

if(row == 0 && col == 0 && isFolder)

continue;

if(isFreshRender)

{

actionBoxes[col][row] = addBlankActionBox(col, row);

}

else

{

if(actionBoxes[col][row].getAction() != null)

{

actionBoxes[col][row].clear();

}

isFreshRender = false;

}

public void setFreshRender(boolean isFreshRender) {

this.isFreshRender = isFreshRender;

}

public void renderActions()

{

StringBuilder errors = new StringBuilder();

for(Action eachAction : getClientProfile().getActions())

{

logger.info("Action ID : "+eachAction.getID()+"\nInvalid : "+eachAction.isInvalid());

try {

renderAction(eachAction);

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

catch (MinorException e)

{

errors.append("*").append(e.getShortMessage()).append("\n");

}

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

{

exceptionAndAlertHandler.handleMinorException(new MinorException("Error while rendering following actions", errors.toString()));

}

public void clear()

{

getChildren().clear();

}

private Logger logger;

public void clearActionBox(int col, int row)

{

actionBoxes[col][row].clear();

}

public ActionBox getActionBox(int col, int row)

{

return actionBoxes[col][row];

}

public ActionBox addBlankActionBox(int col, int row)

{

ActionBox actionBox = new ActionBox(getClientProfile().getActionSize(), exceptionAndAlertHandler, this, row, col);

ActionBox actionBox = new ActionBox(getClientProfile().getActionSize(), exceptionAndAlertHandler, clientListener, this, row, col);

actionBox.setStreamPiParent(currentParent);

add(actionBox, col, row);

return actionBox;

}

public void toggleOffAllToggleActions()

{

for(Node each : getChildren())

{

if(each instanceof ActionBox)

{

ActionBox eachActionBox = (ActionBox) each;

if(eachActionBox.getAction() != null)

{

if(eachActionBox.getAction().getActionType() == ActionType.TOGGLE)

{

if(eachActionBox.getCurrentToggleStatus()) // ON

{

eachActionBox.toggle();

}

public void renderAction(Action action) throws SevereException, MinorException

{

if(!action.getParent().equals(currentParent))

{

logger.info("Skipping action "+action.getID()+", not current parent!");

return;

}

if(action.getLocation().getRow()==-1)

{

logger.info("Action has -1 rowIndex. Probably Combine Action. Skipping ...");

return;

}

if(action.getLocation().getRow() > rows || action.getLocation().getCol() > cols)

{

throw new MinorException("Action "+action.getDisplayText()+" ("+action.getID()+") falls outside bounds.\n" +

" Consider increasing rows/cols from client settings and relocating/deleting it.");

}

Location location = action.getLocation();

ActionBox actionBox = actionBoxes[location.getCol()][location.getRow()];

actionBox.clear();

boolean oldToggleStatus = actionBox.getCurrentToggleStatus();

actionBox.setAction(action);

actionBox.setCurrentToggleStatus(oldToggleStatus);

actionBox.setStreamPiParent(currentParent);

actionBox.init();

/*ActionBox actionBox = new ActionBox(getClientProfile().getActionSize(), action, exceptionAndAlertHandler, this, location.getRow(), location.getCol());

actionBox.setStreamPiParent(currentParent);

clearActionBox(location.getCol(), location.getRow());

System.out.println(location.getCol()+","+location.getRow());

add(actionBox, location.getRow(), location.getCol());

actionBoxes[location.getCol()][location.getRow()] = actionBox;*/

}

public void setRows(int rows)

{

this.rows = rows;

}

public void setCols(int cols)

{

this.cols = cols;

}

public int getRows()

{

return rows;

}

public int getCols()

{

return cols;

}

private String previousParent;

public void setPreviousParent(String previousParent) {

this.previousParent = previousParent;

}

public String getPreviousParent() {

return previousParent;

}

@Override

public void renderFolder(String actionID) {

setCurrentParent(clientProfile.getActionFromID(actionID).getID());

setPreviousParent(clientProfile.getActionFromID(actionID).getParent());

renderGrid();

renderActions();

}

@Override

public void normalActionClicked(String ID)

{

clientListener.onActionClicked(getClientProfile().getID(), ID, false);

}

@Override

public void toggleActionClicked(String ID, boolean toggleState)

{

clientListener.onActionClicked(getClientProfile().getID(), ID, toggleState);

}

@Override

public ActionBox getActionBoxByLocation(Location location)

{

return getActionBox(location.getCol(), location.getRow());

}

@Override

public boolean isConnected()

{

return clientListener.isConnected();

}

@Override

public void combineActionClicked(String ID) {

if(clientListener.isConnected())

{

new Thread(new Task<Void>() {

@Override

protected Void call()

{

Action action = getClientProfile().getActionFromID(ID);

for(int i = 0;i<action.getClientProperties().get().size();i++)

{

try {

logger.info("Clicking "+i+", '"+action.getClientProperties().getSingleProperty(i+"").getRawValue()+"'");

normalActionClicked(action.getClientProperties().getSingleProperty(i+"").getRawValue());

} catch (MinorException e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

return null;

}

}).start();

}

public void returnToPreviousParent()

{

setCurrentParent(getPreviousParent());

if(!getPreviousParent().equals("root"))

{

System.out.println("parent : "+getPreviousParent());

setPreviousParent(getClientProfile().getActionFromID(

getPreviousParent()

).getParent());

}

renderGrid();

renderActions();

}

M src/main/java/com/stream_pi/client/window/settings/SettingsBase.java

+15 −0

package com.stream_pi.client.window.settings;

import java.io.File;

import java.io.IOException;

import java.net.URISyntaxException;

import java.util.function.Consumer;

import com.gluonhq.attach.browser.BrowserService;

import com.gluonhq.attach.vibration.VibrationService;

import com.stream_pi.client.connection.ClientListener;

import com.stream_pi.client.io.Config;

import com.stream_pi.client.info.ClientInfo;

import com.stream_pi.client.profile.ClientProfile;

import com.stream_pi.client.window.ExceptionAndAlertHandler;

import com.stream_pi.theme_api.Theme;

import com.stream_pi.util.alert.StreamPiAlert;

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.combobox.StreamPiComboBox;

import com.stream_pi.util.combobox.StreamPiComboBoxFactory;

import com.stream_pi.util.combobox.StreamPiComboBoxListener;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.platform.Platform;

import com.stream_pi.util.platform.PlatformType;

import com.stream_pi.util.uihelper.HBoxInputBox;

import com.stream_pi.util.uihelper.SpaceFiller;

import com.stream_pi.util.startatboot.StartAtBoot;

import javafx.application.HostServices;

import javafx.concurrent.Task;

import javafx.event.ActionEvent;

import javafx.geometry.Insets;

import javafx.geometry.Pos;

import javafx.scene.CacheHint;

import javafx.scene.control.*;

import javafx.scene.layout.HBox;

import javafx.scene.layout.Priority;

import javafx.scene.layout.VBox;

public class SettingsBase extends VBox {

private TextField serverPortTextField;

private TextField serverHostNameOrIPTextField;

private StreamPiComboBox<ClientProfile> clientProfileComboBox;

private StreamPiComboBox<Theme> themeComboBox;

private TextField nickNameTextField;

private Button closeButton;

private Button saveButton;

private Button connectDisconnectButton;

private Button shutdownButton;

private ToggleButton startOnBootToggleButton;

private ToggleButton tryConnectingToServerIfActionClickedToggleButton;

private ToggleButton connectOnStartupToggleButton;

private ToggleButton vibrateOnActionPressToggleButton;

private ToggleButton fullScreenModeToggleButton;

private ToggleButton showCursorToggleButton;

private ClientListener clientListener;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

private TextField themesPathTextField;

private TextField iconsPathTextField;

private TextField profilesPathTextField;

private TextField autoReconnectTimeTextField;

private final Button checkForUpdatesButton;

private HostServices hostServices;

public SettingsBase(ExceptionAndAlertHandler exceptionAndAlertHandler,

ClientListener clientListener, HostServices hostServices)

{

getStyleClass().add("settings_base");

this.hostServices = hostServices;

this.clientListener = clientListener;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

serverPortTextField = new TextField();

serverHostNameOrIPTextField = new TextField();

nickNameTextField = new TextField();

clientProfileComboBox = new StreamPiComboBox<>();

clientProfileComboBox.setStreamPiComboBoxFactory(new StreamPiComboBoxFactory<ClientProfile>()

{

@Override

public String getOptionDisplayText(ClientProfile object)

{

return object.getName();

}

});

clientProfileComboBox.setStreamPiComboBoxListener(new StreamPiComboBoxListener<ClientProfile>(){

@Override

public void onNewItemSelected(ClientProfile selectedItem)

{

clientListener.renderProfile(selectedItem, true);

}

});

themeComboBox = new StreamPiComboBox<>();

themeComboBox.setStreamPiComboBoxFactory(new StreamPiComboBoxFactory<Theme>()

{

@Override

public String getOptionDisplayText(Theme object)

{

return object.getShortName();

}

});

themesPathTextField = new TextField();

iconsPathTextField = new TextField();

profilesPathTextField = new TextField();

startOnBootToggleButton = new ToggleButton("Start On Boot");

startOnBootToggleButton.managedProperty().bind(startOnBootToggleButton.visibleProperty());

tryConnectingToServerIfActionClickedToggleButton = new ToggleButton("Try Connecting to Server If not connected on Action click");

tryConnectingToServerIfActionClickedToggleButton.managedProperty().bind(tryConnectingToServerIfActionClickedToggleButton.visibleProperty());

fullScreenModeToggleButton = new ToggleButton("Full Screen");

fullScreenModeToggleButton.managedProperty().bind(fullScreenModeToggleButton.visibleProperty());

vibrateOnActionPressToggleButton = new ToggleButton("Vibrate On Action Press");

vibrateOnActionPressToggleButton.managedProperty().bind(vibrateOnActionPressToggleButton.visibleProperty());

connectOnStartupToggleButton = new ToggleButton("Connect On Startup");

connectOnStartupToggleButton.managedProperty().bind(connectOnStartupToggleButton.visibleProperty());

showCursorToggleButton = new ToggleButton("Show Cursor");

showCursorToggleButton.managedProperty().bind(showCursorToggleButton.visibleProperty());

int prefWidth = 200;

Label licenseLabel = new Label("This software is licensed to GNU GPLv3. Check StreamPi Server > settings > About to see full License Statement.");

licenseLabel.setWrapText(true);

Label versionLabel = new Label(ClientInfo.getInstance().getReleaseStatus().getUIName() +" "+ClientInfo.getInstance().getVersion().getText());

HBoxInputBox themesPathInputBox = new HBoxInputBox("Themes Path", themesPathTextField, prefWidth);

themesPathInputBox.managedProperty().bind(themesPathInputBox.visibleProperty());

HBoxInputBox iconsPathInputBox = new HBoxInputBox("Icons Path", iconsPathTextField, prefWidth);

iconsPathInputBox.managedProperty().bind(iconsPathInputBox.visibleProperty());

HBoxInputBox profilesPathInputBox = new HBoxInputBox("Profiles Path", profilesPathTextField, prefWidth);

profilesPathInputBox.managedProperty().bind(profilesPathInputBox.visibleProperty());

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

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

autoReconnectTimeTextField = new TextField();

VBox vBox = new VBox(

new HBoxInputBox("Device Name", nickNameTextField, prefWidth),

new HBoxInputBox("Host Name/IP", serverHostNameOrIPTextField, prefWidth),

new HBoxInputBox("Port", serverPortTextField, prefWidth),

new HBox(

new Label("Current profile"),

SpaceFiller.horizontal(),

clientProfileComboBox

new HBox(

new Label("Theme"),

SpaceFiller.horizontal(),

themeComboBox

themesPathInputBox,

iconsPathInputBox,

profilesPathInputBox

);

vBox.getStyleClass().add("settings_base_vbox");

vBox.setSpacing(5.0);

vBox.setPadding(new Insets(5));

ScrollPane scrollPane = new ScrollPane();

scrollPane.setHbarPolicy(ScrollPane.ScrollBarPolicy.AS_NEEDED);

VBox.setVgrow(scrollPane, Priority.ALWAYS);

scrollPane.getStyleClass().add("settings_base_scroll_pane");

scrollPane.setContent(vBox);

vBox.setMinWidth(300);

vBox.prefWidthProperty().bind(scrollPane.widthProperty().subtract(25));

Label settingsLabel = new Label("Settings");

settingsLabel.setPadding(new Insets(5,0,0,5));

settingsLabel.getStyleClass().add("settings_heading_label");

saveButton = new Button("Save");

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

closeButton = new Button("Close");

connectDisconnectButton = new Button("Connect");

connectDisconnectButton.setOnAction(event -> onConnectDisconnectButtonClicked());

Button exitButton = new Button("Exit");

exitButton.setOnAction(event -> onExitButtonClicked());

HBox buttonBar = new HBox(connectDisconnectButton, saveButton);

shutdownButton = new Button("Shutdown");

shutdownButton.managedProperty().bind(shutdownButton.visibleProperty());

shutdownButton.setOnAction(event -> onShutdownButtonClicked());

vBox.getChildren().addAll(

shutdownButton,

tryConnectingToServerIfActionClickedToggleButton,

fullScreenModeToggleButton,

connectOnStartupToggleButton,

vibrateOnActionPressToggleButton,

checkForUpdatesButton,

startOnBootToggleButton,

showCursorToggleButton,

licenseLabel,

versionLabel

);

buttonBar.getChildren().add(closeButton);

buttonBar.getStyleClass().add("settings_button_bar");

buttonBar.setPadding(new Insets(0,5,5,0));

buttonBar.setSpacing(5.0);

buttonBar.setAlignment(Pos.CENTER_RIGHT);

setSpacing(5.0);

getChildren().addAll(

settingsLabel,

scrollPane,

buttonBar

);

setCache(true);

setCacheHint(CacheHint.SPEED);

//Perform platform checks

Platform platform = ClientInfo.getInstance().getPlatform();

if(platform == Platform.ANDROID ||

platform == Platform.IOS)

{

themesPathInputBox.setVisible(false);

iconsPathInputBox.setVisible(false);

profilesPathInputBox.setVisible(false);

startOnBootToggleButton.setVisible(false);

showCursorToggleButton.setVisible(false);

fullScreenModeToggleButton.setVisible(false);

}

else

{

if(!ClientInfo.getInstance().isShowShutDownButton())

{

shutdownButton.setVisible(false);

}

vibrateOnActionPressToggleButton.setVisible(false);

buttonBar.getChildren().add(exitButton);

}

if(!ClientInfo.getInstance().isShowFullScreenToggleButton())

{

fullScreenModeToggleButton.setVisible(false);

}

private void checkForUpdates()

{

new CheckForUpdates(checkForUpdatesButton,

PlatformType.CLIENT, ClientInfo.getInstance().getVersion(), new UpdateHyperlinkOnClick() {

@Override

public void handle(ActionEvent actionEvent) {

Platform platform = ClientInfo.getInstance().getPlatform();

if(platform == Platform.ANDROID || platform == Platform.IOS)

{

BrowserService.create().ifPresentOrElse(s->

{

try

{

s.launchExternalBrowser(getURL());

}

catch (Exception e )

{

exceptionAndAlertHandler.handleMinorException(

new MinorException("Cant start browser!")

);

}

},()-> exceptionAndAlertHandler.handleMinorException(

new MinorException("Sorry!","No browser detected.")

));

}

else

{

hostServices.showDocument(getURL());

}

});

}

public void onExitButtonClicked()

{

clientListener.onCloseRequest();

javafx.application.Platform.exit();

}

public void setDisableStatus(boolean status)

{

saveButton.setDisable(status);

connectDisconnectButton.setDisable(status);

}

public Button getConnectDisconnectButton()

{

return connectDisconnectButton;

}

public void onShutdownButtonClicked()

{

clientListener.onCloseRequest();

try {

Runtime.getRuntime().exec("sudo halt");

}

catch (Exception e)

{

e.printStackTrace();

}

public void onConnectDisconnectButtonClicked()

{

try

{

if(clientListener.isConnected())

clientListener.disconnect("Client disconnected from settings");

else

clientListener.setupClientConnection();

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

public void setConnectDisconnectButtonStatus()

{

javafx.application.Platform.runLater(()->{

setDisableStatus(false);

if(clientListener.isConnected())

connectDisconnectButton.setText("Disconnect");

else

connectDisconnectButton.setText("Connect");

});

}

public Button getCloseButton() {

return closeButton;

}

public void loadData() throws SevereException

{

Config config = Config.getInstance();

nickNameTextField.setText(config.getClientNickName());

serverHostNameOrIPTextField.setText(config.getSavedServerHostNameOrIP());

serverPortTextField.setText(config.getSavedServerPort()+"");

clientProfileComboBox.setOptions(clientListener.getClientProfiles().getClientProfiles());

int ind = 0;

for(int i = 0;i<clientProfileComboBox.getOptions().size();i++)

{

if(clientProfileComboBox.getOptions().get(i).getID().equals(clientListener.getCurrentProfile().getID()))

{

ind = i;

break;

}

clientProfileComboBox.setCurrentSelectedItemIndex(ind);

themeComboBox.setOptions(clientListener.getThemes().getThemeList());

int ind2 = 0;

for(int i = 0;i<themeComboBox.getOptions().size();i++)

{

if(themeComboBox.getOptions().get(i).getFullName().equals(clientListener.getCurrentTheme().getFullName()))

{

ind2 = i;

break;

}

themeComboBox.setCurrentSelectedItemIndex(ind2);

themesPathTextField.setText(config.getThemesPath());

iconsPathTextField.setText(config.getIconsPath());

profilesPathTextField.setText(config.getProfilesPath());

startOnBootToggleButton.setSelected(config.isStartOnBoot());

fullScreenModeToggleButton.setSelected(config.getIsFullScreenMode());

showCursorToggleButton.setSelected(config.isShowCursor());

connectOnStartupToggleButton.setSelected(config.isConnectOnStartup());

vibrateOnActionPressToggleButton.setSelected(config.isVibrateOnActionClicked());

tryConnectingToServerIfActionClickedToggleButton.setSelected(config.isTryConnectingWhenActionClicked());

}

public void onSaveButtonClicked()

{

StringBuilder errors = new StringBuilder();

int port = -1;

try

{

port = Integer.parseInt(serverPortTextField.getText());

if(port < 1024)

errors.append("* Server IP should be above 1024.\n");

else if(port > 65535)

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

}

catch (NumberFormatException exception)

{

errors.append("* Server IP should be a number.\n");

}

if(serverHostNameOrIPTextField.getText().isBlank())

{

errors.append("* Server IP cannot be empty.\n");

}

if(nickNameTextField.getText().isBlank())

{

errors.append("* Nick name cannot be blank.\n");

}

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

{

exceptionAndAlertHandler.handleMinorException(new MinorException(

"You made mistakes",

"Please fix the errors and try again :\n"+errors.toString()

));

return;

}

try {

boolean toBeReloaded = false;

boolean syncWithServer = false;

Config config = Config.getInstance();

if(!config.getCurrentThemeFullName().equals(themeComboBox.getCurrentSelectedItem().getFullName()))

{

syncWithServer = true;

toBeReloaded = true;

}

config.setCurrentThemeFullName(themeComboBox.getCurrentSelectedItem().getFullName());

if(!config.getClientNickName().equals(nickNameTextField.getText()))

{

syncWithServer = true;

}

config.setNickName(nickNameTextField.getText());

if(port != config.getSavedServerPort() || !serverHostNameOrIPTextField.getText().equals(config.getSavedServerHostNameOrIP()))

{

syncWithServer = true;

}

config.setServerPort(port);

config.setServerHostNameOrIP(serverHostNameOrIPTextField.getText());

boolean isFullScreen = fullScreenModeToggleButton.isSelected();

if(config.getIsFullScreenMode() != isFullScreen)

{

toBeReloaded = true;

}

config.setIsFullScreenMode(isFullScreen);

config.setTryConnectingWhenActionClicked(tryConnectingToServerIfActionClickedToggleButton.isSelected());

boolean startOnBoot = startOnBootToggleButton.isSelected();

if(config.isStartOnBoot() != startOnBoot)

{

if(ClientInfo.getInstance().getRunnerFileName() == null)

{

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

startOnBoot = false;

}

else

{

StartAtBoot startAtBoot = new StartAtBoot(PlatformType.CLIENT, ClientInfo.getInstance().getPlatform());

if(startOnBoot)

{

startAtBoot.create(new File(ClientInfo.getInstance().getRunnerFileName()),

ClientInfo.getInstance().isXMode());

config.setStartupIsXMode(ClientInfo.getInstance().isXMode());

}

else

{

boolean result = startAtBoot.delete();

if(!result)

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

}

config.setStartOnBoot(startOnBoot);

config.setShowCursor(showCursorToggleButton.isSelected());

if(!config.getThemesPath().equals(themesPathTextField.getText()))

toBeReloaded = true;

config.setThemesPath(themesPathTextField.getText());

if(!config.getIconsPath().equals(iconsPathTextField.getText()))

toBeReloaded = true;

config.setIconsPath(iconsPathTextField.getText());

if(!config.getProfilesPath().equals(profilesPathTextField.getText()))

toBeReloaded = true;

config.setProfilesPath(profilesPathTextField.getText());

config.setConnectOnStartup(connectOnStartupToggleButton.isSelected());

boolean isVibrateOnActionClicked = vibrateOnActionPressToggleButton.isSelected();

if(config.isVibrateOnActionClicked() != isVibrateOnActionClicked && isVibrateOnActionClicked)

{

if(VibrationService.create().isEmpty())

{

isVibrateOnActionClicked = false;

new StreamPiAlert("Uh Oh!", "Vibration not supported", StreamPiAlertType.ERROR).show();

}

config.setVibrateOnActionClicked(isVibrateOnActionClicked);

config.save();

loadData();

if(syncWithServer)

{

if(clientListener.isConnected())

{

clientListener.getClient().updateClientDetails();

}

if(toBeReloaded)

{

clientListener.init();

clientListener.renderRootDefaultProfile();

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

catch (MinorException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(e);

}

M src/main/resources/META-INF/native-image/serialization-config.json

+6 −1

[

{"name":"com.stream_pi.util.comms.Message"},

{"name": "java.lang.String"},

{"name": "java.lang.String[]"},

{"name": "byte[]"}

{"name": "byte"},

{"name": "byte[]"},

{"name": "int"},

{"name": "int[]"},

{"name": "double"},

{"name": "double[]"}

]

Public

client

Clone or download

Auto reconnect, Refactored some messages, Added ready method

Modified Files