Initial commit.

.gitignore

@@ -0,0 +1,80 @@
+# Created by https://www.toptal.com/developers/gitignore/api/eclipse
+# Edit at https://www.toptal.com/developers/gitignore?templates=eclipse
+
+### Eclipse ###
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# CDT- autotools
+.autotools
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Annotation Processing
+.apt_generated/
+.apt_generated_test/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+
+# Uncomment this line if you wish to ignore the project description file.
+# Typically, this file would be tracked if it contains build/dependency configurations:
+#.project
+
+### Eclipse Patch ###
+# Spring Boot Tooling
+.sts4-cache/
+
+# End of https://www.toptal.com/developers/gitignore/api/eclipse
+
+
+/hc_scripts/
+hc_scripts
+hcsound
+RhasspyIntentLauncher*8883
+RhasspyIntentLauncher*1883
+keystore.jks
+res
+RhasspyIntentLauncher-settings.ini

RhasspyIntentLauncher/.classpath

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="lib/activation-1.1.1.wso2v2.jar"/>
+	<classpathentry kind="lib" path="lib/commons-lang3-3.9.jar"/>
+	<classpathentry kind="lib" path="lib/commons-logging-1.2.jar"/>
+	<classpathentry kind="lib" path="lib/httpclient_4.5.6.jar"/>
+	<classpathentry kind="lib" path="lib/java-json.jar"/>
+	<classpathentry kind="lib" path="lib/jcommon-1.0.23.jar"/>
+	<classpathentry kind="lib" path="lib/org.eclipse.paho.client.mqttv3-1.2.1.jar"/>
+	<classpathentry kind="lib" path="C:/Program Files/Java/jdk1.8.0_191/lib/missioncontrol/plugins/com.jrockit.mc.rjmx_5.5.2.174165/lib/mailapi.jar"/>
+	<classpathentry kind="lib" path="C:/Program Files/Java/jdk1.8.0_191/lib/missioncontrol/plugins/com.jrockit.mc.rjmx_5.5.2.174165/lib/smtp.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

RhasspyIntentLauncher/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>RhasspyIntentLauncher</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

RhasspyIntentLauncher/src/com/jens/rhasspy/intentlauncher/MQTT.java

