client

Added delay before running for actions

Download Browse

+15 −8

Author

Debayan Sutradhar (rnayabed) 2021-03-09 19:53

Committer

Debayan Sutradhar (rnayabed) 2021-03-09 19:53

Hash 7aa017c4fa445cf66cd74d9afa458e99d84028ee

Parent 55e6c808f00e5cd940ac9a96f7a015e313975735

Reference git #client/7aa017c4fa445cf66cd74d9afa458e99d84028ee

Modified Files

List

Side by side diff

Inline diff

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

+6 −2

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.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 final ClientListener clientListener;

private final ExceptionAndAlertHandler exceptionAndAlertHandler;

private final ClientInfo clientInfo;

private final String serverIP;

private final int serverPort;

private final Logger logger;

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

{

this.serverIP = serverIP;

this.serverPort = serverPort;

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

this.clientInfo = ClientInfo.getInstance();

this.clientListener = clientListener;

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 "action_icon" : onActionIconReceived(message);

break;

case "disconnect" : serverDisconnected(message);

break;

case "get_client_details" : sendClientDetails();

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;

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();

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 onActionIconReceived(Message message)

{

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

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

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

actionID,

message.getByteArrValue()

);

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

clientListener.renderAction(profileID, a);

}

//commands

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

{

try

{

Thread.sleep(50);

}

catch (InterruptedException e)

{

e.printStackTrace();

}

Message message = new Message("action_icon");

message.setStringArrValue(profileID, actionID);

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 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) throws SevereException

{

System.out.println("sending action icon "+clientProfileID+", "+actionID);

sendIcon(clientProfileID, actionID, clientListener.getClientProfiles().getProfileFromID(clientProfileID).getActionFromID(actionID).getIconAsByteArray());

}

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.updateSettingsConnectDisconnectButton();

}

public void sendClientDetails() 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("client_details");

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()];

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

{

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

arr[i] = clientProfile.getID();

}

message.setStringArrValue(arr);

sendMessage(message);

}

public void sendProfileDetailsToServer(Message message) throws SevereException

{

String ID = message.getStringValue();

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())

{

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

}

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) {

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

}

else

{

a.add("no");

}

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

{

a.add(action.getModuleName());

}

else

{

a.add("nut");

}

//display

a.add(action.getBgColourHex());

//icon

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

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

//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];

//icon

boolean isHasIcon = r[6].equals("true");

boolean isShowIcon = r[7].equals("true");

//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)

{

try

{

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

action.setModuleName(r[4]);

}

catch (Exception e)

{

logger.severe(e.getMessage());

e.printStackTrace();

}

action.setBgColourHex(bgColorHex);

action.setShowIcon(isShowIcon);

action.setHasIcon(isHasIcon);

System.out.println("IS HAS ICON : "+isHasIcon+", IS SHOW ICON :"+isShowIcon);

action.setShowDisplayText(isShowDisplayText);

action.setDisplayTextFontColourHex(displayFontColor);

action.setDisplayText(displayText);

action.setDisplayTextAlignment(displayTextAlignment);

action.setLocation(location);

String parent = r[14];

action.setParent(parent);

//client properties

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

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 = 16;i<((clientPropertiesSize*2) + 16); i+=2)

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);

try