@@ -0,0 +1,302 @@
+package com.jens.rhasspy.intentlauncher;
+
+import java.util.ArrayList;
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttCallbackExtended;
+import org.eclipse.paho.client.mqttv3.MqttClient;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.eclipse.paho.client.mqttv3.MqttPersistenceException;
+import org.eclipse.paho.client.mqttv3.MqttSecurityException;
+import org.eclipse.paho.client.mqttv3.MqttTopic;
+
+public class MQTT implements MqttCallbackExtended
+{	
+	final static String clientId = Settings.programName;
+	final static int maximumReconnectionAttempts = -1;
+	protected static ArrayList<String> subscribedTopics = new ArrayList<>();
+	protected static boolean forceReconnection = false;	
+	
+	static String getServerUri()
+	{
+		if(Settings.mqttClientUseSsl)
+			return "ssl://" + Settings.mqttClientServerHostname + ":" + String.valueOf(Settings.mqttClientServerPort);
+		else
+			return "tcp://" + Settings.mqttClientServerHostname + ":" + String.valueOf(Settings.mqttClientServerPort);
+	}
+	
+	static MQTT instance = null;
+	static MqttClient client = null;
+	
+	public static MQTT getInstance()
+	{
+		if(instance == null)
+			instance = new MQTT();
+		
+		return instance;
+	}
+	
+	public MqttClient getClient()
+	{	
+		if(client == null)
+		{
+			try
+			{
+				/*
+				 * Documentation of options:
+				 * https://www.ibm.com/support/knowledgecenter/SSFKSJ_7.5.0/com.ibm.mq.javadoc.doc/WMQMQxrClasses/org/eclipse/paho/client/mqttv3/MqttConnectOptions.html#setKeepAliveInterval(int)
+				 */
+				
+				MqttConnectOptions options = new MqttConnectOptions();
+				options.setCleanSession(true);
+				options.setAutomaticReconnect(true);
+				
+				if(Settings.mqttClientUseSsl)
+				{
+//					Properties props = new Properties();
+//					props.put("secureProtocol", "TLSv1_method");
+//					options.setSSLProperties(props);
+//					options.setSSLProperties(props);
+					options.setHttpsHostnameVerificationEnabled(true);
+				}
+				
+				if(Settings.mqttClientUseAuthentication)
+				{
+					options.setUserName(Settings.mqttClientUsername);
+					options.setPassword(Settings.mqttClientPassword.toCharArray());
+				}
+				client = new MqttClient(getServerUri(), clientId);
+				client.setCallback(this);
+			}
+			catch (MqttException e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+		}
+		
+		return client;
+	}
+	
+	public static boolean isTopicSubscribed(String topic)
+	{
+		return subscribedTopics.contains(topic);
+	}
+	
+	public static synchronized void subscribe(String topic, boolean force)
+	{
+//		startUpSensorListener();
+		
+		if(!subscribedTopics.contains(topic))
+		{
+			if(getInstance().subscribeToTopic(topic))
+				subscribedTopics.add(topic);
+		}
+		else if(force)
+		{
+			if(getInstance().subscribeToTopic(topic))
+			{
+				if(!subscribedTopics.contains(topic))
+					subscribedTopics.add(topic);
+			}
+		}
+	}
+	
+	public static synchronized void unSubscribe(String topic)
+	{
+		if(subscribedTopics.contains(topic))
+		{
+			if(subscribedTopics.contains(topic))
+			{
+				if(getInstance().unsubscribeFromTopic(topic))
+					subscribedTopics.remove(topic);
+			}
+		}
+	}
+	
+	protected boolean subscribeToTopic(String topic)
+	{
+		Miscellaneous.logEvent("Subscribing to topic " + topic, 3);
+		
+		try
+		{
+			if(!getClient().isConnected())
+			{
+				Miscellaneous.logEvent("Connecting to MQTT server " + Settings.mqttClientServerHostname + " on port " + String.valueOf(Settings.mqttClientServerPort) + ".", 3);
+//				getClient().setCallback(this);
+				getClient().connect();
+			}
+			
+			getClient().subscribe(topic);
+			return true;
+		}
+		catch (MqttException e)
+		{
+			Miscellaneous.logEvent("Error subscribing to topic " + topic + ": " + Miscellaneous.getStackTraceAsString(e), 1);
+		}
+		
+		return false;
+	}
+	
+	protected boolean unsubscribeFromTopic(String topic)
+	{
+		Miscellaneous.logEvent("Unsubscribing from topic " + topic, 3);
+		
+		try
+		{
+			if(getClient().isConnected())
+			{
+				getClient().unsubscribe(topic);
+			}
+			
+			return true;
+		}
+		catch (MqttException e)
+		{
+			Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+		}
+		
+		return false;
+	}
+	
+	protected void resubscribeToAll()
+	{
+		Miscellaneous.logEvent("Resubscribing to all topics.", 3);
+		
+		unsubscribeFromTopic(Settings.intentMqttPath);
+		subscribeToTopic(Settings.intentMqttPath);
+	}
+
+	@Override
+	public void connectionLost(Throwable arg0)
+	{
+		Miscellaneous.logEvent("Connection to MQTT server lost.", 3);
+		Miscellaneous.logEvent("Reason for loss of MQTT connection: " + Miscellaneous.getStackTraceAsString(arg0), 5);
+		
+		// Currently set to autoreconnect, but that doesn't always seem to work
+		
+//		reconnectManually();
+	}
+	
+	synchronized void reconnectManually()
+	{
+		int reconnectionCounter = 1;
+		
+		while(!getClient().isConnected())
+		{
+			try
+			{
+				Thread.sleep(10000);
+			}
+			catch(Exception e)
+			{}
+			
+			if(!getClient().isConnected())
+			{
+				System.out.println("Trying to reestablish connection to MQTT server. This is attempt number: " + String.valueOf(reconnectionCounter));
+				
+				try
+				{
+					if(reconnectionCounter < 20)
+					{
+	//					getClient().setCallback(this);
+						getClient().reconnect();
+					}
+					else if((reconnectionCounter >= 20 && reconnectionCounter < maximumReconnectionAttempts) | maximumReconnectionAttempts == -1)
+					{
+						Miscellaneous.logEvent("More than 20 reconnection attempts so far (" + String.valueOf(reconnectionCounter) +"). Doing hard reconnect.", 1);
+						
+						forceReconnection = true;
+						
+						getClient().disconnectForcibly();
+						client = getClient();
+						getClient().connect();
+
+						resubscribeToAll();
+					}
+					else
+					{
+						String notificationText = "Maximum amount of reconnection attempts to MQTT server reached (" + String.valueOf(maximumReconnectionAttempts) + ") . Aborting.";
+						Miscellaneous.logEvent(notificationText, 2);
+						Miscellaneous.notifyAdminViaEmail(notificationText, false, 2);
+						return;
+					}
+				}
+				catch (MqttSecurityException e)
+				{
+					Miscellaneous.logEvent("Reconnection to MQTT server failed: " + Miscellaneous.getStackTraceAsString(e), 1);
+				}
+				catch (MqttException e)
+				{
+					Miscellaneous.logEvent("Reconnection to MQTT server failed: " + Miscellaneous.getStackTraceAsString(e), 1);
+				}
+			}
+			
+			reconnectionCounter++;
+		}
+	}
+	
+	@Override
+	public void deliveryComplete(IMqttDeliveryToken arg0)
+	{
+		// TODO Auto-generated method stub
+		
+	}
+	
+	@Override
+	public void messageArrived(String topic, MqttMessage message) throws Exception
+	{
+		Miscellaneous.logEvent("Received MQTT message from topic: " + topic + ", message: " + message, 3);
+		
+		try
+		{
+			Object[] object = new Object[2];
+			object[0] = message;
+			object[1] = topic;
+			
+			RhasspyIntentWorker.getInstance().notifyOfNewValues(object);
+		}
+		catch(Exception e)
+		{
+			Miscellaneous.logEvent("Error after receiving MQTT message: " + Miscellaneous.getStackTraceAsString(e), 1);
+		}
+	}
+	
+	public boolean publish(String topic, String message)
+	{
+		try
+		{
+			getClient().publish(topic, new MqttMessage(message.getBytes()));
+			return true;
+		}
+		catch (MqttPersistenceException e)
+		{
+			Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+		}
+		catch (MqttException e)
+		{
+			Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+		}
+		
+		return false;
+	}
+
+	@Override
+	public void connectComplete(boolean reconnect, String serverURI)
+	{
+		if(reconnect)
+		{
+			Miscellaneous.logEvent("Reconnected to MQTT server " + serverURI, 3);
+			resubscribeToAll();
+		}
+		else
+		{
+			Miscellaneous.logEvent("Connected to MQTT server " + serverURI, 3);
+			if(forceReconnection)
+			{
+				resubscribeToAll();
+				forceReconnection = false;
+			}
+		}
+	}
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/intentlauncher/MyKeyManager.java

@@ -0,0 +1,72 @@
+package com.jens.rhasspy.intentlauncher;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.X509KeyManager;
+
+public class MyKeyManager implements X509KeyManager {
+    private KeyStore keyStore;
+    private String alias;
+    private char[] password;
+
+    MyKeyManager(String keyStoreFile, char[] password, String alias)
+        throws IOException, GeneralSecurityException
+    {
+        this.alias = alias;
+        this.password = password;
+        InputStream stream = new FileInputStream(keyStoreFile);
+        keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+        keyStore.load(stream, password);
+    }
+
+    public PrivateKey getPrivateKey(String alias) {
+        try {
+			return (PrivateKey) keyStore.getKey(alias, password);
+		} catch (Exception e) {
+			return null;
+		}
+    }
+
+    public X509Certificate[] getCertificateChain(String alias) {
+        try {
+            java.security.cert.Certificate[] certs = keyStore.getCertificateChain(alias);
+            if (certs == null || certs.length == 0)
+            	return null;
+            X509Certificate[] x509 = new X509Certificate[certs.length];
+            for (int i = 0; i < certs.length; i++)
+            	x509[i] = (X509Certificate)certs[i];
+			return x509;
+		} catch (Exception e) {
+			return null;
+		}          
+    }
+
+    public String chooseServerAlias(String keyType, Principal[] issuers,
+                                    Socket socket) {
+        return alias;
+    }
+
+    public String[] getClientAliases(String parm1, Principal[] parm2) {
+        throw new UnsupportedOperationException("Method getClientAliases() not yet implemented.");
+    }
+
+    public String chooseClientAlias(String keyTypes[], Principal[] issuers, Socket socket) {
+        throw new UnsupportedOperationException("Method chooseClientAlias() not yet implemented.");
+    }
+
+    public String[] getServerAliases(String parm1, Principal[] parm2) {
+        return new String[] { alias };
+    }
+
+    public String chooseServerAlias(String parm1, Principal[] parm2) {
+        return alias;
+    }
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/intentlauncher/MySSLSocketFactory.java

@@ -0,0 +1,129 @@
+package com.jens.rhasspy.intentlauncher;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.CertificateException;
+
+import javax.net.SocketFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManagerFactory;
+//import org.bouncycastle.jce.provider.BouncyCastleProvider;
+
+public class MySSLSocketFactory extends SSLSocketFactory
+{
+//    private static SSLSocketFactory sf;
+    private static SSLContext context = null;
+
+    public MySSLSocketFactory() throws KeyManagementException, KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException
+    {
+        init();
+        
+    }
+    
+    private static void init() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException, CertificateException, IOException
+    {
+//    	Security.addProvider(new BouncyCastleProvider());
+    	KeyStore keyStore = KeyStore.getInstance("BKS");
+        InputStream is = new FileInputStream(new File("keystore.ks"));
+        char[] keystorePass="insecure".toCharArray(); 
+        keyStore.load(is,keystorePass);
+        TrustManagerFactory tmf = TrustManagerFactory.getInstance("X509");
+        tmf.init(keyStore);
+        SSLContext ctx = SSLContext.getInstance("TLS");
+
+        
+        ctx.init(null, tmf.getTrustManagers(), null);
+//        sf = ctx.getSocketFactory();
+        
+        final SSLContext context = SSLContext.getInstance("SSL");
+        context.init(null, tmf.getTrustManagers(), new SecureRandom());
+    }
+
+	@Override
+	public Socket createSocket(Socket arg0, String arg1, int arg2, boolean arg3) throws IOException
+	{
+		return null;
+	}
+
+	@Override
+	public String[] getDefaultCipherSuites()
+	{
+		return null;
+	}
+
+	@Override
+	public String[] getSupportedCipherSuites()
+	{
+		return null;
+	}
+
+	@Override
+	public Socket createSocket(String arg0, int arg1) throws IOException, UnknownHostException
+	{
+		return null;
+	}
+
+	@Override
+	public Socket createSocket(InetAddress arg0, int arg1) throws IOException
+	{
+		return null;
+	}
+
+	@Override
+	public Socket createSocket(String arg0, int arg1, InetAddress arg2, int arg3) throws IOException, UnknownHostException
+	{
+		return null;
+	}
+
+	@Override
+	public Socket createSocket(InetAddress arg0, int arg1, InetAddress arg2, int arg3) throws IOException
+	{
+		return null;
+	}
+
+    public static SocketFactory getDefault()
+    {
+    	if(context == null)
+    	{
+			try
+			{
+				init();
+			}
+			catch (KeyManagementException e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+			catch (KeyStoreException e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+			catch (NoSuchAlgorithmException e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+			catch (CertificateException e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+			catch (IOException e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+    	}
+    	
+        return context.getSocketFactory();
+    }
+    /* delegate SSLSocketFactory public methods to sf */
+//	ssf.setHostnameVerifier(MySSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/intentlauncher/RhasspyIntentWorker.java

@@ -0,0 +1,392 @@
+package com.jens.rhasspy.intentlauncher;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.json.JSONObject;
+
+import jdk.nashorn.internal.parser.JSONParser;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+public class RhasspyIntentWorker implements Runnable
+{
+	protected static final int silentRcCode = 99; 
+	protected static final String siteIdString = "siteId";
+	protected static final String topicNameSpeakCommand = "hermes/tts/say";
+	protected static final String topicNameEndSession = "hermes/dialogueManager/endSession";
+		
+	protected static RhasspyIntentWorker instance;
+		
+	public boolean requestUpdates()
+	{
+//		MQTT.subscribe(this, topicToSubscribeTo);
+		return true;
+	}
+	
+	public RhasspyIntentWorker()
+	{
+		instance = this;
+	}
+
+	@Override
+	public void run()
+	{
+		Thread.setDefaultUncaughtExceptionHandler(Miscellaneous.getUncaughtExceptionHandler(3));
+		
+		try
+		{
+			Miscellaneous.logEvent("Subscribing to MQTT topic " + Settings.intentMqttPath + "...", 3);
+			MQTT.subscribe(Settings.intentMqttPath, false);
+		}
+		catch(Exception e)
+		{
+		    Miscellaneous.logEvent("Unknown error in sensor: " + e.getMessage(), 1);
+		    Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+		}
+	}
+	
+	/*public static boolean switchMatrixLeds(String scriptPath, String stateString)
+	{
+		long speakTimeOut = 10000;
+		
+		Miscellaneous.logEvent("Running led script \"" + scriptPath + "\"", 5);
+		String commandToExecute = Settings.voiceInterfaceLedScriptPath.replace(Settings.settingsTtsLedStateVariable, stateString);
+		
+		Object[] returnObject = Miscellaneous.runExternalApplication(commandToExecute, speakTimeOut, null, null);
+		
+		int rc = (int)returnObject[0];
+		String output =  (String)returnObject[1];
+		
+		if(returnObject != null)
+			Miscellaneous.logEvent("Result of external execution: Command=" + commandToExecute + ", RC=" + String.valueOf(rc) + ", output: " + Miscellaneous.lineSeparator + output, 3);
+		
+		return rc==0;	
+	}
+	
+	public static boolean playSoundFile(String targetSystem, String soundFilePath)
+	{
+		long speakTimeOut = 10000;
+		
+		Miscellaneous.logEvent("Playing sound file \"" + soundFilePath + "\" using command " + Settings.voiceInterfacePlaySoundPath, 5);
+		
+		String commandToExecute = Settings.voiceInterfacePlaySoundPath.replace("<targetSystem>", targetSystem);
+		commandToExecute = Settings.voiceInterfacePlaySoundPath.replace(Settings.settingsTtsSoundFileVariable,  "\"" + soundFilePath + "\"");
+		
+		Object[] returnObject = Miscellaneous.runExternalApplication(commandToExecute, speakTimeOut, null, null);
+		
+		int rc = (int)returnObject[0];
+		String output =  (String)returnObject[1];
+		
+		if(returnObject != null)
+			Miscellaneous.logEvent("Result of external execution: Command=" + commandToExecute + ", RC=" + String.valueOf(rc) + ", output: " + Miscellaneous.lineSeparator + output, 3);
+		
+		return rc==0;	
+	}*/
+		
+	/*
+	 * 
+		RHASSPY FORMAT:
+		
+		Topic: rhasspy/intent/SwitchDevice OR hermes/intent/SwitchDevice
+		
+		Payload:
+		{
+			"sessionId": "",
+			"siteId": "default",
+			"input": "stern aus schalten",
+			"intent": {"intentName": "SwitchDevice", "confidenceScore": 1.0},
+			"slots":
+				[
+					{
+						"slotName": "deviceName", "confidence": 1,
+						"value": {"kind": "deviceName", "value": "stern"},
+						"rawValue": "stern"
+					},
+					{
+						"slotName": "onOffState", "confidence": 1,
+						"value": {"kind": "onOffState", "value": "aus"},
+						"rawValue": "aus"
+					}
+				],
+			"asrTokens": [],
+			"asrConfidence": 1
+		}
+		
+		
+		NEW
+		
+		{
+			"input": "sag mir die uhrzeit", 
+			"intent":
+					{
+						"intentName": "GetTime",
+						"confidenceScore": 1.0
+					},
+			"siteId": "satellite02",
+			"id": null,
+			"slots": [],
+			"sessionId": "satellite02-porcupine-e1c9281b-9e0b-4524-b24e-132046bf8a6f",
+			"customData": null,
+			"asrTokens": [
+							[
+								{
+									"value": "sag",
+									"confidence": 1.0,
+									"rangeStart": 0,
+									"rangeEnd": 3,
+									"time": null
+								},
+								{
+									"value": "mir",
+									"confidence": 1.0,
+									"rangeStart": 4,
+									"rangeEnd": 7,
+									"time": null
+								},
+								{
+									"value": "die",
+									"confidence": 1.0,
+									"rangeStart": 8,
+									"rangeEnd": 11,
+									"time": null
+								},
+								{
+									"value": "uhrzeit",
+									"confidence": 1.0,
+									"rangeStart": 12,
+									"rangeEnd": 19,
+									"time": null
+								}
+							]
+						],
+			"asrConfidence": null,
+			"rawInput": "sag mir die uhrzeit",
+			"wakewordId": "porcupine",
+			"lang": null
+		}
+	 */
+		
+	public void notifyOfNewValues(Object result)
+	{
+		/*
+		 * object[0] = message;
+		 * object[1] = topic;
+		 */
+		
+		Object[] results = (Object[])result;
+		
+		String siteId = null;
+				
+		MqttMessage message = (MqttMessage)results[0];				
+		String topic = (String)results[1];
+
+		Miscellaneous.logEvent("New MQTT message on topic " + topic, 3);
+
+		try
+		{
+			Map<String,String> slotMap = new HashMap<>();
+			String payloadString = new String(message.getPayload());
+			if(!StringUtils.isEmpty(payloadString) && (!payloadString.trim().startsWith("{") || !payloadString.trim().endsWith("}")))
+				Miscellaneous.logEvent("Empty or invalid payload", 1);
+			else
+			{
+				// EXTRACT PARAMATERS
+				JSONObject jsonObject = new JSONObject(new String(message.getPayload(), StandardCharsets.UTF_8));
+				
+				if(jsonObject.has(siteIdString))
+				{
+					siteId = jsonObject.getString(siteIdString);
+					slotMap.put(siteIdString, siteId);
+				}
+				
+				if(jsonObject.has("slots"))
+				{				
+					JSONArray jsonArray = jsonObject.getJSONArray("slots");
+					for(int i = 0; i < jsonArray.length(); i++)
+					{
+						JSONObject ob = jsonArray.getJSONObject(i);
+						String sn = ob.getString("slotName");
+						String val = ob.getJSONObject("value").getString("value");
+						Miscellaneous.logEvent("Found slot " + sn + " with value " + val, 5);
+						slotMap.put(sn, val);
+					}
+				}
+				
+				// CHECK INTENT
+				if(slotMap.containsKey(siteIdString))
+				{
+					for(String is : Settings.ignoredSatellites.split(","))
+						if(slotMap.get(siteIdString).equals(is))	//ignore the requests, currently master always cc'd
+							return;
+				}
+				
+				String subtopic = topic.substring(topic.lastIndexOf("/") + 1);
+							
+				/*
+				 * Check if there is an external script under the name of the topic
+				 */
+				boolean scriptFound = false;
+				File scriptsFolder = new File(Settings.scriptsPath);
+				if(scriptsFolder.exists() && scriptsFolder.isDirectory())
+				{
+					for(File script : scriptsFolder.listFiles())
+					{
+						Miscellaneous.logEvent("Checking if scripts file " + script.getAbsolutePath() + " applies for " + subtopic, 5);
+						boolean applies = false;
+						
+						if(script.getName().equalsIgnoreCase(subtopic))
+							applies = true;
+						else
+						{
+							if(script.getName().contains("."))
+							{
+								String nameWithoutSuffix = script.getName().substring(0, script.getName().lastIndexOf(".")); 
+								if(nameWithoutSuffix.equalsIgnoreCase(subtopic))
+									applies = true;
+							}
+						}
+						
+						if(applies)	// name matches -> run it
+						{
+							scriptFound = true;
+							String executionPath = script.getAbsolutePath();
+							if(script.getAbsolutePath().endsWith(".jar"))
+								executionPath = "java -jar " + executionPath;
+							
+							File wd = new File(script.getParent());
+							Miscellaneous.logEvent("Running script " + script.getAbsolutePath() + " to respond to voice command.", 3);
+							
+							Object[] response = Miscellaneous.runExternalApplication(executionPath, 10000, wd, slotMap);
+							int rc = (int)response[0];
+							Miscellaneous.logEvent("Execution finished. RC=" + String.valueOf(rc), 3);
+							String output = ((String)response[1]).trim();
+							
+							if(rc == 0)
+								playRandomSound(siteId, 0);
+							else if(rc == silentRcCode)
+								;	// shut up
+							else
+								playRandomSound(siteId, 1);
+							
+							if(!StringUtils.isBlank(output))	// Script returns some command line output
+							{
+								boolean execResult = speak(siteId, output);
+								
+	//									if(!execResult)
+	//										playRandomSound(siteId, 1);
+							}
+						}
+						else
+							Miscellaneous.logEvent(subtopic + " cannot be found in file name " + script.getName(), 5);
+					}
+					
+					if(!scriptFound)
+					{
+						Miscellaneous.logEvent("No matching script found in directory.", 3);
+						// Currently deactivated. If we're here an entirely different application my have successfully handled the request already.
+//						playRandomSound(siteId, 1);
+					}
+				}
+				else
+				{
+					Miscellaneous.logEvent("Scripts folder " + scriptsFolder.getAbsolutePath() + " not found.", 1);
+				}
+			}
+		}
+		catch(Exception e)
+		{
+			Miscellaneous.logEvent("Error while processing voice command: " + Miscellaneous.getStackTraceAsString(e), 1);
+			playRandomSound(siteId, 1);
+		}
+		
+		//TODO: close session somehow
+		
+		return;		
+	}
+
+	public static RhasspyIntentWorker getInstance()
+	{
+		return instance;
+	}
+
+	public boolean speak(String siteId, String text)
+	{
+		/*
+		 * {
+			"text":"dies ist eine testnachricht",
+			"siteId":"default",
+			"lang":"de-DE",
+			"id":"cf9320fc-f5d4-4436-8347-cbbb552c4722",
+			"session_id": "",
+			"volume":"1.0"
+			}
+		 */
+		
+		String fullMessage = "{\r\n\"text\":\"" + text + "\",\r\n" + 
+				"			\"siteId\":\"" + siteId + "\",\r\n" + 
+				"			\"lang\":\"" + Settings.language + "\",\r\n" + 
+				"			\"id\":\"cf9320fc-f5d4-4436-8347-cbbb552c4722\",\r\n" + 
+				"			\"session_id\": \"\",\r\n" + 
+				"			\"volume\":\"1.0\"\r\n}";
+		
+		
+		return MQTT.getInstance().publish(topicNameSpeakCommand, fullMessage);
+	}
+
+	void playRandomSound(String targetSystem, int type)
+	{
+		String topic = "hermes/audioServer/" + targetSystem + "/playBytes/0";
+		
+		File soundDir;
+		switch(type)
+		{
+			case 0:
+				soundDir = new File("./sound/confirm");
+			break;
+			case 1:
+				soundDir = new File("./sound/error");
+			break;
+			default:
+				soundDir = new File("./sound/other");
+			break;
+		}
+
+		if(soundDir.exists() && soundDir.isDirectory() && soundDir.listFiles().length > 0)
+		{
+			File[] sounds = soundDir.listFiles();
+			int rnd = new Random().nextInt(sounds.length);
+	//		switchMatrixLeds(Settings.voiceInterfaceLedScriptPath, stateString);
+			
+			File soundToPlay = sounds[rnd];
+			
+			Miscellaneous.logEvent("Playing sound file \"" + soundToPlay.getAbsolutePath() + "\" using MQTT to topic " + topic + ".", 4);
+			
+			try
+			{
+				byte[] fileContent = Files.readAllBytes(soundToPlay.toPath());
+				
+				MqttMessage message = new MqttMessage(fileContent);
+				MQTT.getInstance().getClient().publish(topic, message);
+			}
+			catch(Exception e)
+			{
+				Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+			}
+			
+			Miscellaneous.logEvent("Done playing sound file \"" + soundToPlay.getAbsolutePath() + "\" using MQTT to topic " + topic + ".", 4);
+		}
+		else
+			Miscellaneous.logEvent("No sound file found to play at " + soundDir.getAbsolutePath() + ".", 3);
+	}
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/intentlauncher/Settings.java

@@ -0,0 +1,170 @@
+package com.jens.rhasspy.intentlauncher;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Properties;
+
+public class Settings
+{
+	/*
+	 * Unchangable stuff:
+	 */
+		public static final String programName = "RhasspyIntentLauncher";
+		final static String logFileName = programName + "LogFile.txt";
+		final static int logFilesAmount = 1;
+		final static int maxLogSize = Settings.logMaxSize * 1024 * 1024;
+		final static boolean logAppend = true;
+		public static final String settingsFileName = programName + "-settings.ini";
+		public final static String settingsTtsLedStateVariable = "<state>";
+		public final static String settingsTtsSoundFileVariable = "<soundFilePath>";
+		public final static long notificationWaitPeriod = 60*60*24;
+		public final static int programVersion = 1;
+	/*
+	 * Unchangable stuff:
+	 */
+
+		public static final boolean default_sslDebug = false;
+		public static final String default_keystoreFilename = "keystore.jks";
+		public static final String default_keystorePassword = "keystorePassword";
+		public static final String default_dateFormat = "dd.MM.yyyy HH:mm:ss:SSSS";
+		public static final boolean default_logFileEnabled = false;
+		public static final String default_logFolderPath = "/var/log/homecontrol";
+		public static final int default_logLevel = 3;
+		public static final int default_logMaxSize = 5;		
+		public static final String default_encryptionKey="choose_a_password";
+		public static final String default_language = "en-US";
+		public static final String default_intentMqttPath = "hermes/intent/#";
+		public static final boolean default_notificationsEnabled = true;
+		public static final int default_notificationVerbosity = 2;
+		public static final String default_notificationFromAddress = "admin@localhost.com";
+		public static final String default_notificationToAddress = "admin@localhost.com";
+		public static final String default_notificationMailServer = "smtp.host.com";
+		public static final int default_notificationMailServerPort = 25;
+		public static final String default_notificationEncryptionType = "starttls";
+		public static final boolean default_notificationAuthenticate = false;
+		public static final String default_notificationUsername = "smtpUsername";
+		public static final String default_notificationPassword = "smtpPassword";
+		public static final String default_mqttClientServerHostname = "";
+		public static final int default_mqttClientServerPort = 1883;
+		public static final boolean default_mqttClientUseSsl = false;
+		public static final boolean default_mqttClientUseAuthentication = false;
+		public static final String default_mqttClientUsername = "";
+		public static final String default_mqttClientPassword = "";
+		public static final String default_voiceInterfaceLedScriptPath = "/home/pi/lite_js/ledPattern.js";
+		public static final String default_scriptsPath = "/home/pi/rhasspy-scripts";
+		public static final String default_ignoredSatellites = "master";
+		
+	public static String intentMqttPath;
+	public static String language;
+	public static boolean sslDebug;
+	public static String keystoreFilename;
+	public static String keystorePassword;
+	
+	public static String dateFormat = default_dateFormat;
+
+	public static boolean logFileEnabled;
+	public static String logFolderPath;
+	public static int logLevel = 5;						// Set a default value as logging is performed before settings can be loaded.
+	public static int logMaxSize = 5;						// Set a default value as logging is performed before settings can be loaded.
+
+	public static String scriptsPath;
+	
+	public static boolean notificationsEnabled;
+	public static int notificationVerbosity;
+	public static String notificationFromAddress;
+	public static String notificationToAddress;
+	public static String notificationMailServer;
+	public static int notificationMailServerPort;
+	public static String notificationEncryptionType;
+	public static boolean notificationAuthenticate;
+	public static String notificationUsername;
+	public static String notificationPassword;
+	
+	public static String mqttClientServerHostname;
+	public static int mqttClientServerPort;
+	public static boolean mqttClientUseSsl;
+	public static boolean mqttClientUseAuthentication;
+	public static String mqttClientUsername;
+	public static String mqttClientPassword;	
+	
+	public static String ignoredSatellites;
+		
+	public static boolean readSettings()
+	{
+		File sFile = new File(settingsFileName);
+		Miscellaneous.logEvent("Loading settings from " + sFile.getAbsolutePath(), 3);
+		
+		Properties prop = new Properties();		
+		
+		try
+		{
+			// Local settings from settings file
+			prop.load(new FileInputStream(sFile));
+						
+			intentMqttPath = prop.getProperty("intentMqttPath", default_intentMqttPath);
+			language = prop.getProperty("language", default_language);
+			sslDebug = Boolean.parseBoolean(prop.getProperty("sslDebug", String.valueOf(default_sslDebug)));
+			keystoreFilename = prop.getProperty("keystoreFilename", default_keystoreFilename);
+			keystorePassword = prop.getProperty("keystorePassword", default_keystorePassword);
+
+			logFileEnabled = Boolean.parseBoolean(prop.getProperty("logFileEnabled", String.valueOf(default_logFileEnabled)));
+			logFolderPath = prop.getProperty("logFolderPath", String.valueOf(default_logFolderPath));
+			logLevel = Integer.parseInt(prop.getProperty("logLevel", String.valueOf(default_logLevel)));
+			logMaxSize = Integer.parseInt(prop.getProperty("logMaxSize", String.valueOf(default_logMaxSize)));
+
+			scriptsPath = prop.getProperty("scriptsPath", default_scriptsPath);
+
+			notificationsEnabled = Boolean.parseBoolean(prop.getProperty("notificationsEnabled", String.valueOf(default_notificationsEnabled)));
+			notificationVerbosity = Integer.parseInt(prop.getProperty("notificationVerbosity", String.valueOf(default_notificationVerbosity)));
+			notificationFromAddress = prop.getProperty("notificationFromAddress", default_notificationFromAddress);
+			notificationToAddress = prop.getProperty("notificationToAddress", default_notificationToAddress);
+			notificationMailServer = prop.getProperty("notificationMailServer", default_notificationMailServer);
+			notificationMailServerPort = Integer.parseInt(prop.getProperty("notificationMailServerPort", String.valueOf(default_notificationMailServerPort)));
+			notificationEncryptionType = prop.getProperty("notificationEncryptionType", default_notificationEncryptionType);
+			notificationAuthenticate = Boolean.parseBoolean(prop.getProperty("notificationAuthenticate", String.valueOf(default_notificationAuthenticate)));
+			notificationUsername = prop.getProperty("notificationUsername", default_notificationUsername);
+			notificationPassword = prop.getProperty("notificationPassword", default_notificationPassword);
+
+			mqttClientServerHostname = prop.getProperty("mqttClientServerHostname", default_mqttClientServerHostname);
+			mqttClientServerPort = Integer.parseInt(prop.getProperty("mqttClientServerPort", String.valueOf(default_mqttClientServerPort)));
+			mqttClientUseSsl = Boolean.parseBoolean(prop.getProperty("mqttClientUseSsl", String.valueOf(default_mqttClientUseSsl)));
+			mqttClientUseAuthentication = Boolean.parseBoolean(prop.getProperty("mqttClientUseAuthentication", String.valueOf(default_mqttClientUseAuthentication)));
+			mqttClientUsername = prop.getProperty("mqttClientUsername", default_mqttClientUsername);
+			mqttClientPassword = prop.getProperty("mqttClientPassword", default_mqttClientPassword);
+			ignoredSatellites = prop.getProperty("ignoredSatellites", default_ignoredSatellites);
+			
+			if(mqttClientUseSsl)
+				loadKeystore();
+		}
+		catch (FileNotFoundException e)
+		{
+			Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+		}
+		catch (IOException e)
+		{
+			Miscellaneous.logEvent(Miscellaneous.getStackTraceAsString(e), 1);
+		}
+
+		return true;
+	}
+	
+	static void loadKeystore()
+	{
+		if((new File(Settings.keystoreFilename).exists()))
+		{
+			Miscellaneous.logEvent("Loading keystore " + Settings.keystoreFilename, 3);
+			System.setProperty("javax.net.ssl.keyStore", Settings.keystoreFilename);
+		    System.setProperty("javax.net.ssl.keyStorePassword", Settings.keystorePassword);		    	
+	    	System.setProperty("javax.net.ssl.trustStore", Settings.keystoreFilename);
+	    	System.setProperty("javax.net.ssl.trustStorePassword", Settings.keystorePassword);
+//	    	System.setProperty("javax.net.ssl.trustStoreType","JCEKS");
+		}
+		else
+		{
+			Miscellaneous.logEvent("Could not load keystore, file does not exist.", 3);
+			System.exit(1);
+		}
+	}
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/intentlauncher/Starter.java

@@ -0,0 +1,71 @@
+package com.jens.rhasspy.intentlauncher;
+
+public class Starter
+{
+	public static void main(String[] args)
+	{
+		if(!Settings.readSettings())
+		{
+			System.out.println("Settings could not be loaded.");
+			System.exit(1);
+		}
+		
+		if(args.length == 0)
+		{
+			// Start daemon
+			RhasspyIntentWorker server = new RhasspyIntentWorker();
+			Thread t = new Thread(server);
+			t.start();
+			
+			/*
+			 * We just need to stay alive here. The thread just opened will do the actual work.
+			 */
+			/*while(true)
+			{
+				try
+				{
+					Thread.sleep(5000);
+				}
+				catch(Exception e)
+				{
+					
+				}
+			}*/
+		}
+		else
+		{
+//			for(int i=0; i<args.length; i++)
+//				System.out.println("Args " + String.valueOf(i) + ": " + args[i]);
+			
+			switch(args[0])
+			{			
+				case "-testEmailNotification":
+					testEmailNotification();
+					break;
+				case "-getVersion":
+					System.out.println(Settings.programVersion);
+					break;
+				default:
+					System.out.println("Unknown parameters.");
+					System.exit(1);
+			}
+		}
+	}
+	
+	private static void testEmailNotification()
+	{
+		Settings.readSettings();
+		
+		if(Miscellaneous.notifyAdminViaEmail("Test notification from " + Settings.programName + ".", true, 1))
+		{
+			System.out.println("Mail notification successfull.");
+			System.exit(0);
+		}
+		else
+		{
+			System.out.println("Mail notification failed.");
+		}
+		
+		System.exit(7);
+	}
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONException.java

@@ -0,0 +1,45 @@
+package com.jens.rhasspy.lib;
+
+/**
+ * The JSONException is thrown by the JSON.org classes when things are amiss.
+ *
+ * @author JSON.org
+ * @version 2015-12-09
+ */
+public class JSONException extends RuntimeException {
+    /** Serialization ID */
+    private static final long serialVersionUID = 0;
+
+    /**
+     * Constructs a JSONException with an explanatory message.
+     *
+     * @param message
+     *            Detail about the reason for the exception.
+     */
+    public JSONException(final String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a JSONException with an explanatory message and cause.
+     * 
+     * @param message
+     *            Detail about the reason for the exception.
+     * @param cause
+     *            The cause.
+     */
+    public JSONException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new JSONException with the specified cause.
+     * 
+     * @param cause
+     *            The cause.
+     */
+    public JSONException(final Throwable cause) {
+        super(cause.getMessage(), cause);
+    }
+
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONML.java

@@ -0,0 +1,542 @@
+package com.jens.rhasspy.lib;
+
+/*
+Copyright (c) 2008 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * This provides static methods to convert an XML text into a JSONArray or
+ * JSONObject, and to covert a JSONArray or JSONObject into an XML text using
+ * the JsonML transform.
+ *
+ * @author JSON.org
+ * @version 2016-01-30
+ */
+public class JSONML {
+    /**
+     * Parse XML values and store them in a JSONArray.
+     * @param x       The XMLTokener containing the source string.
+     * @param arrayForm true if array form, false if object form.
+     * @param ja      The JSONArray that is containing the current tag or null
+     *     if we are at the outermost level.
+     * @param keepStrings	Don't type-convert text nodes and attribute values
+     * @return A JSONArray if the value is the outermost tag, otherwise null.
+     * @throws JSONException
+     */
+    private static Object parse(
+        XMLTokener x,
+        boolean    arrayForm,
+        JSONArray  ja,
+        boolean keepStrings
+    ) throws JSONException {
+        String     attribute;
+        char       c;
+        String     closeTag = null;
+        int        i;
+        JSONArray  newja = null;
+        JSONObject newjo = null;
+        Object     token;
+        String     tagName = null;
+
+// Test for and skip past these forms:
+//      <!-- ... -->
+//      <![  ... ]]>
+//      <!   ...   >
+//      <?   ...  ?>
+
+        while (true) {
+            if (!x.more()) {
+                throw x.syntaxError("Bad XML");
+            }
+            token = x.nextContent();
+            if (token == XML.LT) {
+                token = x.nextToken();
+                if (token instanceof Character) {
+                    if (token == XML.SLASH) {
+
+// Close tag </
+
+                        token = x.nextToken();
+                        if (!(token instanceof String)) {
+                            throw new JSONException(
+                                    "Expected a closing name instead of '" +
+                                    token + "'.");
+                        }
+                        if (x.nextToken() != XML.GT) {
+                            throw x.syntaxError("Misshaped close tag");
+                        }
+                        return token;
+                    } else if (token == XML.BANG) {
+
+// <!
+
+                        c = x.next();
+                        if (c == '-') {
+                            if (x.next() == '-') {
+                                x.skipPast("-->");
+                            } else {
+                                x.back();
+                            }
+                        } else if (c == '[') {
+                            token = x.nextToken();
+                            if (token.equals("CDATA") && x.next() == '[') {
+                                if (ja != null) {
+                                    ja.put(x.nextCDATA());
+                                }
+                            } else {
+                                throw x.syntaxError("Expected 'CDATA['");
+                            }
+                        } else {
+                            i = 1;
+                            do {
+                                token = x.nextMeta();
+                                if (token == null) {
+                                    throw x.syntaxError("Missing '>' after '<!'.");
+                                } else if (token == XML.LT) {
+                                    i += 1;
+                                } else if (token == XML.GT) {
+                                    i -= 1;
+                                }
+                            } while (i > 0);
+                        }
+                    } else if (token == XML.QUEST) {
+
+// <?
+
+                        x.skipPast("?>");
+                    } else {
+                        throw x.syntaxError("Misshaped tag");
+                    }
+
+// Open tag <
+
+                } else {
+                    if (!(token instanceof String)) {
+                        throw x.syntaxError("Bad tagName '" + token + "'.");
+                    }
+                    tagName = (String)token;
+                    newja = new JSONArray();
+                    newjo = new JSONObject();
+                    if (arrayForm) {
+                        newja.put(tagName);
+                        if (ja != null) {
+                            ja.put(newja);
+                        }
+                    } else {
+                        newjo.put("tagName", tagName);
+                        if (ja != null) {
+                            ja.put(newjo);
+                        }
+                    }
+                    token = null;
+                    for (;;) {
+                        if (token == null) {
+                            token = x.nextToken();
+                        }
+                        if (token == null) {
+                            throw x.syntaxError("Misshaped tag");
+                        }
+                        if (!(token instanceof String)) {
+                            break;
+                        }
+
+// attribute = value
+
+                        attribute = (String)token;
+                        if (!arrayForm && ("tagName".equals(attribute) || "childNode".equals(attribute))) {
+                            throw x.syntaxError("Reserved attribute.");
+                        }
+                        token = x.nextToken();
+                        if (token == XML.EQ) {
+                            token = x.nextToken();
+                            if (!(token instanceof String)) {
+                                throw x.syntaxError("Missing value");
+                            }
+                            newjo.accumulate(attribute, keepStrings ? ((String)token) :XML.stringToValue((String)token));
+                            token = null;
+                        } else {
+                            newjo.accumulate(attribute, "");
+                        }
+                    }
+                    if (arrayForm && newjo.length() > 0) {
+                        newja.put(newjo);
+                    }
+
+// Empty tag <.../>
+
+                    if (token == XML.SLASH) {
+                        if (x.nextToken() != XML.GT) {
+                            throw x.syntaxError("Misshaped tag");
+                        }
+                        if (ja == null) {
+                            if (arrayForm) {
+                                return newja;
+                            }
+                            return newjo;
+                        }
+
+// Content, between <...> and </...>
+
+                    } else {
+                        if (token != XML.GT) {
+                            throw x.syntaxError("Misshaped tag");
+                        }
+                        closeTag = (String)parse(x, arrayForm, newja, keepStrings);
+                        if (closeTag != null) {
+                            if (!closeTag.equals(tagName)) {
+                                throw x.syntaxError("Mismatched '" + tagName +
+                                        "' and '" + closeTag + "'");
+                            }
+                            tagName = null;
+                            if (!arrayForm && newja.length() > 0) {
+                                newjo.put("childNodes", newja);
+                            }
+                            if (ja == null) {
+                                if (arrayForm) {
+                                    return newja;
+                                }
+                                return newjo;
+                            }
+                        }
+                    }
+                }
+            } else {
+                if (ja != null) {
+                    ja.put(token instanceof String
+                        ? keepStrings ? XML.unescape((String)token) :XML.stringToValue((String)token)
+                        : token);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child tags.
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param string The source string.
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(String string) throws JSONException {
+        return (JSONArray)parse(new XMLTokener(string), true, null, false);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child tags.
+     * As opposed to toJSONArray this method does not attempt to convert 
+     * any text node or attribute value to any type 
+     * but just leaves it as a string.
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param string The source string.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(String string, boolean keepStrings) throws JSONException {
+        return (JSONArray)parse(new XMLTokener(string), true, null, keepStrings);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child content and tags.
+     * As opposed to toJSONArray this method does not attempt to convert 
+     * any text node or attribute value to any type 
+     * but just leaves it as a string.
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(XMLTokener x, boolean keepStrings) throws JSONException {
+        return (JSONArray)parse(x, true, null, keepStrings);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child content and tags.
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener.
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(XMLTokener x) throws JSONException {
+        return (JSONArray)parse(x, true, null, false);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param string The XML source text.
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(String string) throws JSONException {
+        return (JSONObject)parse(new XMLTokener(string), false, null, false);
+    }
+    
+    
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param string The XML source text.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {
+        return (JSONObject)parse(new XMLTokener(string), false, null, keepStrings);
+    }
+
+    
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener of the XML source text.
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(XMLTokener x) throws JSONException {
+           return (JSONObject)parse(x, false, null, false);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
+     * @param x An XMLTokener of the XML source text.
+     * @param keepStrings If true, then values will not be coerced into boolean
+     *  or numeric values and will instead be left as strings
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(XMLTokener x, boolean keepStrings) throws JSONException {
+           return (JSONObject)parse(x, false, null, keepStrings);
+    }
+
+
+    /**
+     * Reverse the JSONML transformation, making an XML text from a JSONArray.
+     * @param ja A JSONArray.
+     * @return An XML string.
+     * @throws JSONException Thrown on error converting to a string
+     */
+    public static String toString(JSONArray ja) throws JSONException {
+        int                 i;
+        JSONObject          jo;
+        int                 length;
+        Object              object;
+        StringBuilder        sb = new StringBuilder();
+        String              tagName;
+
+// Emit <tagName
+
+        tagName = ja.getString(0);
+        XML.noSpace(tagName);
+        tagName = XML.escape(tagName);
+        sb.append('<');
+        sb.append(tagName);
+
+        object = ja.opt(1);
+        if (object instanceof JSONObject) {
+            i = 2;
+            jo = (JSONObject)object;
+
+// Emit the attributes
+
+            // Don't use the new entrySet API to maintain Android support
+            for (final String key : jo.keySet()) {
+                final Object value = jo.opt(key);
+                XML.noSpace(key);
+                if (value != null) {
+                    sb.append(' ');
+                    sb.append(XML.escape(key));
+                    sb.append('=');
+                    sb.append('"');
+                    sb.append(XML.escape(value.toString()));
+                    sb.append('"');
+                }
+            }
+        } else {
+            i = 1;
+        }
+
+// Emit content in body
+
+        length = ja.length();
+        if (i >= length) {
+            sb.append('/');
+            sb.append('>');
+        } else {
+            sb.append('>');
+            do {
+                object = ja.get(i);
+                i += 1;
+                if (object != null) {
+                    if (object instanceof String) {
+                        sb.append(XML.escape(object.toString()));
+                    } else if (object instanceof JSONObject) {
+                        sb.append(toString((JSONObject)object));
+                    } else if (object instanceof JSONArray) {
+                        sb.append(toString((JSONArray)object));
+                    } else {
+                        sb.append(object.toString());
+                    }
+                }
+            } while (i < length);
+            sb.append('<');
+            sb.append('/');
+            sb.append(tagName);
+            sb.append('>');
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Reverse the JSONML transformation, making an XML text from a JSONObject.
+     * The JSONObject must contain a "tagName" property. If it has children,
+     * then it must have a "childNodes" property containing an array of objects.
+     * The other properties are attributes with string values.
+     * @param jo A JSONObject.
+     * @return An XML string.
+     * @throws JSONException Thrown on error converting to a string
+     */
+    public static String toString(JSONObject jo) throws JSONException {
+        StringBuilder sb = new StringBuilder();
+        int                 i;
+        JSONArray           ja;
+        int                 length;
+        Object              object;
+        String              tagName;
+        Object              value;
+
+//Emit <tagName
+
+        tagName = jo.optString("tagName");
+        if (tagName == null) {
+            return XML.escape(jo.toString());
+        }
+        XML.noSpace(tagName);
+        tagName = XML.escape(tagName);
+        sb.append('<');
+        sb.append(tagName);
+
+//Emit the attributes
+
+        // Don't use the new entrySet API to maintain Android support
+        for (final String key : jo.keySet()) {
+            if (!"tagName".equals(key) && !"childNodes".equals(key)) {
+                XML.noSpace(key);
+                value = jo.opt(key);
+                if (value != null) {
+                    sb.append(' ');
+                    sb.append(XML.escape(key));
+                    sb.append('=');
+                    sb.append('"');
+                    sb.append(XML.escape(value.toString()));
+                    sb.append('"');
+                }
+            }
+        }
+
+//Emit content in body
+
+        ja = jo.optJSONArray("childNodes");
+        if (ja == null) {
+            sb.append('/');
+            sb.append('>');
+        } else {
+            sb.append('>');
+            length = ja.length();
+            for (i = 0; i < length; i += 1) {
+                object = ja.get(i);
+                if (object != null) {
+                    if (object instanceof String) {
+                        sb.append(XML.escape(object.toString()));
+                    } else if (object instanceof JSONObject) {
+                        sb.append(toString((JSONObject)object));
+                    } else if (object instanceof JSONArray) {
+                        sb.append(toString((JSONArray)object));
+                    } else {
+                        sb.append(object.toString());
+                    }
+                }
+            }
+            sb.append('<');
+            sb.append('/');
+            sb.append(tagName);
+            sb.append('>');
+        }
+        return sb.toString();
+    }
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONPointer.java

@@ -0,0 +1,293 @@
+package com.jens.rhasspy.lib;
+
+import static java.lang.String.format;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * A JSON Pointer is a simple query language defined for JSON documents by
+ * <a href="https://tools.ietf.org/html/rfc6901">RFC 6901</a>.
+ * 
+ * In a nutshell, JSONPointer allows the user to navigate into a JSON document
+ * using strings, and retrieve targeted objects, like a simple form of XPATH.
+ * Path segments are separated by the '/' char, which signifies the root of
+ * the document when it appears as the first char of the string. Array 
+ * elements are navigated using ordinals, counting from 0. JSONPointer strings
+ * may be extended to any arbitrary number of segments. If the navigation
+ * is successful, the matched item is returned. A matched item may be a
+ * JSONObject, a JSONArray, or a JSON value. If the JSONPointer string building 
+ * fails, an appropriate exception is thrown. If the navigation fails to find
+ * a match, a JSONPointerException is thrown. 
+ * 
+ * @author JSON.org
+ * @version 2016-05-14
+ */
+public class JSONPointer {
+
+    // used for URL encoding and decoding
+    private static final String ENCODING = "utf-8";
+
+    /**
+     * This class allows the user to build a JSONPointer in steps, using
+     * exactly one segment in each step.
+     */
+    public static class Builder {
+
+        // Segments for the eventual JSONPointer string
+        private final List<String> refTokens = new ArrayList<String>();
+
+        /**
+         * Creates a {@code JSONPointer} instance using the tokens previously set using the
+         * {@link #append(String)} method calls.
+         */
+        public JSONPointer build() {
+            return new JSONPointer(this.refTokens);
+        }
+
+        /**
+         * Adds an arbitrary token to the list of reference tokens. It can be any non-null value.
+         * 
+         * Unlike in the case of JSON string or URI fragment representation of JSON pointers, the
+         * argument of this method MUST NOT be escaped. If you want to query the property called
+         * {@code "a~b"} then you should simply pass the {@code "a~b"} string as-is, there is no
+         * need to escape it as {@code "a~0b"}.
+         * 
+         * @param token the new token to be appended to the list
+         * @return {@code this}
+         * @throws NullPointerException if {@code token} is null
+         */
+        public Builder append(String token) {
+            if (token == null) {
+                throw new NullPointerException("token cannot be null");
+            }
+            this.refTokens.add(token);
+            return this;
+        }
+
+        /**
+         * Adds an integer to the reference token list. Although not necessarily, mostly this token will
+         * denote an array index. 
+         * 
+         * @param arrayIndex the array index to be added to the token list
+         * @return {@code this}
+         */
+        public Builder append(int arrayIndex) {
+            this.refTokens.add(String.valueOf(arrayIndex));
+            return this;
+        }
+    }
+
+    /**
+     * Static factory method for {@link Builder}. Example usage:
+     * 
+     * <pre><code>
+     * JSONPointer pointer = JSONPointer.builder()
+     *       .append("obj")
+     *       .append("other~key").append("another/key")
+     *       .append("\"")
+     *       .append(0)
+     *       .build();
+     * </code></pre>
+     * 
+     *  @return a builder instance which can be used to construct a {@code JSONPointer} instance by chained
+     *  {@link Builder#append(String)} calls.
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    // Segments for the JSONPointer string
+    private final List<String> refTokens;
+
+    /**
+     * Pre-parses and initializes a new {@code JSONPointer} instance. If you want to
+     * evaluate the same JSON Pointer on different JSON documents then it is recommended
+     * to keep the {@code JSONPointer} instances due to performance considerations.
+     * 
+     * @param pointer the JSON String or URI Fragment representation of the JSON pointer.
+     * @throws IllegalArgumentException if {@code pointer} is not a valid JSON pointer
+     */
+    public JSONPointer(final String pointer) {
+        if (pointer == null) {
+            throw new NullPointerException("pointer cannot be null");
+        }
+        if (pointer.isEmpty() || pointer.equals("#")) {
+            this.refTokens = Collections.emptyList();
+            return;
+        }
+        String refs;
+        if (pointer.startsWith("#/")) {
+            refs = pointer.substring(2);
+            try {
+                refs = URLDecoder.decode(refs, ENCODING);
+            } catch (UnsupportedEncodingException e) {
+                throw new RuntimeException(e);
+            }
+        } else if (pointer.startsWith("/")) {
+            refs = pointer.substring(1);
+        } else {
+            throw new IllegalArgumentException("a JSON pointer should start with '/' or '#/'");
+        }
+        this.refTokens = new ArrayList<String>();
+        int slashIdx = -1;
+        int prevSlashIdx = 0;
+        do {
+            prevSlashIdx = slashIdx + 1;
+            slashIdx = refs.indexOf('/', prevSlashIdx);
+            if(prevSlashIdx == slashIdx || prevSlashIdx == refs.length()) {
+                // found 2 slashes in a row ( obj//next )
+                // or single slash at the end of a string ( obj/test/ )
+                this.refTokens.add("");
+            } else if (slashIdx >= 0) {
+                final String token = refs.substring(prevSlashIdx, slashIdx);
+                this.refTokens.add(unescape(token));
+            } else {
+                // last item after separator, or no separator at all.
+                final String token = refs.substring(prevSlashIdx);
+                this.refTokens.add(unescape(token));
+            }
+        } while (slashIdx >= 0);
+        // using split does not take into account consecutive separators or "ending nulls"
+        //for (String token : refs.split("/")) {
+        //    this.refTokens.add(unescape(token));
+        //}
+    }
+
+    public JSONPointer(List<String> refTokens) {
+        this.refTokens = new ArrayList<String>(refTokens);
+    }
+
+    private String unescape(String token) {
+        return token.replace("~1", "/").replace("~0", "~")
+                .replace("\\\"", "\"")
+                .replace("\\\\", "\\");
+    }
+
+    /**
+     * Evaluates this JSON Pointer on the given {@code document}. The {@code document}
+     * is usually a {@link JSONObject} or a {@link JSONArray} instance, but the empty
+     * JSON Pointer ({@code ""}) can be evaluated on any JSON values and in such case the
+     * returned value will be {@code document} itself. 
+     * 
+     * @param document the JSON document which should be the subject of querying.
+     * @return the result of the evaluation
+     * @throws JSONPointerException if an error occurs during evaluation
+     */
+    public Object queryFrom(Object document) throws JSONPointerException {
+        if (this.refTokens.isEmpty()) {
+            return document;
+        }
+        Object current = document;
+        for (String token : this.refTokens) {
+            if (current instanceof JSONObject) {
+                current = ((JSONObject) current).opt(unescape(token));
+            } else if (current instanceof JSONArray) {
+                current = readByIndexToken(current, token);
+            } else {
+                throw new JSONPointerException(format(
+                        "value [%s] is not an array or object therefore its key %s cannot be resolved", current,
+                        token));
+            }
+        }
+        return current;
+    }
+
+    /**
+     * Matches a JSONArray element by ordinal position
+     * @param current the JSONArray to be evaluated
+     * @param indexToken the array index in string form
+     * @return the matched object. If no matching item is found a
+     * @throws JSONPointerException is thrown if the index is out of bounds
+     */
+    private Object readByIndexToken(Object current, String indexToken) throws JSONPointerException {
+        try {
+            int index = Integer.parseInt(indexToken);
+            JSONArray currentArr = (JSONArray) current;
+            if (index >= currentArr.length()) {
+                throw new JSONPointerException(format("index %d is out of bounds - the array has %d elements", index,
+                        currentArr.length()));
+            }
+            try {
+				return currentArr.get(index);
+			} catch (JSONException e) {
+				throw new JSONPointerException("Error reading value at index position " + index, e);
+			}
+        } catch (NumberFormatException e) {
+            throw new JSONPointerException(format("%s is not an array index", indexToken), e);
+        }
+    }
+
+    /**
+     * Returns a string representing the JSONPointer path value using string
+     * representation
+     */
+    @Override
+    public String toString() {
+        StringBuilder rval = new StringBuilder("");
+        for (String token: this.refTokens) {
+            rval.append('/').append(escape(token));
+        }
+        return rval.toString();
+    }
+
+    /**
+     * Escapes path segment values to an unambiguous form.
+     * The escape char to be inserted is '~'. The chars to be escaped 
+     * are ~, which maps to ~0, and /, which maps to ~1. Backslashes
+     * and double quote chars are also escaped.
+     * @param token the JSONPointer segment value to be escaped
+     * @return the escaped value for the token
+     */
+    private String escape(String token) {
+        return token.replace("~", "~0")
+                .replace("/", "~1")
+                .replace("\\", "\\\\")
+                .replace("\"", "\\\"");
+    }
+
+    /**
+     * Returns a string representing the JSONPointer path value using URI
+     * fragment identifier representation
+     */
+    public String toURIFragment() {
+        try {
+            StringBuilder rval = new StringBuilder("#");
+            for (String token : this.refTokens) {
+                rval.append('/').append(URLEncoder.encode(token, ENCODING));
+            }
+            return rval.toString();
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONPointerException.java

@@ -0,0 +1,45 @@
+package com.jens.rhasspy.lib;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * The JSONPointerException is thrown by {@link JSONPointer} if an error occurs
+ * during evaluating a pointer.
+ * 
+ * @author JSON.org
+ * @version 2016-05-13
+ */
+public class JSONPointerException extends JSONException {
+    private static final long serialVersionUID = 8872944667561856751L;
+
+    public JSONPointerException(String message) {
+        super(message);
+    }
+
+    public JSONPointerException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONPropertyIgnore.java

@@ -0,0 +1,43 @@
+package com.jens.rhasspy.lib;
+
+/*
+Copyright (c) 2018 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RUNTIME)
+@Target({METHOD})
+/**
+ * Use this annotation on a getter method to override the Bean name
+ * parser for Bean -> JSONObject mapping. If this annotation is
+ * present at any level in the class hierarchy, then the method will
+ * not be serialized from the bean into the JSONObject.
+ */
+public @interface JSONPropertyIgnore { }

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONPropertyName.java

@@ -0,0 +1,47 @@
+package com.jens.rhasspy.lib;
+
+/*
+Copyright (c) 2018 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RUNTIME)
+@Target({METHOD})
+/**
+ * Use this annotation on a getter method to override the Bean name
+ * parser for Bean -&gt; JSONObject mapping. A value set to empty string <code>""</code>
+ * will have the Bean parser fall back to the default field name processing.
+ */
+public @interface JSONPropertyName {
+    /**
+     * @return The name of the property as to be used in the JSON Object.
+     */
+    String value();
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONString.java

@@ -0,0 +1,18 @@
+package com.jens.rhasspy.lib;
+/**
+ * The <code>JSONString</code> interface allows a <code>toJSONString()</code>
+ * method so that a class can change the behavior of
+ * <code>JSONObject.toString()</code>, <code>JSONArray.toString()</code>,
+ * and <code>JSONWriter.value(</code>Object<code>)</code>. The
+ * <code>toJSONString</code> method will be used instead of the default behavior
+ * of using the Object's <code>toString()</code> method and quoting the result.
+ */
+public interface JSONString {
+    /**
+     * The <code>toJSONString</code> method allows a class to produce its own JSON
+     * serialization.
+     *
+     * @return A strictly syntactically correct JSON text.
+     */
+    public String toJSONString();
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONStringer.java

@@ -0,0 +1,79 @@
+package com.jens.rhasspy.lib;
+
+/*
+Copyright (c) 2006 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.io.StringWriter;
+
+/**
+ * JSONStringer provides a quick and convenient way of producing JSON text.
+ * The texts produced strictly conform to JSON syntax rules. No whitespace is
+ * added, so the results are ready for transmission or storage. Each instance of
+ * JSONStringer can produce one JSON text.
+ * <p>
+ * A JSONStringer instance provides a <code>value</code> method for appending
+ * values to the
+ * text, and a <code>key</code>
+ * method for adding keys before values in objects. There are <code>array</code>
+ * and <code>endArray</code> methods that make and bound array values, and
+ * <code>object</code> and <code>endObject</code> methods which make and bound
+ * object values. All of these methods return the JSONWriter instance,
+ * permitting cascade style. For example, <pre>
+ * myString = new JSONStringer()
+ *     .object()
+ *         .key("JSON")
+ *         .value("Hello, World!")
+ *     .endObject()
+ *     .toString();</pre> which produces the string <pre>
+ * {"JSON":"Hello, World!"}</pre>
+ * <p>
+ * The first method called must be <code>array</code> or <code>object</code>.
+ * There are no methods for adding commas or colons. JSONStringer adds them for
+ * you. Objects and arrays can be nested up to 20 levels deep.
+ * <p>
+ * This can sometimes be easier than using a JSONObject to build a string.
+ * @author JSON.org
+ * @version 2015-12-09
+ */
+public class JSONStringer extends JSONWriter {
+    /**
+     * Make a fresh JSONStringer. It can be used to build one JSON text.
+     */
+    public JSONStringer() {
+        super(new StringWriter());
+    }
+
+    /**
+     * Return the JSON text. This method is used to obtain the product of the
+     * JSONStringer instance. It will return <code>null</code> if there was a
+     * problem in the construction of the JSON text (such as the calls to
+     * <code>array</code> were not properly balanced with calls to
+     * <code>endArray</code>).
+     * @return The JSON text.
+     */
+    @Override
+    public String toString() {
+        return this.mode == 'd' ? this.writer.toString() : null;
+    }
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONTokener.java

@@ -0,0 +1,529 @@
+package com.jens.rhasspy.lib;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.StringReader;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+/**
+ * A JSONTokener takes a source string and extracts characters and tokens from
+ * it. It is used by the JSONObject and JSONArray constructors to parse
+ * JSON source strings.
+ * @author JSON.org
+ * @version 2014-05-03
+ */
+public class JSONTokener {
+    /** current read character position on the current line. */
+    private long character;
+    /** flag to indicate if the end of the input has been found. */
+    private boolean eof;
+    /** current read index of the input. */
+    private long index;
+    /** current line of the input. */
+    private long line;
+    /** previous character read from the input. */
+    private char previous;
+    /** Reader for the input. */
+    private final Reader reader;
+    /** flag to indicate that a previous character was requested. */
+    private boolean usePrevious;
+    /** the number of characters read in the previous line. */
+    private long characterPreviousLine;
+
+
+    /**
+     * Construct a JSONTokener from a Reader. The caller must close the Reader.
+     *
+     * @param reader     A reader.
+     */
+    public JSONTokener(Reader reader) {
+        this.reader = reader.markSupported()
+                ? reader
+                        : new BufferedReader(reader);
+        this.eof = false;
+        this.usePrevious = false;
+        this.previous = 0;
+        this.index = 0;
+        this.character = 1;
+        this.characterPreviousLine = 0;
+        this.line = 1;
+    }
+
+
+    /**
+     * Construct a JSONTokener from an InputStream. The caller must close the input stream.
+     * @param inputStream The source.
+     */
+    public JSONTokener(InputStream inputStream) {
+        this(new InputStreamReader(inputStream));
+    }
+
+
+    /**
+     * Construct a JSONTokener from a string.
+     *
+     * @param s     A source string.
+     */
+    public JSONTokener(String s) {
+        this(new StringReader(s));
+    }
+
+
+    /**
+     * Back up one character. This provides a sort of lookahead capability,
+     * so that you can test for a digit or letter before attempting to parse
+     * the next number or identifier.
+     * @throws JSONException Thrown if trying to step back more than 1 step
+     *  or if already at the start of the string
+     */
+    public void back() throws JSONException {
+        if (this.usePrevious || this.index <= 0) {
+            throw new JSONException("Stepping back two steps is not supported");
+        }
+        this.decrementIndexes();
+        this.usePrevious = true;
+        this.eof = false;
+    }
+
+    /**
+     * Decrements the indexes for the {@link #back()} method based on the previous character read.
+     */
+    private void decrementIndexes() {
+        this.index--;
+        if(this.previous=='\r' || this.previous == '\n') {
+            this.line--;
+            this.character=this.characterPreviousLine ;
+        } else if(this.character > 0){
+            this.character--;
+        }
+    }
+
+    /**
+     * Get the hex value of a character (base16).
+     * @param c A character between '0' and '9' or between 'A' and 'F' or
+     * between 'a' and 'f'.
+     * @return  An int between 0 and 15, or -1 if c was not a hex digit.
+     */
+    public static int dehexchar(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - ('A' - 10);
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - ('a' - 10);
+        }
+        return -1;
+    }
+
+    /**
+     * Checks if the end of the input has been reached.
+     *  
+     * @return true if at the end of the file and we didn't step back
+     */
+    public boolean end() {
+        return this.eof && !this.usePrevious;
+    }
+
+
+    /**
+     * Determine if the source string still contains characters that next()
+     * can consume.
+     * @return true if not yet at the end of the source.
+     * @throws JSONException thrown if there is an error stepping forward
+     *  or backward while checking for more data.
+     */
+    public boolean more() throws JSONException {
+        if(this.usePrevious) {
+            return true;
+        }
+        try {
+            this.reader.mark(1);
+        } catch (IOException e) {
+            throw new JSONException("Unable to preserve stream position", e);
+        }
+        try {
+            // -1 is EOF, but next() can not consume the null character '\0'
+            if(this.reader.read() <= 0) {
+                this.eof = true;
+                return false;
+            }
+            this.reader.reset();
+        } catch (IOException e) {
+            throw new JSONException("Unable to read the next character from the stream", e);
+        }
+        return true;
+    }
+
+
+    /**
+     * Get the next character in the source string.
+     *
+     * @return The next character, or 0 if past the end of the source string.
+     * @throws JSONException Thrown if there is an error reading the source string.
+     */
+    public char next() throws JSONException {
+        int c;
+        if (this.usePrevious) {
+            this.usePrevious = false;
+            c = this.previous;
+        } else {
+            try {
+                c = this.reader.read();
+            } catch (IOException exception) {
+                throw new JSONException(exception);
+            }
+        }
+        if (c <= 0) { // End of stream
+            this.eof = true;
+            return 0;
+        }
+        this.incrementIndexes(c);
+        this.previous = (char) c;
+        return this.previous;
+    }
+
+    /**
+     * Increments the internal indexes according to the previous character
+     * read and the character passed as the current character.
+     * @param c the current character read.
+     */
+    private void incrementIndexes(int c) {
+        if(c > 0) {
+            this.index++;
+            if(c=='\r') {
+                this.line++;
+                this.characterPreviousLine = this.character;
+                this.character=0;
+            }else if (c=='\n') {
+                if(this.previous != '\r') {
+                    this.line++;
+                    this.characterPreviousLine = this.character;
+                }
+                this.character=0;
+            } else {
+                this.character++;
+            }
+        }
+    }
+
+    /**
+     * Consume the next character, and check that it matches a specified
+     * character.
+     * @param c The character to match.
+     * @return The character.
+     * @throws JSONException if the character does not match.
+     */
+    public char next(char c) throws JSONException {
+        char n = this.next();
+        if (n != c) {
+            if(n > 0) {
+                throw this.syntaxError("Expected '" + c + "' and instead saw '" +
+                        n + "'");
+            }
+            throw this.syntaxError("Expected '" + c + "' and instead saw ''");
+        }
+        return n;
+    }
+
+
+    /**
+     * Get the next n characters.
+     *
+     * @param n     The number of characters to take.
+     * @return      A string of n characters.
+     * @throws JSONException
+     *   Substring bounds error if there are not
+     *   n characters remaining in the source string.
+     */
+    public String next(int n) throws JSONException {
+        if (n == 0) {
+            return "";
+        }
+
+        char[] chars = new char[n];
+        int pos = 0;
+
+        while (pos < n) {
+            chars[pos] = this.next();
+            if (this.end()) {
+                throw this.syntaxError("Substring bounds error");
+            }
+            pos += 1;
+        }
+        return new String(chars);
+    }
+
+
+    /**
+     * Get the next char in the string, skipping whitespace.
+     * @throws JSONException Thrown if there is an error reading the source string.
+     * @return  A character, or 0 if there are no more characters.
+     */
+    public char nextClean() throws JSONException {
+        for (;;) {
+            char c = this.next();
+            if (c == 0 || c > ' ') {
+                return c;
+            }
+        }
+    }
+
+
+    /**
+     * Return the characters up to the next close quote character.
+     * Backslash processing is done. The formal JSON format does not
+     * allow strings in single quotes, but an implementation is allowed to
+     * accept them.
+     * @param quote The quoting character, either
+     *      <code>"</code>&nbsp;<small>(double quote)</small> or
+     *      <code>'</code>&nbsp;<small>(single quote)</small>.
+     * @return      A String.
+     * @throws JSONException Unterminated string.
+     */
+    public String nextString(char quote) throws JSONException {
+        char c;
+        StringBuilder sb = new StringBuilder();
+        for (;;) {
+            c = this.next();
+            switch (c) {
+            case 0:
+            case '\n':
+            case '\r':
+                throw this.syntaxError("Unterminated string");
+            case '\\':
+                c = this.next();
+                switch (c) {
+                case 'b':
+                    sb.append('\b');
+                    break;
+                case 't':
+                    sb.append('\t');
+                    break;
+                case 'n':
+                    sb.append('\n');
+                    break;
+                case 'f':
+                    sb.append('\f');
+                    break;
+                case 'r':
+                    sb.append('\r');
+                    break;
+                case 'u':
+                    try {
+                        sb.append((char)Integer.parseInt(this.next(4), 16));
+                    } catch (NumberFormatException e) {
+                        throw this.syntaxError("Illegal escape.", e);
+                    }
+                    break;
+                case '"':
+                case '\'':
+                case '\\':
+                case '/':
+                    sb.append(c);
+                    break;
+                default:
+                    throw this.syntaxError("Illegal escape.");
+                }
+                break;
+            default:
+                if (c == quote) {
+                    return sb.toString();
+                }
+                sb.append(c);
+            }
+        }
+    }
+
+
+    /**
+     * Get the text up but not including the specified character or the
+     * end of line, whichever comes first.
+     * @param  delimiter A delimiter character.
+     * @return   A string.
+     * @throws JSONException Thrown if there is an error while searching
+     *  for the delimiter
+     */
+    public String nextTo(char delimiter) throws JSONException {
+        StringBuilder sb = new StringBuilder();
+        for (;;) {
+            char c = this.next();
+            if (c == delimiter || c == 0 || c == '\n' || c == '\r') {
+                if (c != 0) {
+                    this.back();
+                }
+                return sb.toString().trim();
+            }
+            sb.append(c);
+        }
+    }
+
+
+    /**
+     * Get the text up but not including one of the specified delimiter
+     * characters or the end of line, whichever comes first.
+     * @param delimiters A set of delimiter characters.
+     * @return A string, trimmed.
+     * @throws JSONException Thrown if there is an error while searching
+     *  for the delimiter
+     */
+    public String nextTo(String delimiters) throws JSONException {
+        char c;
+        StringBuilder sb = new StringBuilder();
+        for (;;) {
+            c = this.next();
+            if (delimiters.indexOf(c) >= 0 || c == 0 ||
+                    c == '\n' || c == '\r') {
+                if (c != 0) {
+                    this.back();
+                }
+                return sb.toString().trim();
+            }
+            sb.append(c);
+        }
+    }
+
+
+    /**
+     * Get the next value. The value can be a Boolean, Double, Integer,
+     * JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object.
+     * @throws JSONException If syntax error.
+     *
+     * @return An object.
+     */
+    public Object nextValue() throws JSONException {
+        char c = this.nextClean();
+        String string;
+
+        switch (c) {
+        case '"':
+        case '\'':
+            return this.nextString(c);
+        case '{':
+            this.back();
+            return new JSONObject(this);
+        case '[':
+            this.back();
+            return new JSONArray(this);
+        }
+
+        /*
+         * Handle unquoted text. This could be the values true, false, or
+         * null, or it can be a number. An implementation (such as this one)
+         * is allowed to also accept non-standard forms.
+         *
+         * Accumulate characters until we reach the end of the text or a
+         * formatting character.
+         */
+
+        StringBuilder sb = new StringBuilder();
+        while (c >= ' ' && ",:]}/\\\"[{;=#".indexOf(c) < 0) {
+            sb.append(c);
+            c = this.next();
+        }
+        this.back();
+
+        string = sb.toString().trim();
+        if ("".equals(string)) {
+            throw this.syntaxError("Missing value");
+        }
+        return JSONObject.stringToValue(string);
+    }
+
+
+    /**
+     * Skip characters until the next character is the requested character.
+     * If the requested character is not found, no characters are skipped.
+     * @param to A character to skip to.
+     * @return The requested character, or zero if the requested character
+     * is not found.
+     * @throws JSONException Thrown if there is an error while searching
+     *  for the to character
+     */
+    public char skipTo(char to) throws JSONException {
+        char c;
+        try {
+            long startIndex = this.index;
+            long startCharacter = this.character;
+            long startLine = this.line;
+            this.reader.mark(1000000);
+            do {
+                c = this.next();
+                if (c == 0) {
+                    // in some readers, reset() may throw an exception if
+                    // the remaining portion of the input is greater than
+                    // the mark size (1,000,000 above).
+                    this.reader.reset();
+                    this.index = startIndex;
+                    this.character = startCharacter;
+                    this.line = startLine;
+                    return 0;
+                }
+            } while (c != to);
+            this.reader.mark(1);
+        } catch (IOException exception) {
+            throw new JSONException(exception);
+        }
+        this.back();
+        return c;
+    }
+
+    /**
+     * Make a JSONException to signal a syntax error.
+     *
+     * @param message The error message.
+     * @return  A JSONException object, suitable for throwing
+     */
+    public JSONException syntaxError(String message) {
+        return new JSONException(message + this.toString());
+    }
+
+    /**
+     * Make a JSONException to signal a syntax error.
+     *
+     * @param message The error message.
+     * @param causedBy The throwable that caused the error.
+     * @return  A JSONException object, suitable for throwing
+     */
+    public JSONException syntaxError(String message, Throwable causedBy) {
+        return new JSONException(message + this.toString(), causedBy);
+    }
+
+    /**
+     * Make a printable string of this JSONTokener.
+     *
+     * @return " at {index} [character {character} line {line}]"
+     */
+    @Override
+    public String toString() {
+        return " at " + this.index + " [character " + this.character + " line " +
+                this.line + "]";
+    }
+}

RhasspyIntentLauncher/src/com/jens/rhasspy/lib/JSONWriter.java

@@ -0,0 +1,418 @@
+package com.jens.rhasspy.lib;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.util.Collection;
+import java.util.Map;
+
+/*
+Copyright (c) 2006 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * JSONWriter provides a quick and convenient way of producing JSON text.
+ * The texts produced strictly conform to JSON syntax rules. No whitespace is
+ * added, so the results are ready for transmission or storage. Each instance of
+ * JSONWriter can produce one JSON text.
+ * <p>
+ * A JSONWriter instance provides a <code>value</code> method for appending
+ * values to the
+ * text, and a <code>key</code>
+ * method for adding keys before values in objects. There are <code>array</code>
+ * and <code>endArray</code> methods that make and bound array values, and
+ * <code>object</code> and <code>endObject</code> methods which make and bound
+ * object values. All of these methods return the JSONWriter instance,
+ * permitting a cascade style. For example, <pre>
+ * new JSONWriter(myWriter)
+ *     .object()
+ *         .key("JSON")
+ *         .value("Hello, World!")
+ *     .endObject();</pre> which writes <pre>
+ * {"JSON":"Hello, World!"}</pre>
+ * <p>
+ * The first method called must be <code>array</code> or <code>object</code>.
+ * There are no methods for adding commas or colons. JSONWriter adds them for
+ * you. Objects and arrays can be nested up to 200 levels deep.
+ * <p>
+ * This can sometimes be easier than using a JSONObject to build a string.
+ * @author JSON.org
+ * @version 2016-08-08
+ */
+public class JSONWriter {
+    private static final int maxdepth = 200;
+
+    /**
+     * The comma flag determines if a comma should be output before the next
+     * value.
+     */
+    private boolean comma;
+
+    /**
+     * The current mode. Values:
+     * 'a' (array),
+     * 'd' (done),
+     * 'i' (initial),
+     * 'k' (key),
+     * 'o' (object).
+     */
+    protected char mode;
+
+    /**
+     * The object/array stack.
+     */
+    private final JSONObject stack[];
+
+    /**
+     * The stack top index. A value of 0 indicates that the stack is empty.
+     */
+    private int top;
+
+    /**
+     * The writer that will receive the output.
+     */
+    protected Appendable writer;
+
+    /**
+     * Make a fresh JSONWriter. It can be used to build one JSON text.
+     */
+    public JSONWriter(Appendable w) {
+        this.comma = false;
+        this.mode = 'i';
+        this.stack = new JSONObject[maxdepth];
+        this.top = 0;
+        this.writer = w;
+    }
+
+    /**
+     * Append a value.
+     * @param string A string value.
+     * @return this
+     * @throws JSONException If the value is out of sequence.
+     */
+    private JSONWriter append(String string) throws JSONException {
+        if (string == null) {
+            throw new JSONException("Null pointer");
+        }
+        if (this.mode == 'o' || this.mode == 'a') {
+            try {
+                if (this.comma && this.mode == 'a') {
+                    this.writer.append(',');
+                }
+                this.writer.append(string);
+            } catch (IOException e) {
+            	// Android as of API 25 does not support this exception constructor
+            	// however we won't worry about it. If an exception is happening here
+            	// it will just throw a "Method not found" exception instead.
+                throw new JSONException(e);
+            }
+            if (this.mode == 'o') {
+                this.mode = 'k';
+            }
+            this.comma = true;
+            return this;
+        }
+        throw new JSONException("Value out of sequence.");
+    }
+
+    /**
+     * Begin appending a new array. All values until the balancing
+     * <code>endArray</code> will be appended to this array. The
+     * <code>endArray</code> method must be called to mark the array's end.
+     * @return this
+     * @throws JSONException If the nesting is too deep, or if the object is
+     * started in the wrong place (for example as a key or after the end of the
+     * outermost array or object).
+     */
+    public JSONWriter array() throws JSONException {
+        if (this.mode == 'i' || this.mode == 'o' || this.mode == 'a') {
+            this.push(null);
+            this.append("[");
+            this.comma = false;
+            return this;
+        }
+        throw new JSONException("Misplaced array.");
+    }
+
+    /**
+     * End something.
+     * @param m Mode
+     * @param c Closing character
+     * @return this
+     * @throws JSONException If unbalanced.
+     */
+    private JSONWriter end(char m, char c) throws JSONException {
+        if (this.mode != m) {
+            throw new JSONException(m == 'a'
+                ? "Misplaced endArray."
+                : "Misplaced endObject.");
+        }
+        this.pop(m);
+        try {
+            this.writer.append(c);
+        } catch (IOException e) {
+        	// Android as of API 25 does not support this exception constructor
+        	// however we won't worry about it. If an exception is happening here
+        	// it will just throw a "Method not found" exception instead.
+            throw new JSONException(e);
+        }
+        this.comma = true;
+        return this;
+    }
+
+    /**
+     * End an array. This method most be called to balance calls to
+     * <code>array</code>.
+     * @return this
+     * @throws JSONException If incorrectly nested.
+     */
+    public JSONWriter endArray() throws JSONException {
+        return this.end('a', ']');
+    }
+
+    /**
+     * End an object. This method most be called to balance calls to
+     * <code>object</code>.
+     * @return this
+     * @throws JSONException If incorrectly nested.
+     */
+    public JSONWriter endObject() throws JSONException {
+        return this.end('k', '}');
+    }
+
+    /**
+     * Append a key. The key will be associated with the next value. In an
+     * object, every value must be preceded by a key.
+     * @param string A key string.
+     * @return this
+     * @throws JSONException If the key is out of place. For example, keys
+     *  do not belong in arrays or if the key is null.
+     */
+    public JSONWriter key(String string) throws JSONException {
+        if (string == null) {
+            throw new JSONException("Null key.");
+        }
+        if (this.mode == 'k') {
+            try {
+                JSONObject topObject = this.stack[this.top - 1];
+                // don't use the built in putOnce method to maintain Android support
+				if(topObject.has(string)) {
+					throw new JSONException("Duplicate key \"" + string + "\"");
+				}
+                topObject.put(string, true);
+                if (this.comma) {
+                    this.writer.append(',');
+                }
+                this.writer.append(JSONObject.quote(string));
+                this.writer.append(':');
+                this.comma = false;
+                this.mode = 'o';
+                return this;
+            } catch (IOException e) {
+            	// Android as of API 25 does not support this exception constructor
+            	// however we won't worry about it. If an exception is happening here
+            	// it will just throw a "Method not found" exception instead.
+                throw new JSONException(e);
+            }
+        }
+        throw new JSONException("Misplaced key.");
+    }
+
+
+    /**
+     * Begin appending a new object. All keys and values until the balancing
+     * <code>endObject</code> will be appended to this object. The
+     * <code>endObject</code> method must be called to mark the object's end.
+     * @return this
+     * @throws JSONException If the nesting is too deep, or if the object is
+     * started in the wrong place (for example as a key or after the end of the
+     * outermost array or object).
+     */
+    public JSONWriter object() throws JSONException {
+        if (this.mode == 'i') {
+            this.mode = 'o';
+        }
+        if (this.mode == 'o' || this.mode == 'a') {
+            this.append("{");
+            this.push(new JSONObject());
+            this.comma = false;
+            return this;
+        }
+        throw new JSONException("Misplaced object.");
+
+    }
+
+
+    /**
+     * Pop an array or object scope.
+     * @param c The scope to close.
+     * @throws JSONException If nesting is wrong.
+     */
+    private void pop(char c) throws JSONException {
+        if (this.top <= 0) {
+            throw new JSONException("Nesting error.");
+        }
+        char m = this.stack[this.top - 1] == null ? 'a' : 'k';
+        if (m != c) {
+            throw new JSONException("Nesting error.");
+        }
+        this.top -= 1;
+        this.mode = this.top == 0
+            ? 'd'
+            : this.stack[this.top - 1] == null
+            ? 'a'
+            : 'k';
+    }
+
+    /**
+     * Push an array or object scope.
+     * @param jo The scope to open.
+     * @throws JSONException If nesting is too deep.
+     */
+    private void push(JSONObject jo) throws JSONException {
+        if (this.top >= maxdepth) {
+            throw new JSONException("Nesting too deep.");
+        }
+        this.stack[this.top] = jo;
+        this.mode = jo == null ? 'a' : 'k';
+        this.top += 1;
+    }
+
+    /**
+     * Make a JSON text of an Object value. If the object has an
+     * value.toJSONString() method, then that method will be used to produce the
+     * JSON text. The method is required to produce a strictly conforming text.
+     * If the object does not contain a toJSONString method (which is the most
+     * common case), then a text will be produced by other means. If the value
+     * is an array or Collection, then a JSONArray will be made from it and its
+     * toJSONString method will be called. If the value is a MAP, then a
+     * JSONObject will be made from it and its toJSONString method will be
+     * called. Otherwise, the value's toString method will be called, and the
+     * result will be quoted.
+     *
+     * <p>
+     * Warning: This method assumes that the data structure is acyclical.
+     *
+     * @param value
+     *            The value to be serialized.
+     * @return a printable, displayable, transmittable representation of the
+     *         object, beginning with <code>{</code>&nbsp;<small>(left
+     *         brace)</small> and ending with <code>}</code>&nbsp;<small>(right
+     *         brace)</small>.
+     * @throws JSONException
+     *             If the value is or contains an invalid number.
+     */
+    public static String valueToString(Object value) throws JSONException {
+        if (value == null || value.equals(null)) {
+            return "null";
+        }
+        if (value instanceof JSONString) {
+            Object object;
+            try {
+                object = ((JSONString) value).toJSONString();
+            } catch (Exception e) {
+                throw new JSONException(e);
+            }
+            if (object instanceof String) {
+                return (String) object;
+            }
+            throw new JSONException("Bad value from toJSONString: " + object);
+        }
+        if (value instanceof Number) {
+            // not all Numbers may match actual JSON Numbers. i.e. Fractions or Complex
+            final String numberAsString = JSONObject.numberToString((Number) value);
+            try {
+                // Use the BigDecimal constructor for it's parser to validate the format.
+                @SuppressWarnings("unused")
+                BigDecimal unused = new BigDecimal(numberAsString);
+                // Close enough to a JSON number that we will return it unquoted
+                return numberAsString;
+            } catch (NumberFormatException ex){
+                // The Number value is not a valid JSON number.
+                // Instead we will quote it as a string
+                return JSONObject.quote(numberAsString);
+            }
+        }
+        if (value instanceof Boolean || value instanceof JSONObject
+                || value instanceof JSONArray) {
+            return value.toString();
+        }
+        if (value instanceof Map) {
+            Map<?, ?> map = (Map<?, ?>) value;
+            return new JSONObject(map).toString();
+        }
+        if (value instanceof Collection) {
+            Collection<?> coll = (Collection<?>) value;
+            return new JSONArray(coll).toString();
+        }
+        if (value.getClass().isArray()) {
+            return new JSONArray(value).toString();
+        }
+        if(value instanceof Enum<?>){
+            return JSONObject.quote(((Enum<?>)value).name());
+        }
+        return JSONObject.quote(value.toString());
+    }
+
+    /**
+     * Append either the value <code>true</code> or the value
+     * <code>false</code>.
+     * @param b A boolean.
+     * @return this
+     * @throws JSONException
+     */
+    public JSONWriter value(boolean b) throws JSONException {
+        return this.append(b ? "true" : "false");
+    }
+
+    /**
+     * Append a double value.
+     * @param d A double.
+     * @return this
+     * @throws JSONException If the number is not finite.
+     */
+    public JSONWriter value(double d) throws JSONException {
+        return this.value(Double.valueOf(d));
+    }
+
+    /**
+     * Append a long value.
+     * @param l A long.
+     * @return this
+     * @throws JSONException
+     */
+    public JSONWriter value(long l) throws JSONException {
+        return this.append(Long.toString(l))