{

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

if(old != null)

{

if(isHasIcon)

action.setIcon(clientListener.getClientProfiles().getProfileFromID(profileID).getActionFromID(action.getID()).getIconAsByteArray());

else

{

if(old.isHasIcon())

{

new File(Config.getInstance().getIconsPath()+"/"+actionID).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.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);

}

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

{

String[] sep = message.getStringArrValue();

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

String oldWidth = Config.getInstance().getStartupWindowWidth()+"";

String oldHeight = Config.getInstance().getStartupWindowHeight()+"";

Config.getInstance().setStartupWindowSize(

Double.parseDouble(sep[1]),

Double.parseDouble(sep[2])

);

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

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

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

if(!oldHeight.equals(sep[2]) || !oldWidth.equals(sep[1]) || !oldThemeFullName.equals(sep[4]))

Platform.runLater(clientListener::init);

Config.getInstance().save();

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) throws SevereException

{

Message m = new Message("action_clicked");

m.setStringArrValue(profileID, actionID);

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/info/ClientInfo.java

+1 −1

ServerInfo.java

Stores basic information about the server - name, platform type

Contributors: Debayan Sutradhar (@dubbadhar)

package com.stream_pi.client.info;

import com.gluonhq.attach.storage.StorageService;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.platform.Platform;

import com.stream_pi.util.platform.ReleaseStatus;

import com.stream_pi.util.version.Version;

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Optional;

import java.util.function.Function;

public class ClientInfo {

private Version version;

private final ReleaseStatus releaseStatus;

private Platform platform;

private String prePath;

private Version minThemeSupportVersion;

private Version minPluginSupportVersion;

private Version commStandardVersion;

private String runnerFileName;

private static ClientInfo instance = null;

private ClientInfo()

{

version = new Version(0,0,0);

version = new Version(1,0,0);

minThemeSupportVersion = new Version(1,0,0);

minPluginSupportVersion = new Version(1,0,0);

commStandardVersion = new Version(1,0,0);

releaseStatus = ReleaseStatus.EA;

String osName = System.getProperty("os.name").toLowerCase();

prePath = System.getProperty("user.home")+"/Stream-Pi/Client/";

if(osName.contains("windows"))

{

platform = Platform.WINDOWS;

}

else if (osName.contains("linux"))

{

platform = Platform.LINUX;

}

else if(osName.contains("android")) // SPECIFY -Dsvm.targetName=android WHILE BUILDING ANDROID NATIVE IMAGE

{

StorageService.create().ifPresent(s->{

s.getPublicStorage("Documents").ifPresentOrElse(sp->{

prePath = sp.getAbsolutePath()+"/Stream-Pi/Client/";

}, ()->

{

prePath = null;

});

platform = Platform.ANDROID;

}

else if(osName.contains("ios")) // SPECIFY -Dsvm.targetName=ios WHILE BUILDING ANDROID NATIVE IMAGE

{

StorageService.create().ifPresent(s->{

s.getPrivateStorage().ifPresentOrElse(sp->{

prePath = sp.getAbsolutePath()+"/Stream-Pi/Client/";

}, ()->

{

prePath = null;

});

platform = Platform.IOS;

}

else if (osName.contains("mac"))

{

platform = Platform.MAC;

}

else

{

platform = Platform.UNKNOWN;

}

public void setRunnerFileName(String runnerFileName)

{

this.runnerFileName = runnerFileName;

}

public String getRunnerFileName()

{

return runnerFileName;

}

public static synchronized ClientInfo getInstance(){

if(instance == null)

{

instance = new ClientInfo();

}

return instance;

}

private boolean isShowShutDownButton = false;

public void setShowShutDownButton(boolean showShutDownButton) {

isShowShutDownButton = showShutDownButton;

}

private boolean isXMode = false;

public void setXMode(boolean isXMode)

{

this.isXMode = isXMode;

}

public boolean isXMode() {

return isXMode;

}

public boolean isShowShutDownButton() {

return isShowShutDownButton;

}

public String getPrePath()

{

return prePath;

}

public Platform getPlatform()

{

return platform;

}

public Version getVersion() {

return version;

}

public ReleaseStatus getReleaseStatus()

{

return releaseStatus;

}

public Version getMinThemeSupportVersion()

{

return minThemeSupportVersion;

}

public Version getMinPluginSupportVersion()

{

return minPluginSupportVersion;

}

public Version getCommStandardVersion()

{

return commStandardVersion;

}

M src/main/java/com/stream_pi/client/profile/ClientProfile.java

+8 −0

package com.stream_pi.client.profile;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

import java.nio.file.Files;

import java.nio.file.NoSuchFileException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.logging.Logger;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.Result;

import javax.xml.transform.Source;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

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.info.ClientInfo;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import com.stream_pi.util.xmlconfighelper.XMLConfigHelper;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

public class ClientProfile implements Cloneable{

private String name, ID;

private int rows, cols, actionSize, actionGap;

private HashMap<String, Action> actions;

private String iconsPath;

private File file;

private Logger logger;

private Document document;

public ClientProfile(File file, String iconsPath) throws MinorException

{

this.file = file;

this.iconsPath = iconsPath;

actions = new HashMap<>();

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

if(!file.exists() && !file.isFile())

createConfigFile(file);

try

{

DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();

DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

document = docBuilder.parse(file);

}

catch (Exception e)

{

e.printStackTrace();

throw new MinorException("profile", "Unable to read profile config file.");

}

setID(file.getName().replace(".xml", ""));

load();

}

private Element getProfileElement()

{

return (Element) document.getElementsByTagName("profile").item(0);

}

private Element getActionsElement()

{

return (Element) document.getElementsByTagName("actions").item(0);

}

public void load() throws MinorException

{

try

{

actions.clear();

logger.info("Loading profile "+getID()+" ...");

String name = XMLConfigHelper.getStringProperty(getProfileElement(), "name");

int rows = XMLConfigHelper.getIntProperty(getProfileElement(), "rows");

int cols = XMLConfigHelper.getIntProperty(getProfileElement(), "cols");

int actionSize = XMLConfigHelper.getIntProperty(getProfileElement(), "action-size");

int actionGap = XMLConfigHelper.getIntProperty(getProfileElement(), "action-gap");

setName(name);

setRows(rows);

setCols(cols);

setActionSize(actionSize);

setActionGap(actionGap);

//Load Actions

NodeList actionsNodesList = getActionsElement().getChildNodes();

int actionsSize = actionsNodesList.getLength();

logger.info("Actions Size : "+actionsSize);

for(int item = 0; item<actionsSize; item++)

{

Node eachActionNode = actionsNodesList.item(item);

if(eachActionNode.getNodeType() != Node.ELEMENT_NODE)

continue;

Element eachActionElement = (Element) eachActionNode;

if(!eachActionElement.getNodeName().equals("action"))

continue;

String id = XMLConfigHelper.getStringProperty(eachActionElement, "id");

String parent = XMLConfigHelper.getStringProperty(eachActionElement, "parent");

logger.info("Loading action "+id+" ...");

ActionType actionType = ActionType.valueOf(XMLConfigHelper.getStringProperty(eachActionElement, "action-type"));

Action action = new Action(id, actionType);

action.setParent(parent);

ClientProperties properties = new ClientProperties();

if(actionType == ActionType.FOLDER)

properties.setDuplicatePropertyAllowed(true);

if(actionType == ActionType.NORMAL)

{

action.setVersion(new Version(XMLConfigHelper.getStringProperty(eachActionElement, "version")));

action.setModuleName(XMLConfigHelper.getStringProperty(eachActionElement, "module-name"));

action.setDelayBeforeExecuting(Integer.parseInt(

XMLConfigHelper.getStringProperty(eachActionElement, "delay-before-running")

));

}

Node propertiesNode = eachActionElement.getElementsByTagName("properties").item(0);

NodeList propertiesNodesList = propertiesNode.getChildNodes();

int propertiesSize = propertiesNodesList.getLength();

for(int propItem = 0; propItem < propertiesSize; propItem++)

{

Node eachPropertyNode = propertiesNodesList.item(propItem);

if(eachPropertyNode.getNodeType() != Node.ELEMENT_NODE)

continue;

Element eachPropertyElement = (Element) eachPropertyNode;

if(eachPropertyElement.getNodeName() != "property")

continue;

String propertyName = XMLConfigHelper.getStringProperty(eachPropertyElement, "name");

String propertyValue = XMLConfigHelper.getStringProperty(eachPropertyElement, "value");

logger.info("Property Name : "+propertyName);

logger.info("Property Value : "+propertyValue);

Property p = new Property(propertyName, Type.STRING);

p.setRawValue(propertyValue);

properties.addProperty(p);

}

action.setClientProperties(properties);

Element displayElement = (Element) eachActionElement.getElementsByTagName("display").item(0);

//display

//location

try

{

Element locationElement = (Element) displayElement.getElementsByTagName("location").item(0);

int row = XMLConfigHelper.getIntProperty(locationElement, "row");

int col = XMLConfigHelper.getIntProperty(locationElement, "col");

action.setLocation(new Location(row, col));

}

catch (Exception e)

{

logger.info("Action has no location, most probably a combine action child");

}

//background

Element backgroundElement = (Element) displayElement.getElementsByTagName("background").item(0);

action.setBgColourHex(XMLConfigHelper.getStringProperty(backgroundElement, "colour-hex"));

Element iconElement = (Element) backgroundElement.getElementsByTagName("icon").item(0);

boolean showIcon = XMLConfigHelper.getBooleanProperty(iconElement, "show");

boolean hasIcon = XMLConfigHelper.getBooleanProperty(iconElement, "has");

Element textElement = (Element) displayElement.getElementsByTagName("text").item(0);

boolean showText = XMLConfigHelper.getBooleanProperty(textElement, "show");

String displayTextFontColour = XMLConfigHelper.getStringProperty(textElement, "colour-hex");

DisplayTextAlignment displayTextAlignment = DisplayTextAlignment.valueOf(XMLConfigHelper.getStringProperty(textElement, "alignment"));

action.setDisplayTextAlignment(displayTextAlignment);

action.setShowIcon(showIcon);

action.setHasIcon(hasIcon);

action.setShowDisplayText(showText);

action.setDisplayTextFontColourHex(displayTextFontColour);

String displayText = XMLConfigHelper.getStringProperty(textElement, "display-text");

action.setDisplayText(displayText);

if(hasIcon)

{

File f = new File(iconsPath+"/"+id);

try

{

byte[] iconFileByteArray = Files.readAllBytes(f.toPath());

action.setIcon(iconFileByteArray);

}

catch(NoSuchFileException e)

{

action.setIcon(null);

action.setHasIcon(false);

action.setShowIcon(false);

saveAction(action);

}

addAction(action);

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

}

logger.info("Loaded profile "+getID()+" ("+getName()+") !");

}

catch (Exception e)

{

e.printStackTrace();

throw new MinorException("profile", "profile is corrupt.");

}

public void addAction(Action action) throws CloneNotSupportedException {

actions.put(action.getID(), (Action) action.clone());

}

private void createConfigFile(File file) throws MinorException

{

try

{

file.createNewFile();

DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();

Document newDocument = dBuilder.newDocument();

Element rootElement = newDocument.createElement("config");

newDocument.appendChild(rootElement);

Element profileElement = newDocument.createElement("profile");

rootElement.appendChild(profileElement);

Element actionsElement = newDocument.createElement("actions");

rootElement.appendChild(actionsElement);

Element nameElement = newDocument.createElement("name");

nameElement.setTextContent("Untitled profile");

profileElement.appendChild(nameElement);

Element rowsElement = newDocument.createElement("rows");

rowsElement.setTextContent("3");

profileElement.appendChild(rowsElement);

Element colsElement = newDocument.createElement("cols");

colsElement.setTextContent("3");

profileElement.appendChild(colsElement);

Element actionSizeElement = newDocument.createElement("action-size");

actionSizeElement.setTextContent("100");

profileElement.appendChild(actionSizeElement);

Element actionGapElement = newDocument.createElement("action-gap");

actionGapElement.setTextContent("5");

profileElement.appendChild(actionGapElement);

TransformerFactory transformerFactory = TransformerFactory.newInstance();

Transformer transformer = transformerFactory.newTransformer();

DOMSource source = new DOMSource(newDocument);

StreamResult result = new StreamResult(file);

transformer.transform(source, result);

}

catch (Exception e)

{

e.printStackTrace();

throw new MinorException(e.getMessage());

}

public void deleteProfile()

{

file.delete();

}

public void saveAction(Action action) throws Exception {

Element newActionElement = document.createElement("action");

getActionsElement().appendChild(newActionElement);

Element idElement = document.createElement("id");

idElement.setTextContent(action.getID());

newActionElement.appendChild(idElement);

Element parentElement = document.createElement("parent");

parentElement.setTextContent(action.getParent());

newActionElement.appendChild(parentElement);

Element actionTypeElement = document.createElement("action-type");

actionTypeElement.setTextContent(action.getActionType()+"");

newActionElement.appendChild(actionTypeElement);

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

{

Element versionElement = document.createElement("version");

versionElement.setTextContent(action.getVersion().getText());

newActionElement.appendChild(versionElement);

System.out.println(action.getModuleName());

Element moduleNameElement = document.createElement("module-name");

moduleNameElement.setTextContent(action.getModuleName());

newActionElement.appendChild(moduleNameElement);

Element delayBeforeRunningElement = document.createElement("delay-before-running");

delayBeforeRunningElement.setTextContent(action.getDelayBeforeExecuting()+"");

newActionElement.appendChild(delayBeforeRunningElement);

}

Element displayElement = document.createElement("display");

newActionElement.appendChild(displayElement);

Element backgroundElement = document.createElement("background");

displayElement.appendChild(backgroundElement);

Element colourHexElement = document.createElement("colour-hex");

colourHexElement.setTextContent(action.getBgColourHex());

backgroundElement.appendChild(colourHexElement);

Element iconElement = document.createElement("icon");

Element iconShowElement = document.createElement("show");

iconShowElement.setTextContent(action.isShowIcon()+"");

iconElement.appendChild(iconShowElement);

Element iconHasElement = document.createElement("has");

iconHasElement.setTextContent(action.isHasIcon()+"");

iconElement.appendChild(iconHasElement);

backgroundElement.appendChild(iconElement);

Element textElement = document.createElement("text");

displayElement.appendChild(textElement);

Element textTolourHexElement = document.createElement("colour-hex");

textTolourHexElement.setTextContent(action.getDisplayTextFontColourHex());

textElement.appendChild(textTolourHexElement);

Element textShowElement = document.createElement("show");

textShowElement.setTextContent(action.isShowDisplayText()+"");

textElement.appendChild(textShowElement);

Element textDisplayTextElement = document.createElement("display-text");

textDisplayTextElement.setTextContent(action.getDisplayText());

textElement.appendChild(textDisplayTextElement);

Element textAlignmentElement = document.createElement("alignment");

textAlignmentElement.setTextContent(action.getDisplayTextAlignment()+"");

textElement.appendChild(textAlignmentElement);

Element locationElement = document.createElement("location");

displayElement.appendChild(locationElement);

Element colElement = document.createElement("col");

colElement.setTextContent(action.getLocation().getCol()+"");

locationElement.appendChild(colElement);

Element rowElement = document.createElement("row");

rowElement.setTextContent(action.getLocation().getRow()+"");

locationElement.appendChild(rowElement);

Element propertiesElement = document.createElement("properties");

newActionElement.appendChild(propertiesElement);

for(String key : action.getClientProperties().getNames())

{

for(Property eachProperty : action.getClientProperties().getMultipleProperties(key))

{

Element propertyElement = document.createElement("property");

propertiesElement.appendChild(propertyElement);

Element nameElement = document.createElement("name");

nameElement.setTextContent(eachProperty.getName());

propertyElement.appendChild(nameElement);

Element valueElement = document.createElement("value");

valueElement.setTextContent(eachProperty.getRawValue());

propertyElement.appendChild(valueElement);

}

save();

}

private int getActionIndexInConfig(String actionID)

{

NodeList actionsList = getActionsElement().getChildNodes();

int actionsSize = actionsList.getLength();

int index = 0;

for(int i = 0;i<actionsSize;i++)

{

Node eachActionNode = actionsList.item(index);

if(eachActionNode.getNodeType() != Node.ELEMENT_NODE)

continue;

if(!eachActionNode.getNodeName().equals("action"))

continue;

Element eachActionElement = (Element) eachActionNode;

Element idElement = (Element) eachActionElement.getElementsByTagName("id").item(0);

if(idElement.getTextContent().equals(actionID))

return index;

index++;

}

return -1;

}

public void saveActionIcon(String actionID, byte[] array){

int index = getActionIndexInConfig(actionID);

getActionFromID(actionID).setIcon(array);

File iconFile = new File(iconsPath+"/"+actionID);

if(iconFile.exists())

{

boolean result = iconFile.delete();

System.out.println("result : "+result);

}

try

{

OutputStream outputStream = new FileOutputStream(iconFile);

outputStream.write(array);

outputStream.flush();

outputStream.close();

Element actionElement = (Element) getActionsElement().getElementsByTagName("action").item(index);

Element displayElement = (Element) actionElement.getElementsByTagName("display").item(0);

Element backgroundElement = (Element) displayElement.getElementsByTagName("background").item(0);

Element iconElement = (Element) backgroundElement.getElementsByTagName("icon").item(0);

Element hasElement = (Element) iconElement.getElementsByTagName("has").item(0);

hasElement.setTextContent("true");

save();

}

catch (Exception e)

{

e.printStackTrace();

}

private void save() throws Exception

{

Transformer transformer = TransformerFactory.newInstance().newTransformer();

Result output = new StreamResult(file);

Source input = new DOMSource(document);

transformer.transform(input, output);

}

public void saveProfileDetails() throws Exception {

XMLConfigHelper.removeChilds(getProfileElement());

Element nameElement = document.createElement("name");

nameElement.setTextContent(getName());

getProfileElement().appendChild(nameElement);

Element rowsElement = document.createElement("rows");

rowsElement.setTextContent(getRows()+"");

getProfileElement().appendChild(rowsElement);

Element colsElement = document.createElement("cols");

colsElement.setTextContent(getCols()+"");

getProfileElement().appendChild(colsElement);

Element actionSizeElement = document.createElement("action-size");

actionSizeElement.setTextContent(getActionSize()+"");

getProfileElement().appendChild(actionSizeElement);

Element actionGapElement = document.createElement("action-gap");

actionGapElement.setTextContent(getActionGap()+"");

getProfileElement().appendChild(actionGapElement);

save();

}

public void saveActions() throws Exception

{

XMLConfigHelper.removeChilds(getActionsElement());

save();

for(Action action : getActions())

{

logger.info("ACTION ID :"+action.getID());

logger.info("Action ICON : "+action.isHasIcon());

saveAction(action);

}

public void removeAction(String ID) throws Exception {

int index = getActionIndexInConfig(ID);

if(index>-1)

{

Element actionElement = (Element) getActionsElement().getElementsByTagName("action").item(index);

Element displayElement = (Element) actionElement.getElementsByTagName("display").item(0);

Element backgroundElement = (Element) displayElement.getElementsByTagName("background").item(0);

Element iconElement = (Element) backgroundElement.getElementsByTagName("icon").item(0);

if(XMLConfigHelper.getBooleanProperty(iconElement, "has"))

{

new File(iconsPath+"/"+ID).delete();

}

actions.remove(ID);

}

public ArrayList<Action> getActions()

{

ArrayList<Action> p = new ArrayList<>();

for(String profile : actions.keySet())

p.add(actions.get(profile));

return p;

}

public String getID()

{

return ID;

}

public String getName()

{

return name;

}

public int getRows()

{

return rows;

}

public int getCols()

{

return cols;

}

public int getActionSize()

{

return actionSize;

}

public Action getActionFromID(String ID)

{

return actions.getOrDefault(ID, null);

}

public int getActionGap()

{

return actionGap;

}

public void setRows(int rows)

{

this.rows = rows;

}

public void setCols(int cols)

{

this.cols = cols;

}

public void setID(String ID)

{

this.ID = ID;

}

public void setActionSize(int actionSize)

{

this.actionSize = actionSize;

}

public void setActionGap(int actionGap)

{

this.actionGap = actionGap;

}

public void setName(String name)

{

this.name = name;

}

public Object clone() throws CloneNotSupportedException

{

return super.clone();

}

M src/main/java/com/stream_pi/client/window/Base.java

+0 −5

package com.stream_pi.client.window;

import com.stream_pi.client.connection.ClientListener;

import com.stream_pi.client.io.Config;

import com.stream_pi.client.info.ClientInfo;

import java.io.File;

import java.util.logging.Logger;

import com.stream_pi.client.Main;

import com.stream_pi.client.profile.ClientProfiles;

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

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

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

import com.stream_pi.theme_api.Theme;

import com.stream_pi.theme_api.Themes;

import com.stream_pi.util.alert.StreamPiAlert;

import com.stream_pi.util.combobox.StreamPiComboBox;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.SevereException;

import com.stream_pi.util.iohelper.IOHelper;

import com.stream_pi.util.loggerhelper.StreamPiLogFallbackHandler;

import com.stream_pi.util.loggerhelper.StreamPiLogFileHandler;

import com.stream_pi.util.platform.Platform;

import javafx.application.HostServices;

import javafx.geometry.Insets;

import javafx.scene.CacheHint;

import javafx.scene.Cursor;

import javafx.scene.image.Image;

import javafx.scene.input.KeyCombination;

import javafx.scene.layout.StackPane;

import javafx.scene.text.Font;

import javafx.stage.Screen;

import javafx.stage.Stage;

public abstract class Base extends StackPane implements ExceptionAndAlertHandler, ClientListener {

private Config config;

private ClientProfiles clientProfiles;

private ClientInfo clientInfo;

private Stage stage;

public Stage getStage()

{

return stage;

}

public Logger getLogger()

{

return logger;

}

private DashboardBase dashboardBase;

private SettingsBase settingsBase;

private FirstTimeUse firstTimeUse;

public FirstTimeUse getFirstTimeUse() {

return firstTimeUse;

}

private StackPane alertStackPane;

@Override

public ClientProfiles getClientProfiles() {

return clientProfiles;

}

public void setClientProfiles(ClientProfiles clientProfiles) {

this.clientProfiles = clientProfiles;

}

private Logger logger = null;

private StreamPiLogFileHandler logFileHandler = null;

private StreamPiLogFallbackHandler logFallbackHandler = null;

@Override

public void initLogger()

{

try

{

if(logFileHandler != null)

return;

closeLogger();

logger = Logger.getLogger("");

if(new File(ClientInfo.getInstance().getPrePath()).getAbsoluteFile().getParentFile().canWrite())

{

String path = ClientInfo.getInstance().getPrePath()+"../stream-pi-client.log";

Platform platform = getClientInfo().getPlatform();

if(platform == Platform.ANDROID ||

platform == Platform.IOS)

path = ClientInfo.getInstance().getPrePath()+"stream-pi-client.log";

logFileHandler = new StreamPiLogFileHandler(path);

logger.addHandler(logFileHandler);

}

else

{

logFallbackHandler = new StreamPiLogFallbackHandler();

logger.addHandler(logFallbackHandler);

}

catch(Exception e)

{

e.printStackTrace();

logFallbackHandler = new StreamPiLogFallbackHandler();

logger.addHandler(logFallbackHandler);

}

public void closeLogger()

{

if(logFileHandler != null)

logFileHandler.close();

else if(logFallbackHandler != null)

logFallbackHandler.close();

}

private HostServices hostServices;

public void setHostServices(HostServices hostServices)

{

this.hostServices = hostServices;

}

public HostServices getHostServices()

{

return hostServices;

}

public void initBase() throws SevereException

{

stage = (Stage) getScene().getWindow();

getStage().getIcons().add(new Image(Main.class.getResourceAsStream("app_icon.png")));

clientInfo = ClientInfo.getInstance();

dashboardBase = new DashboardBase(this, this);

dashboardBase.prefWidthProperty().bind(widthProperty());

dashboardBase.prefHeightProperty().bind(heightProperty());

settingsBase = new SettingsBase(this, this, getHostServices());

alertStackPane = new StackPane();

alertStackPane.setPadding(new Insets(10));

alertStackPane.setVisible(false);

StreamPiAlert.setParent(alertStackPane);

StreamPiComboBox.setParent(alertStackPane);

firstTimeUse = new FirstTimeUse(this, this);

getChildren().clear();

getChildren().addAll(alertStackPane);

initLogger();

checkPrePathDirectory();

getChildren().addAll(settingsBase, dashboardBase);

setStyle(null);

config = Config.getInstance();

if(config.isFirstTimeUse())

{

clearStylesheets();

applyDefaultStylesheet();

applyDefaultIconsStylesheet();

getChildren().add(firstTimeUse);

firstTimeUse.toFront();

//resolution check

resizeAccordingToResolution();

}

else

{

dashboardBase.toFront();

}

initThemes();

}

private void resizeAccordingToResolution()

{

if(ClientInfo.getInstance().getPlatform() != Platform.ANDROID)

{

double height = getScreenHeight();

double width = getScreenWidth();

logger.info("HEIGHT: "+height+", WIDTH: "+width);

if(height < 500)

setPrefHeight(320);

if(width < 500)

setPrefWidth(240);

}

@Override

public double getStageWidth()

{

if(ClientInfo.getInstance().getPlatform() == Platform.ANDROID)

{

return getScreenWidth();

}

else

{

return getStage().getWidth();

}

public double getScreenWidth()

{

return Screen.getPrimary().getBounds().getWidth();

}

@Override

public double getStageHeight()

{

if(ClientInfo.getInstance().getPlatform() == Platform.ANDROID)

{

return getScreenHeight();

}

else

{

return getStage().getHeight();

}

public double getScreenHeight()

{

return Screen.getPrimary().getBounds().getHeight();

}

private void checkPrePathDirectory() throws SevereException

{

try

{

String path = getClientInfo().getPrePath();

System.out.println("PAAAAAAAAAAAATH : '"+path+"'");

if(path == null)

{

throwStoragePermErrorAlert("Unable to access file system!");

return;

}

File file = new File(path);

if(!file.canWrite() || !file.canRead())

{

throwStoragePermErrorAlert("No read/write storage permission. Give it!");

return;

}

if(!file.exists())

{

boolean result = file.mkdirs();

if(result)

{

IOHelper.unzip(Main.class.getResourceAsStream("Default.zip"), ClientInfo.getInstance().getPrePath());

Config.getInstance().setThemesPath(ClientInfo.getInstance().getPrePath()+"Themes/");

Config.getInstance().setIconsPath(ClientInfo.getInstance().getPrePath()+"Icons/");

Config.getInstance().setProfilesPath(ClientInfo.getInstance().getPrePath()+"Profiles/");

Config.getInstance().save();

initLogger();

}

else

{

throwStoragePermErrorAlert("No storage permission. Give it!");

}

catch (Exception e)

{

e.printStackTrace();

throw new SevereException(e.getMessage());

}

private void throwStoragePermErrorAlert(String msg) throws SevereException

{

resizeAccordingToResolution();

clearStylesheets();

applyDefaultStylesheet();

applyDefaultIconsStylesheet();

getStage().show();

throw new SevereException(msg);

}

public void setupFlags()

{

//Full Screen

if(getConfig().isFullscreen())

{

getStage().setFullScreenExitKeyCombination(KeyCombination.NO_MATCH);

getStage().setFullScreen(true);

}

else

{

getStage().setFullScreenExitKeyCombination(KeyCombination.keyCombination("Esc"));

getStage().setFullScreen(false);

}

//Cursor

if(getConfig().isShowCursor())

{

setCursor(Cursor.DEFAULT);

}

else

{

setCursor(Cursor.NONE);

}

public SettingsBase getSettingsPane() {

return settingsBase;

}

public DashboardBase getDashboardPane() {

return dashboardBase;

}

public void renderRootDefaultProfile()

{

getDashboardPane().renderProfile(getClientProfiles().getProfileFromID(

getConfig().getStartupProfileID()

), true);

}

public void clearStylesheets()

{

getStylesheets().clear();

}

public void applyDefaultStylesheet()

{

Font.loadFont(Main.class.getResourceAsStream("Roboto.ttf"), 13);

getStylesheets().add(Main.class.getResource("style.css").toExternalForm());

}

public void applyDefaultIconsStylesheet()

{

Font.loadFont(Main.class.getResourceAsStream("Roboto.ttf"), 13);

getStylesheets().add(Main.class.getResource("default_icons.css").toExternalForm());

}

public Config getConfig()

{

return config;

}

public ClientInfo getClientInfo()

{

return clientInfo;

}

private Theme currentTheme;

@Override

public Theme getCurrentTheme()

{

return currentTheme;

}

public void applyTheme(Theme t)

{

logger.info("Applying theme '"+t.getFullName()+"' ...");

if(t.getFonts() != null)

{

for(String fontFile : t.getFonts())

{

Font.loadFont(fontFile.replace("%20",""), 13);

}

currentTheme = t;

clearStylesheets();

applyDefaultStylesheet();

getStylesheets().addAll(t.getStylesheets());

applyDefaultIconsStylesheet();

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

}

Themes themes;

public void initThemes() throws SevereException

{

logger.info("Loading themes ...");

themes = new Themes(getConfig().getThemesPath(), getConfig().getCurrentThemeFullName(), clientInfo.getMinThemeSupportVersion());

if(themes.getErrors().size()>0)

{

StringBuilder themeErrors = new StringBuilder();

for(MinorException eachException : themes.getErrors())

{

themeErrors.append("\n * ").append(eachException.getShortMessage());

}

if(themes.getIsBadThemeTheCurrentOne())

{

themeErrors.append("\n\nReverted to default theme! (").append(getConfig().getDefaultCurrentThemeFullName()).append(")");

getConfig().setCurrentThemeFullName(getConfig().getDefaultCurrentThemeFullName());

getConfig().save();

}

handleMinorException(new MinorException("Theme Loading issues", themeErrors.toString()));

}

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

}

@Override

public Themes getThemes() {

return themes;

}

public void applyDefaultTheme()

{

logger.info("Applying default theme ...");

boolean foundTheme = false;

for(Theme t: themes.getThemeList())

{

if(t.getFullName().equals(config.getCurrentThemeFullName()))

{

foundTheme = true;

applyTheme(t);

break;

}

if(foundTheme)

{

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

}

else

{

logger.info("Theme not found. reverting to light theme ...");

try {

Config.getInstance().setCurrentThemeFullName("com.StreamPi.DefaultLight");

Config.getInstance().save();

applyDefaultTheme();

}

catch (SevereException e)

{

handleSevereException(e);

}

@Override

public String getDefaultThemeFullName()

{

return config.getCurrentThemeFullName();

}

Public

client

Clone or download

Added delay before running for actions

Modified Files