--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+
+public class CameraCallback_CallbackSkeleton implements CameraCallback {
+
+ private CameraCallback mainObj;
+ private int objectId = 0;
+ private String callbackAddress;
+ private static int objIdCnt = 0;
+ private IoTRMICall rmiCall;
+ private int[] ports;
+
+
+
+ public CameraCallback_CallbackSkeleton(CameraCallback _mainObj, String _callbackAddress, int _objectId) throws Exception {
+ callbackAddress = _callbackAddress;
+ mainObj = _mainObj;
+ objectId = _objectId;
+ }
+
+ public void newCameraFrameAvailable(CameraSmart _camera) {
+ mainObj.newCameraFrameAvailable(_camera);
+ }
+
+ public void ___regCB(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int[].class, String.class, int.class },new Class<?>[] { null, null, null });
+ ports = (int[]) paramObj[0];
+ rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], ports[1]);
+ }
+
+ public void ___newCameraFrameAvailable(IoTRMIObject rmiObj) {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class },
+ new Class<?>[] { null });
+ try {
+ CameraSmart stub0 = new CameraSmart_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);
+ objIdCnt++;
+ newCameraFrameAvailable(stub0);
+ } catch(Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception from callback object instantiation!");
+ }
+ }
+
+ public void invokeMethod(IoTRMIObject rmiObj) throws IOException {
+ int methodId = rmiObj.getMethodId();
+ switch (methodId) {
+ case 0: ___newCameraFrameAvailable(rmiObj); break;
+ case -9999: ___regCB(rmiObj); break;
+ default:
+ throw new Error("Method Id " + methodId + " not recognized!");
+ }
+ }
+
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+
+public class CameraSmartCallback_CallbackStub implements CameraSmartCallback {
+
+ private IoTRMICall rmiCall;
+ private String callbackAddress;
+ private int[] ports;
+
+ private int objectId = 0;
+ // Callback properties
+ private IoTRMIObject rmiObj;
+ List<Camera> listCallbackObj;
+ private static int objIdCnt = 0;
+ private final static int object0Id = 0; //CameraSmart
+ private static Integer[] object0Permission = { 8, 7, 9, 6, 2, 1, 4, 3, 0, 10, 5 };
+ private static List<Integer> set0Allowed;
+
+
+ public CameraSmartCallback_CallbackStub(IoTRMICall _rmiCall, String _callbackAddress, int _objectId, int[] _ports) throws Exception {
+ callbackAddress = _callbackAddress;
+ objectId = _objectId;
+ rmiCall = _rmiCall;
+ ports = _ports;
+ set0Allowed = new ArrayList<Integer>(Arrays.asList(object0Permission));
+ listCallbackObj = new ArrayList<Camera>();
+ ___initCallBack();
+ }
+
+ public void newCameraFrameAvailable(Camera _camera) {
+ try {
+ Camera_CallbackSkeleton skel0 = new Camera_CallbackSkeleton(_camera, callbackAddress, objIdCnt++);
+ listCallbackObj.add(skel0);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception when generating skeleton objects!");
+ }
+
+ int methodId = 0;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { new Integer(1) };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void ___initCallBack() {
+ Thread thread = new Thread() {
+ public void run() {
+ try {
+ rmiObj = new IoTRMIObject(ports[1]);
+ while (true) {
+ byte[] method = rmiObj.getMethodBytes();
+ int methodId = IoTRMIObject.getMethodId(method);
+ if (!set0Allowed.contains(methodId)) {
+ throw new Error("Callback object for Camera is not allowed to access method: " + methodId);
+ }
+ int objId = IoTRMIObject.getObjectId(method);
+ Camera_CallbackSkeleton skel = (Camera_CallbackSkeleton) listCallbackObj.get(objId);
+ if (skel != null) {
+ skel.invokeMethod(rmiObj);
+ } else {
+ throw new Error("Camera: Object with Id " + objId + " not found!");
+ }
+ }
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Error instantiating class Camera_CallbackSkeleton!");
+ }
+ }
+ };
+ thread.start();
+
+ int methodId = -9999;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int[].class, String.class, int.class };
+ Object[] paramObj = new Object[] { ports, callbackAddress, 0 };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+
+public class CameraSmartCallback_Stub implements CameraSmartCallback {
+
+ private IoTRMICall rmiCall;
+ private String callbackAddress;
+ private int[] ports;
+
+ private final static int objectId = 0;
+ // Callback properties
+ private IoTRMIObject rmiObj;
+ List<Camera> listCallbackObj;
+ private static int objIdCnt = 0;
+ private final static int object0Id = 0; //CameraSmart
+ private static Integer[] object0Permission = { 8, 7, 9, 6, 2, 1, 4, 3, 0, 10, 5 };
+ private static List<Integer> set0Allowed;
+
+
+ public CameraSmartCallback_Stub(int _port, String _skeletonAddress, String _callbackAddress, int _rev, int[] _ports) throws Exception {
+ callbackAddress = _callbackAddress;
+ ports = _ports;
+ rmiCall = new IoTRMICall(_port, _skeletonAddress, _rev);
+ set0Allowed = new ArrayList<Integer>(Arrays.asList(object0Permission));
+ listCallbackObj = new ArrayList<Camera>();
+ ___initCallBack();
+ }
+
+ public void newCameraFrameAvailable(Camera _camera) {
+ try {
+ Camera_CallbackSkeleton skel0 = new Camera_CallbackSkeleton(_camera, callbackAddress, objIdCnt++);
+ listCallbackObj.add(skel0);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception when generating skeleton objects!");
+ }
+
+ int methodId = 0;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { new Integer(1) };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void ___initCallBack() {
+ Thread thread = new Thread() {
+ public void run() {
+ try {
+ rmiObj = new IoTRMIObject(ports[0]);
+ while (true) {
+ byte[] method = rmiObj.getMethodBytes();
+ int methodId = IoTRMIObject.getMethodId(method);
+ if (!set0Allowed.contains(methodId)) {
+ throw new Error("Callback object for Camera is not allowed to access method: " + methodId);
+ }
+ int objId = IoTRMIObject.getObjectId(method);
+ Camera_CallbackSkeleton skel = (Camera_CallbackSkeleton) listCallbackObj.get(objId);
+ if (skel != null) {
+ skel.invokeMethod(rmiObj);
+ } else {
+ throw new Error("Camera: Object with Id " + objId + " not found!");
+ }
+ }
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Error instantiating class Camera_CallbackSkeleton!");
+ }
+ }
+ };
+ thread.start();
+
+ int methodId = -9999;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int[].class, String.class, int.class };
+ Object[] paramObj = new Object[] { ports, callbackAddress, 0 };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+
+public class CameraSmart_CallbackStub implements CameraSmart {
+
+ private IoTRMICall rmiCall;
+ private String callbackAddress;
+ private int[] ports;
+
+ private int objectId = 0;
+ // Callback properties
+ private IoTRMIObject rmiObj;
+ List<CameraCallback> listCallbackObj;
+ private static int objIdCnt = 0;
+ private final static int object0Id = 0; //CameraSmartCallback
+ private static Integer[] object0Permission = { 0 };
+ private static List<Integer> set0Allowed;
+
+
+ public CameraSmart_CallbackStub(IoTRMICall _rmiCall, String _callbackAddress, int _objectId, int[] _ports) throws Exception {
+ callbackAddress = _callbackAddress;
+ objectId = _objectId;
+ rmiCall = _rmiCall;
+ ports = _ports;
+ set0Allowed = new ArrayList<Integer>(Arrays.asList(object0Permission));
+ listCallbackObj = new ArrayList<CameraCallback>();
+ ___initCallBack();
+ }
+
+ public int getMaxFPS() {
+ int methodId = 8;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public boolean setFPS(int _fps) {
+ int methodId = 7;
+ Class<?> retType = boolean.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { _fps };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (boolean)retObj;
+ }
+
+ public int getMinFPS() {
+ int methodId = 9;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public boolean setResolution(Resolution _res) {
+ int methodId = 6;
+ Class<?> retType = boolean.class;
+ int paramEnum0[] = new int[1];
+ paramEnum0[0] = _res.ordinal();
+ Class<?>[] paramCls = new Class<?>[] { int[].class };
+ Object[] paramObj = new Object[] { paramEnum0 };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (boolean)retObj;
+ }
+
+ public void stop() {
+ int methodId = 2;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void start() {
+ int methodId = 1;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public long getTimestamp() {
+ int methodId = 4;
+ Class<?> retType = long.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (long)retObj;
+ }
+
+ public byte[] getLatestFrame() {
+ int methodId = 3;
+ Class<?> retType = byte[].class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (byte[])retObj;
+ }
+
+ public void init() {
+ int methodId = 0;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void registerCallback(CameraCallback _callbackTo) {
+ try {
+ CameraCallback_CallbackSkeleton skel0 = new CameraCallback_CallbackSkeleton(_callbackTo, callbackAddress, objIdCnt++);
+ listCallbackObj.add(skel0);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception when generating skeleton objects!");
+ }
+
+ int methodId = 10;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { new Integer(1) };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void ___initCallBack() {
+ Thread thread = new Thread() {
+ public void run() {
+ try {
+ rmiObj = new IoTRMIObject(ports[1]);
+ while (true) {
+ byte[] method = rmiObj.getMethodBytes();
+ int methodId = IoTRMIObject.getMethodId(method);
+ if (!set0Allowed.contains(methodId)) {
+ throw new Error("Callback object for CameraCallback is not allowed to access method: " + methodId);
+ }
+ int objId = IoTRMIObject.getObjectId(method);
+ CameraCallback_CallbackSkeleton skel = (CameraCallback_CallbackSkeleton) listCallbackObj.get(objId);
+ if (skel != null) {
+ skel.invokeMethod(rmiObj);
+ } else {
+ throw new Error("CameraCallback: Object with Id " + objId + " not found!");
+ }
+ }
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Error instantiating class CameraCallback_CallbackSkeleton!");
+ }
+ }
+ };
+ thread.start();
+
+ int methodId = -9998;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int[].class, String.class, int.class };
+ Object[] paramObj = new Object[] { ports, callbackAddress, 0 };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public List<Resolution> getSupportedResolutions() {
+ int methodId = 5;
+ Class<?> retType = int[].class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ int[] retEnum = (int[]) retObj;
+ Resolution[] enumVals = Resolution.values();
+ int retLen = retEnum.length;
+ List<Resolution> enumRetVal = new ArrayList<Resolution>();
+ for (int i = 0; i < retLen; i++) {
+ enumRetVal.add(enumVals[retEnum[i]]);
+ }
+ return enumRetVal;
+ }
+
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+
+public class CameraSmart_Stub implements CameraSmart {
+
+ private IoTRMICall rmiCall;
+ private String callbackAddress;
+ private int[] ports;
+
+ private final static int objectId = 0;
+ // Callback properties
+ private IoTRMIObject rmiObj;
+ List<CameraCallback> listCallbackObj;
+ private static int objIdCnt = 0;
+ private final static int object0Id = 0; //CameraSmartCallback
+ private static Integer[] object0Permission = { 0 };
+ private static List<Integer> set0Allowed;
+
+
+ public CameraSmart_Stub(int _port, String _skeletonAddress, String _callbackAddress, int _rev, int[] _ports) throws Exception {
+ callbackAddress = _callbackAddress;
+ ports = _ports;
+ rmiCall = new IoTRMICall(_port, _skeletonAddress, _rev);
+ set0Allowed = new ArrayList<Integer>(Arrays.asList(object0Permission));
+ listCallbackObj = new ArrayList<CameraCallback>();
+ ___initCallBack();
+ }
+
+ public int getMaxFPS() {
+ int methodId = 8;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public boolean setFPS(int _fps) {
+ int methodId = 7;
+ Class<?> retType = boolean.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { _fps };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (boolean)retObj;
+ }
+
+ public int getMinFPS() {
+ int methodId = 9;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public boolean setResolution(Resolution _res) {
+ int methodId = 6;
+ Class<?> retType = boolean.class;
+ int paramEnum0[] = new int[1];
+ paramEnum0[0] = _res.ordinal();
+ Class<?>[] paramCls = new Class<?>[] { int[].class };
+ Object[] paramObj = new Object[] { paramEnum0 };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (boolean)retObj;
+ }
+
+ public void stop() {
+ int methodId = 2;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void start() {
+ int methodId = 1;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public long getTimestamp() {
+ int methodId = 4;
+ Class<?> retType = long.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (long)retObj;
+ }
+
+ public byte[] getLatestFrame() {
+ int methodId = 3;
+ Class<?> retType = byte[].class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (byte[])retObj;
+ }
+
+ public void init() {
+ int methodId = 0;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void registerCallback(CameraCallback _callbackTo) {
+ try {
+ CameraCallback_CallbackSkeleton skel0 = new CameraCallback_CallbackSkeleton(_callbackTo, callbackAddress, objIdCnt++);
+ listCallbackObj.add(skel0);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception when generating skeleton objects!");
+ }
+
+ int methodId = 10;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { new Integer(1) };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void ___initCallBack() {
+ Thread thread = new Thread() {
+ public void run() {
+ try {
+ rmiObj = new IoTRMIObject(ports[0]);
+ while (true) {
+ byte[] method = rmiObj.getMethodBytes();
+ int methodId = IoTRMIObject.getMethodId(method);
+ if (!set0Allowed.contains(methodId)) {
+ throw new Error("Callback object for CameraCallback is not allowed to access method: " + methodId);
+ }
+ int objId = IoTRMIObject.getObjectId(method);
+ CameraCallback_CallbackSkeleton skel = (CameraCallback_CallbackSkeleton) listCallbackObj.get(objId);
+ if (skel != null) {
+ skel.invokeMethod(rmiObj);
+ } else {
+ throw new Error("CameraCallback: Object with Id " + objId + " not found!");
+ }
+ }
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Error instantiating class CameraCallback_CallbackSkeleton!");
+ }
+ }
+ };
+ thread.start();
+
+ int methodId = -9998;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int[].class, String.class, int.class };
+ Object[] paramObj = new Object[] { ports, callbackAddress, 0 };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public List<Resolution> getSupportedResolutions() {
+ int methodId = 5;
+ Class<?> retType = int[].class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ int[] retEnum = (int[]) retObj;
+ Resolution[] enumVals = Resolution.values();
+ int retLen = retEnum.length;
+ List<Resolution> enumRetVal = new ArrayList<Resolution>();
+ for (int i = 0; i < retLen; i++) {
+ enumRetVal.add(enumVals[retEnum[i]]);
+ }
+ return enumRetVal;
+ }
+
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+
+public class Camera_CallbackSkeleton implements Camera {
+
+ private Camera mainObj;
+ private int objectId = 0;
+ private String callbackAddress;
+ private static int objIdCnt = 0;
+ private IoTRMICall rmiCall;
+ private int[] ports;
+
+
+
+ public Camera_CallbackSkeleton(Camera _mainObj, String _callbackAddress, int _objectId) throws Exception {
+ callbackAddress = _callbackAddress;
+ mainObj = _mainObj;
+ objectId = _objectId;
+ }
+
+ public void init() {
+ mainObj.init();
+ }
+
+ public void start() {
+ mainObj.start();
+ }
+
+ public void stop() {
+ mainObj.stop();
+ }
+
+ public byte[] getLatestFrame() {
+ return mainObj.getLatestFrame();
+ }
+
+ public long getTimestamp() {
+ return mainObj.getTimestamp();
+ }
+
+ public List<Resolution> getSupportedResolutions() {
+ return mainObj.getSupportedResolutions();
+ }
+
+ public boolean setResolution(Resolution _res) {
+ return mainObj.setResolution(_res);
+ }
+
+ public boolean setFPS(int _fps) {
+ return mainObj.setFPS(_fps);
+ }
+
+ public int getMaxFPS() {
+ return mainObj.getMaxFPS();
+ }
+
+ public int getMinFPS() {
+ return mainObj.getMinFPS();
+ }
+
+ public void registerCallback(CameraSmartCallback _callbackTo) {
+ mainObj.registerCallback(_callbackTo);
+ }
+
+ public void ___regCB(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int[].class, String.class, int.class },new Class<?>[] { null, null, null });
+ ports = (int[]) paramObj[0];
+ rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], ports[1]);
+ }
+
+ public void ___init(IoTRMIObject rmiObj) {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ init();
+ }
+
+ public void ___start(IoTRMIObject rmiObj) {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ start();
+ }
+
+ public void ___stop(IoTRMIObject rmiObj) {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ stop();
+ }
+
+ public void ___getLatestFrame(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getLatestFrame();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getTimestamp(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getTimestamp();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getSupportedResolutions(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ List<Resolution> retEnum = getSupportedResolutions();
+ int retLen = retEnum.size();
+ int[] retEnumVal = new int[retLen];
+ for (int i = 0; i < retLen; i++) {
+ retEnumVal[i] = retEnum.get(i).ordinal();
+ }
+ Object retObj = retEnumVal;
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___setResolution(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int[].class },
+ new Class<?>[] { null });
+ int paramInt0[] = (int[]) paramObj[0];
+ Resolution[] enumVals = Resolution.values();
+ Resolution paramEnum0 = enumVals[paramInt0[0]];
+ Object retObj = setResolution(paramEnum0);
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___setFPS(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class },
+ new Class<?>[] { null });
+ Object retObj = setFPS((int) paramObj[0]);
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getMaxFPS(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getMaxFPS();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getMinFPS(IoTRMIObject rmiObj) throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getMinFPS();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___registerCallback(IoTRMIObject rmiObj) {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class },
+ new Class<?>[] { null });
+ try {
+ CameraSmartCallback stub0 = new CameraSmartCallback_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);
+ objIdCnt++;
+ registerCallback(stub0);
+ } catch(Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception from callback object instantiation!");
+ }
+ }
+
+ public void invokeMethod(IoTRMIObject rmiObj) throws IOException {
+ int methodId = rmiObj.getMethodId();
+ switch (methodId) {
+ case 0: ___init(rmiObj); break;
+ case 1: ___start(rmiObj); break;
+ case 2: ___stop(rmiObj); break;
+ case 3: ___getLatestFrame(rmiObj); break;
+ case 4: ___getTimestamp(rmiObj); break;
+ case 5: ___getSupportedResolutions(rmiObj); break;
+ case 6: ___setResolution(rmiObj); break;
+ case 7: ___setFPS(rmiObj); break;
+ case 8: ___getMaxFPS(rmiObj); break;
+ case 9: ___getMinFPS(rmiObj); break;
+ case 10: ___registerCallback(rmiObj); break;
+ case -9998: ___regCB(rmiObj); break;
+ default:
+ throw new Error("Method Id " + methodId + " not recognized!");
+ }
+ }
+
+}
--- /dev/null
+package SmartLightsController;
+
+/** Class ColorTemperature to store the color and temperature data.
+ *
+ *
+ * @author Ali Younis <ayounis @ uci.edu>
+ * @version 1.0
+ * @since 2016-01-27
+ */
+public class ColorTemperature {
+
+ // As a percentage
+ public double hue;
+ public double saturation;
+ public double brightness;
+
+ // In Kelvin
+ public int temperature;
+
+ /** Constructor
+ */
+ public ColorTemperature() {
+ this.hue = 0;
+ this.saturation = 0;
+ this.brightness = 0;
+ this.temperature = 0;
+ }
+
+ /** Constructor
+ *
+ * @param _hue [double], Hue as a percentage.
+ * @param _saturation [double], Saturation as a percentage.
+ * @param _brightness [double], Brightness as a percentage.
+ * @param _temperature [double], Temperature as kelvin.
+ *
+ */
+ public ColorTemperature(double _hue, double _saturation, double _brightness, int _temperature) {
+ this.hue = _hue;
+ this.saturation = _saturation;
+ this.brightness = _brightness;
+ this.temperature = _temperature;
+ }
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.LightBulbSmart;
+
+public class LightBulbSmart_Stub implements LightBulbSmart {
+
+ private IoTRMICall rmiCall;
+ private String callbackAddress;
+ private int[] ports;
+
+ private final static int objectId = 0;
+
+
+ public LightBulbSmart_Stub(int _port, String _skeletonAddress, String _callbackAddress, int _rev, int[] _ports) throws Exception {
+ callbackAddress = _callbackAddress;
+ ports = _ports;
+ rmiCall = new IoTRMICall(_port, _skeletonAddress, _rev);
+ }
+
+ public void turnOn() {
+ int methodId = 2;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public double getBrightnessRangeLowerBound() {
+ int methodId = 10;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public void turnOff() {
+ int methodId = 1;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public boolean getState() {
+ int methodId = 3;
+ Class<?> retType = boolean.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (boolean)retObj;
+ }
+
+ public double getBrightnessRangeUpperBound() {
+ int methodId = 11;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public double getSaturation() {
+ int methodId = 8;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public double getHueRangeLowerBound() {
+ int methodId = 12;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public double getHue() {
+ int methodId = 7;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public double getHueRangeUpperBound() {
+ int methodId = 13;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public int getTemperature() {
+ int methodId = 9;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public double getBrightness() {
+ int methodId = 6;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public int getTemperatureRangeLowerBound() {
+ int methodId = 16;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public int getTemperatureRangeUpperBound() {
+ int methodId = 17;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+ public void setColor(double _hue, double _saturation, double _brightness) {
+ int methodId = 4;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { double.class, double.class, double.class };
+ Object[] paramObj = new Object[] { _hue, _saturation, _brightness };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public void init() {
+ int methodId = 0;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+ public double getSaturationRangeLowerBound() {
+ int methodId = 14;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public double getSaturationRangeUpperBound() {
+ int methodId = 15;
+ Class<?> retType = double.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (double)retObj;
+ }
+
+ public void setTemperature(int _temperature) {
+ int methodId = 5;
+ Class<?> retType = void.class;
+ Class<?>[] paramCls = new Class<?>[] { int.class };
+ Object[] paramObj = new Object[] { _temperature };
+ rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ }
+
+}
--- /dev/null
+BASE = ../..
+
+include $(BASE)/common.mk
+
+BOOFDIR := ../libs/boofcv_libs
+BOOFJARS := $(BOOFDIR)/BoofCV-feature-0.21.jar:$(BOOFDIR)/BoofCV-io-0.21.jar:$(BOOFDIR)/BoofCV-visualize-0.21.jar:$(BOOFDIR)/BoofCV-ip-0.21.jar:$(CHECKERJARS)
+
+JFLAGS = -d $(BIN_DIR) -cp $(BOOFJARS):$(BIN_DIR):.
+JARFLAGS = cf
+
+all: smartlights
+
+PHONY += smartlights
+smartlights:
+ $(JAVAC) $(JFLAGS) *.java
+ cp SmartLightsController.config $(BIN_DIR)/SmartLightsController
+ cd $(BIN_DIR)/SmartLightsController; $(JAR) $(JARFLAGS) SmartLightsController.jar ../SmartLightsController/SmartLightsController*.class ../SmartLightsController/ColorTemperature*.class ../SmartLightsController/MotionDetection*.class ../iotcode/interfaces/Camera*.class ../iotcode/interfaces/Room*.class ../iotcode/interfaces/LightBulb*.class
+
+.PHONY: $(PHONY)
--- /dev/null
+package SmartLightsController;
+
+// IoT packages
+import iotcode.annotation.*;
+import iotcode.interfaces.*;
+
+// BoofCv packages
+import boofcv.alg.background.BackgroundModelStationary;
+import boofcv.factory.background.ConfigBackgroundGaussian;
+import boofcv.factory.background.FactoryBackgroundModel;
+import boofcv.gui.binary.VisualizeBinaryData;
+import boofcv.gui.image.ImageGridPanel;
+import boofcv.gui.image.ShowImages;
+import boofcv.io.MediaManager;
+import boofcv.io.UtilIO;
+import boofcv.io.image.SimpleImageSequence;
+import boofcv.io.image.ConvertBufferedImage;
+import boofcv.io.wrapper.DefaultMediaManager;
+import boofcv.struct.image.ImageBase;
+import boofcv.struct.image.ImageFloat32;
+import boofcv.struct.image.ImageType;
+import boofcv.struct.image.ImageUInt8;
+import boofcv.alg.filter.blur.BlurImageOps;
+
+
+// Standard Java Packages
+import java.awt.image.BufferedImage;
+import java.util.Date;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.awt.image.ColorModel;
+import java.awt.image.WritableRaster;
+import java.util.List;
+import java.util.ArrayList;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import javax.imageio.ImageIO;
+
+// RMI Packages
+import java.rmi.RemoteException;
+
+// For testing
+import java.net.*;
+
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+import java.util.Iterator;
+
+// Checker annotations
+//import iotchecker.qual.*;
+
+/** Class MotionDetection to do motion detection using images
+ *
+ *
+ * @author Ali Younis <ayounis @ uci.edu>
+ * @version 1.0
+ * @since 2016-03-21
+ */
+class MotionDetection implements CameraCallback {
+
+ // Define Like variables
+ private static boolean DO_GRAPHICAL_USER_INTERFACE = false;
+
+ /*******************************************************************************************************************************************
+ **
+ ** Constants
+ **
+ *******************************************************************************************************************************************/
+ private final float MOTION_DETECTED_THRESHOLD_PERCENTAGE = 15;
+
+
+ /*******************************************************************************************************************************************
+ **
+ ** Variables
+ **
+ *******************************************************************************************************************************************/
+
+ // Timestamp buffer and locks needed for that safety on that buffer
+ // This is the buffer for post-detection algorithm use
+ private Date timestampOfLastMotion = null;
+ private ReadWriteLock timestampReadWriteLock = new ReentrantReadWriteLock();
+ private Lock timestampReadLock = timestampReadWriteLock.readLock();
+ private Lock timestampWriteLock = timestampReadWriteLock.writeLock();
+
+ // Flag for when new data is available and ready for processing
+ private AtomicBoolean newFrameAvailable = new AtomicBoolean(false);
+
+ // Flag for determining if motion has been detected and therefore
+ // the callbacks should be issued
+ private AtomicBoolean motionDetected = new AtomicBoolean(false);
+
+ // Image and timestamp buffers and locks needed for that safety on those buffers
+ // Timestamp buffer for pre-detection algorithm use
+ private BufferedImage latestImage = null;
+ private Date possibleDate = null;
+ private ReadWriteLock imageReadWriteLock = new ReentrantReadWriteLock();
+ private Lock imageReadLock = imageReadWriteLock.readLock();
+ private Lock imageWriteLock = imageReadWriteLock.writeLock();
+
+ // List of objects wishing to receive callbacks from this class.
+ private List<MotionDetectionCallback>
+ callbackList = new ArrayList<MotionDetectionCallback>();
+
+ // Variables to help with motion detection
+ private ConfigBackgroundGaussian configGaussian = null;
+ private BackgroundModelStationary backgroundDetector = null;
+ private ImageUInt8 segmented = null;
+ private ImageFloat32 newFrameFloat = null;
+
+ // counts the number of frames since a background image is added to algorithm
+ private int frameCounter = 0;
+
+
+
+ /*******************************************************************************************************************************************
+ **
+ ** Threads
+ **
+ *******************************************************************************************************************************************/
+ private Thread workThread = null;
+ private Thread callBackThread = null;
+
+ /*******************************************************************************************************************************************
+ **
+ ** GUI Stuff (Used Only for Testing)
+ **
+ *******************************************************************************************************************************************/
+ ImageGridPanel gui;
+
+ /** Constructor
+ *
+ * @param _threshold [float], Variable for gaussian background detector.
+ * @param _learnSpeed [float], Variable for gaussian background detector.
+ * @param _initialVariance [float], Variable for gaussian background detector.
+ * @param _minDifference [float], Variable for gaussian background detector.
+ *
+ */
+ public MotionDetection(float _threshold, float _learnSpeed, float _initialVariance, float _minDifference)
+ throws RemoteException {
+
+ // Configure the Gaussian model used for background detection
+ configGaussian = new ConfigBackgroundGaussian(_threshold, _learnSpeed);
+ configGaussian.initialVariance = _initialVariance;
+ configGaussian.minimumDifference = _minDifference;
+
+ // setup the background detector
+ ImageType imageType = ImageType.single(ImageFloat32.class);
+ backgroundDetector = FactoryBackgroundModel.stationaryGaussian(configGaussian, imageType);
+
+ // setup the gui if we are going to use it
+ if (DO_GRAPHICAL_USER_INTERFACE) {
+
+ // create an image grid for images to place on, tile fashion
+ gui = new ImageGridPanel(1, 2);
+
+ // make the window large so we dont have to manually resize with the mouse
+ gui.setSize(1920, 1080);
+
+ // Make the window visible and set the title
+ ShowImages.showWindow(gui, "Static Scene: Background Segmentation", true);
+ }
+
+ // Launch the worker thread
+ workThread = new Thread(new Runnable() {
+ public void run() {
+
+ while (true) {
+ runMotionDetection();
+ }
+ }
+ });
+ workThread.start();
+
+
+ // Launch the callback thread
+ callBackThread = new Thread(new Runnable() {
+ public void run() {
+
+ while (true) {
+ doCallbacks();
+ }
+ }
+ });
+ callBackThread.start();
+ }
+
+
+ /*******************************************************************************************************************************************
+ **
+ ** Public Methods
+ **
+ *******************************************************************************************************************************************/
+
+ /** Method to add a new frame to the motion detector.
+ *
+ * @param _newFrame [byte[]], Frame data of new frame.
+ * @param _timestamp [Date] , Timestamp of new frame.
+ *
+ * @return [void] None.
+ */
+ public void addFrame(byte[] _newFrame, Date _timestamp) {
+ BufferedImage img = null;
+
+ try {
+ // Parse the byte array into a Buffered Image
+ InputStream in = new ByteArrayInputStream(_newFrame);
+ img = ImageIO.read(in);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ return;
+ }
+
+ // Save the image and timestamp for use later
+ imageWriteLock.lock();// lock the image and timestamp buffers since multithread
+ latestImage = img;// image into image buffer
+ possibleDate = _timestamp;// timestamp into timestamp buffer
+ imageWriteLock.unlock();// Never forget to unlock
+
+ // flag the worker thread that there is new data ready for processing
+ newFrameAvailable.set(true);
+ }
+
+ /** Method to get the timestamp of the last time motion was detected
+ *
+ * @return [Date] timestamp of last motion or null if no motion was ever detected.
+ */
+ public Date getTimestampOfLastMotion() {
+ Date ret = null;
+
+ // Be safe because multithread
+ timestampReadLock.lock();
+
+ // Checks if there was ever motion, if not then timestampOfLastMotion
+ // will be null
+ if (timestampOfLastMotion != null) {
+ // Clone since we don't know what the other person is going to do
+ // with the timestamp
+ ret = (Date)timestampOfLastMotion.clone();
+ }
+
+ timestampReadLock.unlock();
+
+ return ret;
+ }
+
+
+ /** Method to add a new frame to the motion detector from a camera
+ *
+ * @param _camera [Camera], Camera that has the new data.
+ *
+ * @return [void] None.
+ */
+ public void newCameraFrameAvailable(CameraSmart _camera) {
+ BufferedImage img = null;
+
+ try {
+ // Parse the byte array into a Buffered Image
+ InputStream in = new ByteArrayInputStream(_camera.getLatestFrame());
+ img = ImageIO.read(in);
+
+ } catch (RemoteException e) {
+ e.printStackTrace();
+ return;
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ return;
+
+ }
+
+ // Save the image and timestamp for use later
+ imageWriteLock.lock(); // lock the image and timestamp buffers since multithread
+ latestImage = img; // image into image buffer
+
+ // timestamp from camera into timestamo buffer
+ long dateLong = _camera.getTimestamp();
+ possibleDate = new Date(dateLong);
+
+ imageWriteLock.unlock(); // Never forget to unlock
+
+ // flag the worker thread that there is new data ready for processing
+ newFrameAvailable.set(true);
+ }
+
+ /** Method to register an object to recieve callbacks from this motion detector
+ *
+ * @param _mdc [MotionDetectionCallback], object to recieve callbacks.
+ *
+ * @return [void] None.
+ */
+ public void registerCallback(MotionDetectionCallback _mdc) {
+ callbackList.add(_mdc);
+ }
+
+ /*******************************************************************************************************************************************
+ **
+ ** Helper Methods
+ **
+ *******************************************************************************************************************************************/
+
+ /** Method that constantly loops checking if new data is available. If there is
+ * new data, it is processed.
+ * This method should be run on a separate thread.
+ *
+ * @return [void] None.
+ */
+ private void runMotionDetection() {
+
+ // check if there is a new frame availble, only runs detection if there is new data to save
+ // computation time
+ if (!newFrameAvailable.get()) {
+ return;
+ }
+
+ // Lock since we are accessing the data buffers
+ imageReadLock.lock();
+
+ // processing data so now the buffered data is old
+ newFrameAvailable.set(false);
+
+ // copy from buffer to local for processing
+ Date tmpDate = possibleDate;
+
+ // Allocate space for the segmented image based on the first image we received
+ // cannot pre-allocate this since we do not know what the size of the images is
+ // before the first image arrives
+ if (segmented == null) {
+ segmented = new ImageUInt8(latestImage.getWidth(), latestImage.getHeight());
+ }
+
+ // copy from data buffers and convert into correct data type for BoofCv libraries
+ newFrameFloat = ConvertBufferedImage.convertFrom(latestImage, newFrameFloat);
+
+ // All done accessing the data buffers
+ imageReadLock.unlock();
+
+ // Run background detection
+ backgroundDetector.segment(newFrameFloat, segmented);
+
+ // Update the background baseline every 10 frames, helps the algorithm
+ frameCounter++;
+ if (frameCounter > 10) {
+ backgroundDetector.updateBackground(newFrameFloat);
+ frameCounter = 0;
+ }
+
+ // get the raw pixel data, gray-scale image
+ byte[] frameData = segmented.getData();
+
+ // count the number of pixels of the image that was deemed as "motion"
+ double count = 0;
+ double countMotion = 0;
+ for (byte b : frameData) {
+ count++;
+ if (b > 0) {
+ countMotion++;
+ }
+ }
+
+ // calculate the percentage of the image that was in motion
+ double percentMotion = (countMotion / count) * 100.0;
+
+ // Check if a high enough percentage of the image was in motion to say that there was motion in this frame of data
+ if (percentMotion > MOTION_DETECTED_THRESHOLD_PERCENTAGE) {
+
+ // Motion detected so save timestamp of this frame to another buffer
+ timestampWriteLock.lock();
+ timestampOfLastMotion = (Date)tmpDate.clone(); // clone to a different buffer
+ timestampWriteLock.unlock();
+
+ System.out.println("Motion Detected (with percentage: " + Double.toString(percentMotion) + "%)");
+ }
+
+ // Do output to the screen if we are using gui mode
+ if (DO_GRAPHICAL_USER_INTERFACE) {
+
+ // change image data unto correct type for rendering
+ BufferedImage visualized1 = new BufferedImage(segmented.width, segmented.height, BufferedImage.TYPE_INT_RGB);
+ VisualizeBinaryData.renderBinary(segmented, false, visualized1);
+
+ // change image data unto correct type for rendering
+ BufferedImage visualized2 = null;
+ visualized2 = ConvertBufferedImage.convertTo(newFrameFloat, visualized2, true);
+
+ // place the images into the image grid
+ gui.setImage(0, 1, visualized1);
+ gui.setImage(0, 2, visualized2);
+
+ // trigger rendering
+ gui.repaint();
+ }
+ }
+
+ /** Method that constantly loops checking if the callbacks should be issues and
+ * issues the callbacks if they should be issues.
+ * This method should be run on a separate thread.
+ *
+ * @return [void] None.
+ */
+ private void doCallbacks() {
+
+ // Keep looping forever for callback
+ while (true) {
+
+ // If motion detected
+ if (motionDetected.compareAndSet(true, false)) {
+
+ // Motion was detected so issue callbacks to all objects that registered
+ // to receive callback from this class.
+ for (MotionDetectionCallback c : callbackList) {
+ try {
+ c.motionDetected(this);
+ } catch (RemoteException re) {
+ }
+ }
+
+ } else {
+
+ // Sleep for 15 millisec to give time for new frame to arrive
+ try {
+ Thread.sleep(15);
+ } catch (InterruptedException ie) {
+ }
+ }
+ }
+ }
+
+
+
+
+ // /*******************************************************************************************************************************************
+ // ** Main Method used for testing
+ // *******************************************************************************************************************************************/
+ // public static void main(String[] args) {
+ // MotionDetection mo = new MotionDetection(12, 0.5f, 10, 10);
+
+ // AmcrestCamera cam = null;
+ // try {
+
+ // InetAddress addr = InetAddress.getByName("192.168.1.29");
+ // cam = new AmcrestCamera(addr, "admin", "55779CatSoundz32");
+ // cam.registerCallback(mo);
+ // cam.start();
+ // // cam.streamDisconnect();
+
+ // } catch (Exception e) {
+
+ // }
+
+ // while (true) {
+
+ // }
+
+ // }
+}
+
--- /dev/null
+package SmartLightsController;
+
+/** Interface MotionDetectionCallback for allowing callbacks from the MotionDetection class.
+ *
+ *
+ * @author Ali Younis <ayounis @ uci.edu>
+ * @version 1.0
+ * @since 2016-03-21
+ */
+
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+public interface MotionDetectionCallback extends Remote {
+
+ /** Callback method for when motion is detected.
+ *
+ * @param _md [MotionDetection].
+ *
+ * @return [void] None.
+ */
+ public void motionDetected(MotionDetection _md) throws RemoteException;
+}
--- /dev/null
+package SmartLightsController;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.RoomSmart;
+
+public class RoomSmart_Stub implements RoomSmart {
+
+ private IoTRMICall rmiCall;
+ private String callbackAddress;
+ private int[] ports;
+
+ private final static int objectId = 0;
+
+
+ public RoomSmart_Stub(int _port, String _skeletonAddress, String _callbackAddress, int _rev, int[] _ports) throws Exception {
+ callbackAddress = _callbackAddress;
+ ports = _ports;
+ rmiCall = new IoTRMICall(_port, _skeletonAddress, _rev);
+ }
+
+ public int getRoomID() {
+ int methodId = 0;
+ Class<?> retType = int.class;
+ Class<?>[] paramCls = new Class<?>[] { };
+ Object[] paramObj = new Object[] { };
+ Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);
+ return (int)retObj;
+ }
+
+}
--- /dev/null
+ADDITIONAL_ZIP_FILE=No
--- /dev/null
+package SmartLightsController;
+
+// IoT Runtime packages
+import iotruntime.slave.IoTSet;
+import iotruntime.slave.IoTRelation;
+
+// IoT driver packages
+import iotcode.interfaces.*;
+import iotcode.annotation.*;
+
+
+// Standard Java packages
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Date; // TODO: Get rid of all depreciated stuff for date, switch to Calender
+import java.util.concurrent.Semaphore;
+
+// RMI packages
+import java.rmi.RemoteException;
+
+// Checker annotations
+//import iotchecker.qual.*;
+
+/** Class Smart Lights Controller for the smart home application benchmark
+ *
+ * @author Ali Younis <ayounis @ uci.edu>
+ * @version 1.0
+ * @since 2016-01-27
+ */
+public class SmartLightsController {
+
+ /*
+ * Constants
+ */
+ public static final int MOTION_TIME_THRESHOLD = 60; // in seconds
+ public static final int CHECK_TIME_WAIT = 1; // in seconds
+ public static final int COLOR_TEMP_MIN_KELVIN = 2500; // In Kelvin
+ public static final int COLOR_TEMP_MAX_KELVIN = 9000; // In Kelvin
+ public static final int CAMERA_FPS = 15; // In frames per second
+
+ /*
+ * IoT Sets of Devices
+ */
+ @config private IoTSet<LightBulbSmart> mainRoomLightBulbs;
+ @config private IoTSet<CameraSmart> cameras;
+
+
+ /*
+ * IoT Sets of Things that are not devices such as rooms
+ */
+ @config private IoTSet<Room> rooms;
+
+ /*
+ * IoT Relations
+ */
+ @config private IoTRelation<Room,CameraSmart> roomCameraRel;
+ @config private IoTRelation<Room,LightBulbSmart> roomMainBulbRel;
+
+
+ /*
+ * The state that the room main lights are supposed to be in
+ */
+ Map<Room, Boolean> roomLightOnOffStatus =
+ new HashMap<Room, Boolean>();
+ Map<Room, ColorTemperature> roomLightColorTemperature =
+ new HashMap<Room, ColorTemperature>();
+
+ /*
+ * Motion detectors that are bound to specific cameras
+ */
+ private Map<CameraSmart, MotionDetection>
+ camMotionDetect = new HashMap<CameraSmart, MotionDetection>();
+
+
+ /*******************************************************************************************************************************************
+ **
+ ** Variables
+ **
+ *******************************************************************************************************************************************/
+ long lastTimeChecked = 0;
+
+ boolean print830 = true;
+ boolean print1030 = true;
+ boolean print730 = true;
+ boolean print930 = true;
+ boolean printNite = true;
+
+ /*******************************************************************************************************************************************
+ **
+ ** Private Helper Methods
+ **
+ *******************************************************************************************************************************************/
+
+ /** Method to detect if a room has seen motion within the last few seconds (time specified as parameter).
+ * Checks all the motion detectors for the given room
+ *
+ * @param _room [Room] , Room of interest.
+ * @param _numberOfSeconds [int] , Number of seconds in the past that we consider recent.
+ * @param _upperThreshold [int] , Number of seconds as an upper bound before we turn off.
+ *
+ * @return [boolean] if motion was detected recently.
+ */
+ private boolean roomDidHaveMotionRecently(Room _room, int _numberOfSeconds) {
+ long currentTimeSeconds = (new Date()).getTime() / 1000;
+
+ // Loop through all the motion sensors in the room
+ for (CameraSmart cam : roomCameraRel.get(_room)) {
+ long lastDetectedMotionSeconds = currentTimeSeconds;
+
+ Date motionTime = ((MotionDetection)camMotionDetect.get(cam)).getTimestampOfLastMotion();
+
+ // Motion was detected at least once
+ if (motionTime != null) {
+ lastDetectedMotionSeconds = motionTime.getTime() / 1000;
+ } else {
+ // motionTime == null means this is the initialization phase
+ // so we return false to initialize the lightbulbs to off
+ return false;
+ }
+
+ // Did detect motion recently
+ if (Math.abs(currentTimeSeconds - lastDetectedMotionSeconds) < _numberOfSeconds) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+
+
+ /** Set the temperature of the room based on the time of day.
+ * Do this to make sure people are able to get a good nights sleep.
+ * based on this: https://justgetflux.com/research.html
+ *
+ * @return [void] None;
+ */
+ private void setRoomColorTemperatureForSleep() throws RemoteException {
+
+ long currentTimeSeconds = (new Date()).getTime() / 1000;
+ Date today = new Date();
+ Date beginningOfToday = new Date(today.getYear(),
+ today.getMonth(), today.getDate());
+
+ long secondsSinceStartOfDay = currentTimeSeconds - (beginningOfToday.getTime() / 1000);
+
+ for (Room room : rooms.values()) {
+
+ // before 8:30 am
+ if (secondsSinceStartOfDay <= 30600) {
+ ColorTemperature colTemp = roomLightColorTemperature.get(room);
+ colTemp.temperature = COLOR_TEMP_MIN_KELVIN;
+ roomLightColorTemperature.put(room, colTemp);
+
+ if (print830) {
+ System.out.println("Before 8:30am!");
+ System.out.println("Color temperature: " + colTemp.temperature);
+ print830 = false;
+ print1030 = true;
+ print730 = true;
+ print930 = true;
+ printNite = true;
+ }
+
+ } else if ((secondsSinceStartOfDay > 30600) && (secondsSinceStartOfDay < 37800)) {
+ // 8:30am - 10:30 am
+ // Slowly turn lights from warm to work white
+ double newKelvinValue = (double) (secondsSinceStartOfDay - 30600) / (37800 - 30600);
+ newKelvinValue = (newKelvinValue * (COLOR_TEMP_MAX_KELVIN - COLOR_TEMP_MIN_KELVIN)) + COLOR_TEMP_MIN_KELVIN;
+ ColorTemperature colTemp = roomLightColorTemperature.get(room);
+ colTemp.temperature = (int)newKelvinValue;
+ roomLightColorTemperature.put(room, colTemp);
+
+ if (print1030) {
+ System.out.println("8:30am - 10:30am!");
+ print830 = true;
+ print1030 = false;
+ print730 = true;
+ print930 = true;
+ printNite = true;
+ }
+
+ } else if ((secondsSinceStartOfDay > 37800 ) && (secondsSinceStartOfDay < 70200)) {
+ // Between 10:30am and 7:30pm
+ // Keep white Work Light
+ ColorTemperature colTemp = roomLightColorTemperature.get(room);
+ colTemp.temperature = COLOR_TEMP_MAX_KELVIN;
+ roomLightColorTemperature.put(room, colTemp);
+
+ if (print730) {
+ System.out.println("10:30am - 7:30pm!");
+ System.out.println("Color temperature: " + colTemp.temperature);
+ print830 = true;
+ print1030 = true;
+ print730 = false;
+ print930 = true;
+ printNite = true;
+ }
+
+ } else if ((secondsSinceStartOfDay > 70200) && (secondsSinceStartOfDay < 77400)) {
+ // Between 7:30pm and 9:30pm
+ // Slowly turn lights from work to warm
+ double newKelvinValue = (double) (secondsSinceStartOfDay - 30600) / (37800 - 30600);
+ newKelvinValue = (newKelvinValue * (COLOR_TEMP_MAX_KELVIN - COLOR_TEMP_MIN_KELVIN)) + COLOR_TEMP_MIN_KELVIN;
+ ColorTemperature colTemp = roomLightColorTemperature.get(room);
+ colTemp.temperature = (int)newKelvinValue;
+ roomLightColorTemperature.put(room, colTemp);
+
+ if (print930) {
+ System.out.println("7:30pm - 9:30pm!");
+ print830 = true;
+ print1030 = true;
+ print730 = true;
+ print930 = false;
+ printNite = true;
+ }
+
+ } else if (secondsSinceStartOfDay > 77400) {
+ // past 9:30pm
+ // Keep warm Light
+ ColorTemperature colTemp = roomLightColorTemperature.get(room);
+ colTemp.temperature = COLOR_TEMP_MIN_KELVIN;
+ roomLightColorTemperature.put(room, colTemp);
+
+ if (printNite) {
+ System.out.println("After 9:30pm!");
+ System.out.println("Color temperature: " + colTemp.temperature);
+ print830 = true;
+ print1030 = true;
+ print730 = true;
+ print930 = true;
+ printNite = false;
+ }
+ }
+ }
+ }
+
+
+
+ /** Sets bulbs to the proper state. Sets the On/Off state as well as the color.
+ * The method changes the state of the bulb. It does not calculate what the state
+ * of the bulb should be, this is done elsewhere.
+ *
+ * When setting the color of the bulb, a best attempt effort is made. If the needed
+ * temperature and color of the bulb is outside the bulb range then the system gets
+ * as close as it can
+ *
+ * @return [void] None;
+ */
+ private void setMainBulbs() throws RemoteException {
+
+ for (Room room : rooms.values()) {
+
+ // Lights in room should be turned off
+ if (!roomLightOnOffStatus.get(room)) {
+
+ // turn the bulbs off if they are on
+ for (LightBulbSmart bulb : roomMainBulbRel.get(room)) {
+ if (bulb.getState()) {
+ bulb.turnOff();
+ System.out.println("SmartLightsController: Send off signal!!!");
+ }
+ }
+
+ } else {
+
+ // Lights in room should be turned on
+ // set the color of the bulbs
+ ColorTemperature colTemp = roomLightColorTemperature.get(room);
+ for (LightBulbSmart bulb : roomMainBulbRel.get(room)) {
+ // Turn on the bulb if they are off
+ if (!bulb.getState()) {
+ bulb.turnOn();
+ System.out.println("SmartLightsController: Send on signal!!!");
+ }
+
+ // Get the requested color of the room
+ double hue = colTemp.hue;
+ double saturation = colTemp.saturation;
+ double brightness = colTemp.brightness;
+ int temperature = colTemp.temperature;
+
+ // Make sure hue is in range that light bulb supports
+ if (hue < bulb.getHueRangeLowerBound()) {
+ hue = bulb.getHueRangeLowerBound();
+ } else if (hue > bulb.getHueRangeUpperBound()) {
+ hue = bulb.getHueRangeUpperBound();
+ }
+
+ // Make sure saturation is in range that light bulb supports
+ if (saturation < bulb.getSaturationRangeLowerBound()) {
+ saturation = bulb.getSaturationRangeLowerBound();
+ } else if (saturation > bulb.getSaturationRangeUpperBound()) {
+ saturation = bulb.getSaturationRangeUpperBound();
+ }
+
+ // Make sure brightness is in range that light bulb supports
+ if (brightness < bulb.getBrightnessRangeLowerBound()) {
+ brightness = bulb.getBrightnessRangeLowerBound();
+ } else if (brightness > bulb.getBrightnessRangeUpperBound()) {
+ brightness = bulb.getBrightnessRangeUpperBound();
+ }
+
+ // Make sure temperature is in range that light bulb supports
+ if (temperature < bulb.getTemperatureRangeLowerBound()) {
+ temperature = bulb.getTemperatureRangeLowerBound();
+ } else if (temperature > bulb.getTemperatureRangeUpperBound()) {
+ temperature = bulb.getTemperatureRangeUpperBound();
+ }
+
+ // Actually set the bulb to that color and temp
+ bulb.setColor(hue, saturation, brightness);
+ bulb.setTemperature(temperature);
+ }
+ }
+ }
+ }
+
+
+ /********************************************************************************************************
+ ** Public methods, called by the runtime
+ *********************************************************************************************************/
+
+ /** Initialization method, called by the runtime (effectively the main of the controller)
+ * This method runs a continuous loop and is blocking
+ *
+ * @return [void] None;
+ */
+ public void init() throws RemoteException, InterruptedException {
+
+
+ // Initialize the rooms
+ for (Room room : rooms.values()) {
+
+ // All rooms start with the lights turned off
+ roomLightOnOffStatus.put(room, false);
+
+ // All rooms have a default color and temperature
+ roomLightColorTemperature.put(room, new ColorTemperature(0, 0, 100, 2500));
+ }
+
+
+ // Setup the cameras, start them all and assign each one a motion detector
+ for (CameraSmart cam : cameras.values()) {
+
+ // Each camera will have a motion detector unique to it since the motion detection has state
+ MotionDetection mo = new MotionDetection(12, 0.5f, 10, 10);
+
+ // initialize the camera, might need to setup some stuff internally
+ cam.init();
+
+ // set the camera parameters.
+ cam.setFPS(CAMERA_FPS);
+ cam.setResolution(Resolution.RES_VGA);
+
+ // camera will call the motion detector directly with data not this controller
+ cam.registerCallback(mo);
+
+ // Start the camera (example is start the HTTP stream if it is a network camera)
+ cam.start();
+
+ // Remember which motion detector is for what camera
+ camMotionDetect.put(cam, mo);
+ }
+
+
+ //Initialize the light-bulbs, will turn off the bulb
+ for (LightBulbSmart bulb : mainRoomLightBulbs.values()) {
+ bulb.init();
+ Thread.sleep(1000);
+ }
+
+ // Run the main loop that will keep check the bulbs and rooms periodically
+ while (true) {
+
+ // Run this code every <specified time>
+ long currentTimeSeconds = (new Date()).getTime() / 1000;
+ if ((currentTimeSeconds - lastTimeChecked) > CHECK_TIME_WAIT) {
+ lastTimeChecked = currentTimeSeconds;
+
+ // Check for motion in rooms and if there is motion then turn on the lights
+ for (Room room : rooms.values()) {
+
+ if (roomDidHaveMotionRecently(room, MOTION_TIME_THRESHOLD)) {
+
+ // Motion was detected
+ roomLightOnOffStatus.put(room, true);
+
+ } else {
+
+ // No motion was detected
+ roomLightOnOffStatus.put(room, false);
+
+ }
+ }
+
+ // Check what the temperature of the light in the room should be
+ setRoomColorTemperatureForSleep();
+
+ // Set the bulbs to the new values
+ setMainBulbs();
+
+ } else {
+ try {
+ Thread.sleep(CHECK_TIME_WAIT * 100); // sleep for a tenth of the time
+ } catch (Exception e) {
+
+ }
+ }
+
+ }
+ }
+}
+
+
+
+
--- /dev/null
+# Skeleton/original interface
+INTERFACE_CLASS=Camera
+# Stub
+INTERFACE_STUB_CLASS=CameraSmart
--- /dev/null
+package iotcode.AmcrestCamera;
+
+// IoT Packages
+import iotcode.annotation.*;
+import iotcode.interfaces.*;
+import iotruntime.IoTHTTP;
+import iotruntime.slave.IoTSet;
+import iotruntime.slave.IoTDeviceAddress;
+
+// Standard Java Packages
+import java.io.IOException;
+import java.io.DataInputStream;
+import java.io.InputStream;
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.WritableRaster;
+import java.awt.image.BufferedImage;
+import javax.imageio.ImageIO;
+import java.util.Base64;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.Iterator;
+import javax.imageio.ImageIO;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Semaphore;
+
+// RMI Packages
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+// Checker annotations
+//import iotchecker.qual.*;
+
+public class AmcrestCamera implements Camera {
+
+ /*******************************************************************************************************************************************
+ **
+ ** Variables
+ **
+ *******************************************************************************************************************************************/
+ private String credentialUsername = "";
+ private String credentialPassword = "";
+ private DataInputStream dataInStream = null;
+ private boolean isStreamConnected = false;
+ private byte[] latestImage = null;
+ private ReadWriteLock imageReadWriteLock = new ReentrantReadWriteLock();
+ private Lock imageReadLock = imageReadWriteLock.readLock();
+ private Lock imageWriteLock = imageReadWriteLock.writeLock();
+ private AtomicBoolean newFrameAvailable = new AtomicBoolean(false);
+ private ReadWriteLock timestampReadWriteLock = new ReentrantReadWriteLock();
+ private Lock timestampReadLock = timestampReadWriteLock.readLock();
+ private Lock timestampWriteLock = timestampReadWriteLock.writeLock();
+ private Date latestImageTimestamp = null;
+ private List <CameraSmartCallback> callbackList =
+ new CopyOnWriteArrayList <CameraSmartCallback> ();
+ private AtomicBoolean doEnd = new AtomicBoolean(false);
+ private IoTDeviceAddress deviceAddress = null;
+ private AtomicBoolean didInit = new AtomicBoolean();
+ private AtomicBoolean didStart = new AtomicBoolean();
+ static Semaphore settingsSettings = new Semaphore(1);
+
+ /*******************************************************************************************************************************************
+ **
+ ** Threads
+ **
+ *******************************************************************************************************************************************/
+ private Thread callbackThread = null;
+ private Thread workerThread = null;
+
+
+ /*******************************************************************************************************************************************
+ **
+ ** IoT Sets and Relations
+ **
+ *******************************************************************************************************************************************/
+
+ // IoTSet of Device Addresses.
+ // Will be filled with only 1 address.
+ @config private IoTSet<IoTDeviceAddress> cam_addresses;
+
+
+ public AmcrestCamera(String _credentialUsername, String _credentialPassword) throws RemoteException {
+ credentialUsername = _credentialUsername;
+ credentialPassword = _credentialPassword;
+ }
+
+ /*******************************************************************************************************************************************
+ **
+ ** Camera Interface Methods
+ **
+ *******************************************************************************************************************************************/
+
+ public byte[] getLatestFrame() {
+
+ byte[] newImage = null;
+
+ imageReadLock.lock();
+ try {
+ if (latestImage != null) {
+ newImage = Arrays.copyOf(latestImage, latestImage.length);
+ }
+ } catch (Exception x) {
+ x.printStackTrace();
+ }
+ imageReadLock.unlock();
+
+ return newImage;
+ }
+
+ public long getTimestamp() {
+ timestampReadLock.lock();
+ Date ret = (Date)latestImageTimestamp.clone();
+ timestampReadLock.unlock();
+ long retLong = ret.getTime();
+ return retLong;
+ }
+
+ public void registerCallback(CameraSmartCallback _callbackTo) {
+ callbackList.add(_callbackTo);
+ }
+
+ public boolean setFPS(int _fps) {
+ try {
+ settingsSettings.acquire();
+
+ String camUrlString = "/cgi-bin/configManager.cgi?action=setConfig&Encode[0].MainFormat[0].Video.FPS=" + Integer.toString(_fps);
+
+ try {
+
+ String credsPreBase64 = credentialUsername + ":" + credentialPassword;
+ String credsBase64 = Base64.getEncoder().encodeToString(credsPreBase64.getBytes("utf-8"));
+ String httpAuthCredentials = "Basic " + credsBase64;
+
+ IoTHTTP httpConnection = new IoTHTTP(deviceAddress);
+ httpConnection.setURL(camUrlString);
+ httpConnection.openConnection();
+ httpConnection.setDoInput(true);
+ httpConnection.setRequestProperty("Authorization", httpAuthCredentials);
+ httpConnection.connect();
+
+ InputStream is = httpConnection.getInputStream();
+ BufferedInputStream bis = new BufferedInputStream(is);
+ DataInputStream din = new DataInputStream(bis);
+
+ // wait for a response
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException ie) {
+ }
+
+ byte[] byteBuf = new byte[100];
+ try {
+ int r = din.read(byteBuf, 0, byteBuf.length);
+ String retString = new String(byteBuf);
+
+ if (!retString.substring(0, 2).equals("OK")) {
+ httpConnection.disconnect();
+ return false;
+ }
+
+ } catch (Exception e) {
+ httpConnection.disconnect();
+ return false;
+ // e.printStackTrace();
+ }
+
+ httpConnection.disconnect();
+ } catch (IOException e) {
+ return false;
+ } catch (Exception e) {
+ return false;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ settingsSettings.release();
+
+ return true;
+ }
+
+ public int getMaxFPS() {
+ // Hard coded since this is hardware dependant
+ return 30;
+ }
+
+ public int getMinFPS() {
+ // Hard coded since this is hardware dependant
+ return 5;
+ }
+
+ public List<Resolution> getSupportedResolutions() {
+
+ // Hard coded since this is hardware dependant
+ List<Resolution> ret = new ArrayList<Resolution>();
+ ret.add(Resolution.RES_1080P);
+ ret.add(Resolution.RES_720P);
+ ret.add(Resolution.RES_VGA);
+ return ret;
+ }
+
+ public boolean setResolution(Resolution _res) {
+
+ try {
+ settingsSettings.acquire();
+
+
+ String camUrlString = "/cgi-bin/configManager.cgi?action=setConfig";
+
+ if (_res == Resolution.RES_1080P) {
+ camUrlString += "&Encode[0].MainFormat[0].Video.Height=1080&Encode[0].MainFormat[0].Video.Width=1920";
+
+ } else if (_res == Resolution.RES_720P) {
+ camUrlString += "&Encode[0].MainFormat[0].Video.Height=720&Encode[0].MainFormat[0].Video.Width=1280";
+
+ } else if (_res == Resolution.RES_VGA) {
+ camUrlString += "&Encode[0].MainFormat[0].Video.Height=480&Encode[0].MainFormat[0].Video.Width=640";
+ }
+
+
+ try {
+
+ String credsPreBase64 = credentialUsername + ":" + credentialPassword;
+ String credsBase64 = Base64.getEncoder().encodeToString(credsPreBase64.getBytes("utf-8"));
+ String httpAuthCredentials = "Basic " + credsBase64;
+
+ IoTHTTP httpConnection = new IoTHTTP(deviceAddress);
+ httpConnection.setURL(camUrlString);
+ httpConnection.openConnection();
+ httpConnection.setDoInput(true);
+ httpConnection.setRequestProperty("Authorization", httpAuthCredentials);
+ httpConnection.connect();
+
+ InputStream is = httpConnection.getInputStream();
+ BufferedInputStream bis = new BufferedInputStream(is);
+ DataInputStream din = new DataInputStream(bis);
+
+ // wait for a response
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException ie) {
+ }
+
+ byte[] byteBuf = new byte[100];
+ try {
+ int r = din.read(byteBuf, 0, byteBuf.length);
+ String retString = new String(byteBuf);
+
+ if (!retString.substring(0, 2).equals("OK")) {
+ httpConnection.disconnect();
+ return false;
+ }
+
+ } catch (Exception e) {
+ httpConnection.disconnect();
+ return false;
+ // e.printStackTrace();
+ }
+
+ httpConnection.disconnect();
+ } catch (IOException e) {
+ return false;
+ } catch (Exception e) {
+ return false;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ settingsSettings.release();
+
+ return true;
+ }
+
+ public void start() {
+
+ if (didStart.compareAndSet(false, true) == false) {
+ return; // already started
+ }
+
+
+
+ doEnd.set(false);
+
+ if (!streamConnect()) {
+ return;
+ }
+
+ callbackThread = new Thread(new Runnable() {
+ public void run() {
+ doCallbacks();
+ }
+ });
+ callbackThread.start();
+
+ workerThread = new Thread(new Runnable() {
+ public void run() {
+ doWork();
+ }
+ });
+ workerThread.start();
+ }
+
+ public void stop() {
+ if (didStart.compareAndSet(true, false) == false) {
+ return; // already stopped
+ }
+
+ doEnd.set(true);
+
+ try {
+ callbackThread.join();
+ workerThread.join();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ streamDisconnect();
+ }
+
+ public void init() {
+ if (didInit.compareAndSet(false, true) == false) {
+ return; // already init
+ }
+
+ // get the device address and save it for later use when creating HTTP connections
+ Iterator itr = cam_addresses.iterator();
+ deviceAddress = (IoTDeviceAddress)itr.next();
+
+ System.out.println("Address: " + deviceAddress.getCompleteAddress());
+ }
+
+ /*******************************************************************************************************************************************
+ **
+ ** Helper Methods
+ **
+ *******************************************************************************************************************************************/
+ private byte[] readFromStream(int num) {
+ byte[] byteBuf = new byte[num];
+ try {
+ dataInStream.readFully(byteBuf, 0, byteBuf.length);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return byteBuf;
+ }
+
+ private void findBoundry() {
+ String boundary = "**************";
+ while (true) {
+ byte b = readFromStream(1)[0];
+ boundary = boundary.substring(1);
+ boundary += (char)b;
+
+ if (boundary.equals("--myboundary\r\n")) {
+ break;
+ }
+ }
+ }
+
+ private String getLine() {
+ String line = "";
+ while (true) {
+ byte b = readFromStream(1)[0];
+ char c = (char)b;
+
+ if (c == '\n') {
+ break;
+ } else if (c != '\r') {
+ line += c;
+ }
+ }
+
+ return line;
+ }
+
+ private BufferedImage parseImage() {
+
+ findBoundry();
+
+ String contentTypeString = getLine();
+ String contentLengthString = getLine();
+
+ // remove the new line characters \r\n
+ readFromStream(2);
+
+ int imageDataLength = Integer.parseInt(contentLengthString.substring(16));
+
+ byte[] imageDataBuf = readFromStream(imageDataLength);
+
+ // remove the new line characters \r\n
+ readFromStream(2);
+
+
+ try {
+ InputStream imageInStream = new ByteArrayInputStream(imageDataBuf);
+ return ImageIO.read(imageInStream);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ System.out.println("Has Exception");
+
+ }
+
+ return null;
+ }
+
+ private boolean streamConnect() {
+
+ try {
+
+ String credsPreBase64 = credentialUsername + ":" + credentialPassword;
+ String credsBase64 = Base64.getEncoder().encodeToString(credsPreBase64.getBytes("utf-8"));
+ String httpAuthCredentials = "Basic " + credsBase64;
+
+ IoTHTTP httpConnection = new IoTHTTP(deviceAddress);
+ httpConnection.setURL("/cgi-bin/mjpg/video.cgi?");
+ httpConnection.openConnection();
+ httpConnection.setDoInput(true);
+ httpConnection.setRequestProperty("Authorization", httpAuthCredentials);
+ httpConnection.connect();
+
+ InputStream is = httpConnection.getInputStream();
+ BufferedInputStream bis = new BufferedInputStream(is);
+ dataInStream = new DataInputStream(bis);
+
+ isStreamConnected = true;
+
+ } catch (IOException e) {
+ isStreamConnected = false;
+
+ } catch (Exception e) {
+ isStreamConnected = false;
+ }
+
+ return isStreamConnected;
+ }
+
+ private void streamDisconnect() {
+ try {
+ if (isStreamConnected) {
+ dataInStream.close();
+ isStreamConnected = false;
+ }
+ } catch (Exception e) {
+ }
+ }
+
+ private void doCallbacks() {
+
+ while (!doEnd.get()) {
+ if (newFrameAvailable.compareAndSet(true, false)) {
+
+ for (CameraSmartCallback c : callbackList) {
+
+ c.newCameraFrameAvailable(this);
+ }
+ } else {
+
+ // Sleep for 15 millisec to give time for new frame to arrive
+ try {
+ Thread.sleep(15);
+ } catch (InterruptedException ie) {
+ }
+ }
+ }
+
+ }
+
+ private void doWork() {
+
+ // parse the images that are loaded into the buffer
+ while (!doEnd.get()) {
+
+ BufferedImage img = parseImage();
+
+ if (img != null) {
+
+ timestampWriteLock.lock();
+ latestImageTimestamp = new Date();
+ timestampWriteLock.unlock();
+
+ imageWriteLock.lock();
+
+ try {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ ImageIO.write(img, "jpg", baos);
+ baos.flush();
+ latestImage = baos.toByteArray();
+ baos.close();
+
+ } catch (Exception e) {
+
+ }
+ imageWriteLock.unlock();
+
+ newFrameAvailable.set(true);
+ }
+
+ try {
+ if (dataInStream.available() > 120000) {
+ dataInStream.skip(120000);
+ }
+ } catch (Exception e) {
+ }
+ }
+
+ }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+package iotcode.AmcrestCamera;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.*;
+import SmartLightsController.CameraSmartCallback_CallbackStub;
+
+public class Camera_Skeleton implements Camera {
+
+ private Camera mainObj;
+ private IoTRMIObject rmiObj;
+
+ private String callbackAddress;
+ private static int objIdCnt = 0;
+ private IoTRMICall rmiCall;
+ private int[] ports;
+
+ private final static int object0Id = 0; //CameraSmart
+ private static Integer[] object0Permission = { 8, 7, 9, 6, 2, 1, 4, 3, 0, 10, 5 };
+ private static List<Integer> set0Allowed;
+
+
+ public Camera_Skeleton(Camera _mainObj, String _callbackAddress, int _port) throws Exception {
+ mainObj = _mainObj;
+ callbackAddress = _callbackAddress;
+ rmiObj = new IoTRMIObject(_port);
+ set0Allowed = new ArrayList<Integer>(Arrays.asList(object0Permission));
+ set0Allowed.add(-9998);
+ ___waitRequestInvokeMethod();
+ }
+
+ public void init() {
+ mainObj.init();
+ }
+
+ public void start() {
+ mainObj.start();
+ }
+
+ public void stop() {
+ mainObj.stop();
+ }
+
+ public byte[] getLatestFrame() {
+ return mainObj.getLatestFrame();
+ }
+
+ public long getTimestamp() {
+ return mainObj.getTimestamp();
+ }
+
+ public List<Resolution> getSupportedResolutions() {
+ return mainObj.getSupportedResolutions();
+ }
+
+ public boolean setResolution(Resolution _res) {
+ return mainObj.setResolution(_res);
+ }
+
+ public boolean setFPS(int _fps) {
+ return mainObj.setFPS(_fps);
+ }
+
+ public int getMaxFPS() {
+ return mainObj.getMaxFPS();
+ }
+
+ public int getMinFPS() {
+ return mainObj.getMinFPS();
+ }
+
+ public void registerCallback(CameraSmartCallback _callbackTo) {
+ mainObj.registerCallback(_callbackTo);
+ }
+
+ public void ___regCB() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int[].class, String.class, int.class },new Class<?>[] { null, null, null });
+ ports = (int[]) paramObj[0];
+ rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], ports[0]);
+ }
+
+ public void ___init() {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ init();
+ }
+
+ public void ___start() {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ start();
+ }
+
+ public void ___stop() {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ stop();
+ }
+
+ public void ___getLatestFrame() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getLatestFrame();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getTimestamp() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getTimestamp();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getSupportedResolutions() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ List<Resolution> retEnum = getSupportedResolutions();
+ int retLen = retEnum.size();
+ int[] retEnumVal = new int[retLen];
+ for (int i = 0; i < retLen; i++) {
+ retEnumVal[i] = retEnum.get(i).ordinal();
+ }
+ Object retObj = retEnumVal;
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___setResolution() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int[].class },
+ new Class<?>[] { null });
+ int paramInt0[] = (int[]) paramObj[0];
+ Resolution[] enumVals = Resolution.values();
+ Resolution paramEnum0 = enumVals[paramInt0[0]];
+ Object retObj = setResolution(paramEnum0);
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___setFPS() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class },
+ new Class<?>[] { null });
+ Object retObj = setFPS((int) paramObj[0]);
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getMaxFPS() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getMaxFPS();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___getMinFPS() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getMinFPS();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ public void ___registerCallback() {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class },
+ new Class<?>[] { null });
+ try {
+ CameraSmartCallback stub0 = new CameraSmartCallback_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);
+ objIdCnt++;
+ registerCallback(stub0);
+ } catch(Exception ex) {
+ ex.printStackTrace();
+ throw new Error("Exception from callback object instantiation!");
+ }
+ }
+
+ private void ___waitRequestInvokeMethod() throws IOException {
+ while (true) {
+ rmiObj.getMethodBytes();
+ int _objectId = rmiObj.getObjectId();
+ int methodId = rmiObj.getMethodId();
+ if (_objectId == object0Id) {
+ if (!set0Allowed.contains(methodId)) {
+ throw new Error("Object with object Id: " + _objectId + " is not allowed to access method: " + methodId);
+ }
+ }
+ else {
+ throw new Error("Object Id: " + _objectId + " not recognized!");
+ }
+ switch (methodId) {
+ case 0: ___init(); break;
+ case 1: ___start(); break;
+ case 2: ___stop(); break;
+ case 3: ___getLatestFrame(); break;
+ case 4: ___getTimestamp(); break;
+ case 5: ___getSupportedResolutions(); break;
+ case 6: ___setResolution(); break;
+ case 7: ___setFPS(); break;
+ case 8: ___getMaxFPS(); break;
+ case 9: ___getMinFPS(); break;
+ case 10: ___registerCallback(); break;
+ case -9998: ___regCB(); break;
+ default:
+ throw new Error("Method Id " + methodId + " not recognized!");
+ }
+ }
+ }
+
+}
--- /dev/null
+# Skeleton/original interface
+INTERFACE_CLASS=Room
+# Stub
+INTERFACE_STUB_CLASS=RoomSmart
--- /dev/null
+package iotcode.LabRoom;
+
+import iotcode.interfaces.Room;
+
+/** LabRoom implements Room as a needed object for room identification
+ *
+ * @author Rahmadi Trimananda <rahmadi.trimananda @ uci.edu>
+ * @version 1.0
+ * @since 2016-04-22
+ */
+public class LabRoom implements Room {
+
+ public LabRoom() {
+
+ }
+
+ public int getRoomID() {
+ return 0;
+ }
+}
--- /dev/null
+package iotcode.LabRoom;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import iotrmi.Java.IoTRMICall;
+import iotrmi.Java.IoTRMIObject;
+
+import iotcode.interfaces.Room;
+
+public class Room_Skeleton implements Room {
+
+ private Room mainObj;
+ private IoTRMIObject rmiObj;
+
+ private String callbackAddress;
+ private final static int object0Id = 0; //RoomSmart
+ private static Integer[] object0Permission = { 0 };
+ private static List<Integer> set0Allowed;
+
+
+ public Room_Skeleton(Room _mainObj, String _callbackAddress, int _port) throws Exception {
+ mainObj = _mainObj;
+ callbackAddress = _callbackAddress;
+ rmiObj = new IoTRMIObject(_port);
+ set0Allowed = new ArrayList<Integer>(Arrays.asList(object0Permission));
+ ___waitRequestInvokeMethod();
+ }
+
+ public int getRoomID() {
+ return mainObj.getRoomID();
+ }
+
+ public void ___getRoomID() throws IOException {
+ Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { },
+ new Class<?>[] { });
+ Object retObj = getRoomID();
+ rmiObj.sendReturnObj(retObj);
+ }
+
+ private void ___waitRequestInvokeMethod() throws IOException {
+ while (true) {
+ rmiObj.getMethodBytes();
+ int _objectId = rmiObj.getObjectId();
+ int methodId = rmiObj.getMethodId();
+ if (_objectId == object0Id) {
+ if (!set0Allowed.contains(methodId)) {
+ throw new Error("Object with object Id: " + _objectId + " is not allowed to access method: " + methodId);
+ }
+ }
+ else {
+ throw new Error("Object Id: " + _objectId + " not recognized!");
+ }
+ switch (methodId) {
+ case 0: ___getRoomID(); break;
+ default:
+ throw new Error("Method Id " + methodId + " not recognized!");
+ }
+ }
+ }
+
+}
+# Skeleton/original interface
INTERFACE_CLASS=LightBulb
+# Stub
INTERFACE_STUB_CLASS=LightBulbTest
JARFLAGS = cf
INTFACE_DIR = iotcode/interfaces
-all: light
+all: light camera labroom
# Compile
#
cp LifxLightBulb/LifxLightBulb.config $(BIN_DIR)/iotcode/LifxLightBulb
cd $(BIN_DIR)/iotcode/LifxLightBulb; $(JAR) $(JARFLAGS) LifxLightBulb.jar ../../iotcode/LifxLightBulb/*.class ../../iotcode/interfaces/LightBulb*.class
+PHONY += camera
+camera:
+ $(JAVAC) $(JFLAGS) AmcrestCamera/*.java
+ cp AmcrestCamera/AmcrestCamera.config $(BIN_DIR)/iotcode/AmcrestCamera
+ cd $(BIN_DIR)/iotcode/AmcrestCamera; $(JAR) $(JARFLAGS) AmcrestCamera.jar ../../iotcode/AmcrestCamera/*.class ../../iotcode/interfaces/Camera*.class
+
+PHONY += labroom
+labroom:
+ $(JAVAC) $(JFLAGS) LabRoom/*.java
+ cp LabRoom/LabRoom.config $(BIN_DIR)/iotcode/LabRoom
+ cd $(BIN_DIR)/iotcode/LabRoom; $(JAR) $(JARFLAGS) LabRoom.jar ../../iotcode/LabRoom/*.class ../../iotcode/interfaces/Room*.class
+
.PHONY: $(PHONY)
--- /dev/null
+package iotcode.interfaces;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public interface Camera {
+ public void init();
+ public void start();
+ public void stop();
+ public byte[] getLatestFrame();
+ public long getTimestamp();
+ public List<Resolution> getSupportedResolutions();
+ public boolean setResolution(Resolution _res);
+ public boolean setFPS(int _fps);
+ public int getMaxFPS();
+ public int getMinFPS();
+ public void registerCallback(CameraSmartCallback _callbackTo);
+}
--- /dev/null
+package iotcode.interfaces;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public interface CameraCallback {
+ public void newCameraFrameAvailable(CameraSmart _camera);
+}
--- /dev/null
+package iotcode.interfaces;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public interface CameraSmart {
+
+ public int getMaxFPS();
+ public boolean setFPS(int _fps);
+ public int getMinFPS();
+ public boolean setResolution(Resolution _res);
+ public void stop();
+ public void start();
+ public long getTimestamp();
+ public byte[] getLatestFrame();
+ public void init();
+ public void registerCallback(CameraCallback _callbackTo);
+ public List<Resolution> getSupportedResolutions();
+}
--- /dev/null
+package iotcode.interfaces;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public interface CameraSmartCallback {
+
+ public void newCameraFrameAvailable(Camera _camera);
+}
--- /dev/null
+package iotcode.interfaces;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public interface LightBulbSmart {
+
+ public void turnOn();
+ public double getBrightnessRangeLowerBound();
+ public void turnOff();
+ public boolean getState();
+ public double getBrightnessRangeUpperBound();
+ public double getSaturation();
+ public double getHueRangeLowerBound();
+ public double getHue();
+ public double getHueRangeUpperBound();
+ public int getTemperature();
+ public double getBrightness();
+ public int getTemperatureRangeLowerBound();
+ public int getTemperatureRangeUpperBound();
+ public void setColor(double _hue, double _saturation, double _brightness);
+ public void init();
+ public double getSaturationRangeLowerBound();
+ public double getSaturationRangeUpperBound();
+ public void setTemperature(int _temperature);
+}
--- /dev/null
+package iotcode.interfaces;
+
+public enum Resolution {
+ RES_1080P,
+ RES_720P,
+ RES_VGA
+}
+
--- /dev/null
+package iotcode.interfaces;
+
+public interface Room {
+ public int getRoomID();
+}
--- /dev/null
+package iotcode.interfaces;
+
+public interface RoomSmart {
+
+ public int getRoomID();
+}
run-compiler-lifx:
cp ../localconfig/iotpolicy/LifxLightBulb/*.pol $(BIN_DIR)/iotpolicy/
cp ../localconfig/iotpolicy/LifxLightBulb/*.req $(BIN_DIR)/iotpolicy/
- cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler lifxlightbulb.pol lifxtest.req -java Java
+ cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler lifxlightbulb.pol smartlightsbulb.req -java Java
+
+PHONY += run-compiler-room
+run-compiler-room:
+ cp ../localconfig/iotpolicy/LabRoom/*.pol $(BIN_DIR)/iotpolicy/
+ cp ../localconfig/iotpolicy/LabRoom/*.req $(BIN_DIR)/iotpolicy/
+ cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler labroom.pol roomsmart.req -java Java
+
+PHONY += run-compiler-cam
+run-compiler-cam:
+ cp ../localconfig/iotpolicy/AmcrestCamera/*.pol $(BIN_DIR)/iotpolicy/
+ cp ../localconfig/iotpolicy/AmcrestCamera/*.req $(BIN_DIR)/iotpolicy/
+ cd $(BIN_DIR)/iotpolicy; $(JAVA) -cp .:..:../$(PARSERJARS):../$(BIN_DIR) iotpolicy.IoTCompiler amcrestcamera.pol smartlightscam.req motiondetection.pol motiondetection.req -java Java
# TODO: Can remove this later - just to test-compile the resulted files from the compiler
PHONY += compile
}
+ /**
+ * HELPER: updateIntfaceObjIdMap() updates the mapping between new interface and object Id
+ */
+ private void updateIntfaceObjIdMap(String intface, String newIntface) {
+
+ Integer objId = mapIntfaceObjId.get(intface);
+ mapNewIntfaceObjId.put(newIntface, objId);
+ mapIntfaceObjId.put(intface, objId++);
+ }
+
+
/**
* generateJavaInterfaces() generate stub interfaces based on the methods list in Java
*/
// Write interface header
println("");
println("public interface " + newIntface + " {\n");
+ updateIntfaceObjIdMap(intface, newIntface);
// Write methods
writeMethodJavaInterface(methods, intDecl);
println("}");
// Get the object Id
Integer objId = mapIntfaceObjId.get(intface);
println("private final static int objectId = " + objId + ";");
- mapNewIntfaceObjId.put(newIntface, objId);
- mapIntfaceObjId.put(intface, objId++);
+ //mapNewIntfaceObjId.put(newIntface, objId);
+ //mapIntfaceObjId.put(intface, objId++);
if (callbackExist) {
// We assume that each class only has one callback interface for now
Iterator it = callbackClasses.iterator();
/**
* HELPER: writeInitCallbackJavaStub() writes callback initialization in stub
*/
- private void writeInitCallbackJavaStub(String intface, InterfaceDecl intDecl) {
+ private void writeInitCallbackJavaStub(String intface, InterfaceDecl intDecl, boolean isGenCallbackStub) {
println("public void ___initCallBack() {");
// Generate main thread for callbacks
println("Thread thread = new Thread() {");
println("public void run() {");
println("try {");
- println("rmiObj = new IoTRMIObject(ports[0]);");
+ if (isGenCallbackStub) // Use the second port for a _CallbackStub class (callback in callback)
+ println("rmiObj = new IoTRMIObject(ports[1]);");
+ else
+ println("rmiObj = new IoTRMIObject(ports[0]);");
println("while (true) {");
println("byte[] method = rmiObj.getMethodBytes();");
writeJavaMethodCallbackPermission(intface);
int methodNumId = intDecl.getHelperMethodNumId(method);
println("int methodId = " + methodNumId + ";");
println("Class<?> retType = void.class;");
- println("Class<?>[] paramCls = new Class<?>[] { int.class, String.class, int.class };");
- println("Object[] paramObj = new Object[] { ports[0], callbackAddress, 0 };");
+ println("Class<?>[] paramCls = new Class<?>[] { int[].class, String.class, int.class };");
+ println("Object[] paramObj = new Object[] { ports, callbackAddress, 0 };");
println("rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
println("}\n");
}
String param = methParams.get(i);
if (isArrayOrList(paramType, param)) { // Generate loop
println("for (" + getGenericType(paramType) + " cb : " + getSimpleIdentifier(param) + ") {");
- println(callbackType + "_CallbackSkeleton skel" + i + " = new " + callbackType + "_CallbackSkeleton(cb, objIdCnt++);");
+ println(callbackType + "_CallbackSkeleton skel" + i + " = new " + callbackType + "_CallbackSkeleton(cb, callbackAddress, objIdCnt++);");
} else
println(callbackType + "_CallbackSkeleton skel" + i + " = new " + callbackType + "_CallbackSkeleton(" +
- getSimpleIdentifier(param) + ", objIdCnt++);");
+ getSimpleIdentifier(param) + ", callbackAddress, objIdCnt++);");
println("listCallbackObj.add(skel" + i + ");");
if (isArrayOrList(paramType, param))
println("}");
/**
* HELPER: writeMethodJavaStub() writes the methods of the stub class
*/
- private void writeMethodJavaStub(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses) {
+ private void writeMethodJavaStub(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses, boolean isGenCallbackStub) {
boolean isDefined = false;
for (String method : methods) {
println("}\n");
// Write the init callback helper method
if (isCallbackMethod && !isDefined) {
- writeInitCallbackJavaStub(callbackType, intDecl);
+ writeInitCallbackJavaStub(callbackType, intDecl, isGenCallbackStub);
isDefined = true;
}
}
// Write constructor
writeConstructorJavaStub(intface, newStubClass, callbackExist, callbackClasses);
// Write methods
- writeMethodJavaStub(intMeth.getValue(), intDecl, callbackClasses);
+ writeMethodJavaStub(intMeth.getValue(), intDecl, callbackClasses, false);
println("}");
pw.close();
System.out.println("IoTCompiler: Generated stub class " + newStubClass + ".java...");
private void writePropertiesJavaCallbackStub(String intface, String newIntface, boolean callbackExist, Set<String> callbackClasses) {
println("private IoTRMICall rmiCall;");
- println("private String address;");
+ println("private String callbackAddress;");
println("private int[] ports;\n");
// Get the object Id
println("private int objectId = 0;");
private void writeConstructorJavaCallbackStub(String intface, String newStubClass, boolean callbackExist, Set<String> callbackClasses) {
// TODO: If we want callback in callback, then we need to add address and port initializations
- println("public " + newStubClass + "(IoTRMICall _rmiCall, int _objectId) throws Exception {");
+ println("public " + newStubClass + "(IoTRMICall _rmiCall, String _callbackAddress, int _objectId, int[] _ports) throws Exception {");
+ println("callbackAddress = _callbackAddress;");
println("objectId = _objectId;");
println("rmiCall = _rmiCall;");
+ println("ports = _ports;");
if (callbackExist) {
Iterator it = callbackClasses.iterator();
String callbackType = (String) it.next();
writeConstructorJavaPermission(intface);
println("listCallbackObj = new ArrayList<" + callbackType + ">();");
println("___initCallBack();");
- println("// TODO: Add address and port initialization here if we want callback in callback!");
}
println("}\n");
}
writeConstructorJavaCallbackStub(intface, newStubClass, callbackExist, callbackClasses);
// Write methods
// TODO: perhaps need to generate callback for callback
- writeMethodJavaStub(intMeth.getValue(), intDecl, callbackClasses);
+ writeMethodJavaStub(intMeth.getValue(), intDecl, callbackClasses, true);
println("}");
pw.close();
System.out.println("IoTCompiler: Generated callback stub class " + newStubClass + ".java...");
println("private " + intface + " mainObj;");
//println("private int ports;");
println("private IoTRMIObject rmiObj;\n");
+ println("private String callbackAddress;");
// Callback
if (callbackExist) {
println("private static int objIdCnt = 0;");
println("private IoTRMICall rmiCall;");
+ println("private int[] ports;\n");
}
writePropertiesJavaPermission(intface, intDecl);
println("\n");
*/
private void writeConstructorJavaSkeleton(String newSkelClass, String intface, InterfaceDecl intDecl, Collection<String> methods, boolean callbackExist) {
- println("public " + newSkelClass + "(" + intface + " _mainObj, int _port) throws Exception {");
+ println("public " + newSkelClass + "(" + intface + " _mainObj, String _callbackAddress, int _port) throws Exception {");
println("mainObj = _mainObj;");
+ println("callbackAddress = _callbackAddress;");
println("rmiObj = new IoTRMIObject(_port);");
// Generate permission control initialization
writeConstructorJavaPermission(intface);
println("public void ___regCB(IoTRMIObject rmiObj) throws IOException {");
else
println("public void ___regCB() throws IOException {");
- print("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class, String.class, int.class },");
+ print("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int[].class, String.class, int.class },");
println("new Class<?>[] { null, null, null });");
- println("rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], (int) paramObj[2]);");
+ println("ports = (int[]) paramObj[0];");
+ if (callbackSkeleton) // If this is a callback skeleton then use the other port
+ println("rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], ports[1]);");
+ else
+ println("rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], ports[0]);");
println("}\n");
}
println("int numStubs" + i + " = (int) paramObj[" + offsetPfx + i + "];");
println("List<" + exchParamType + "> stub" + i + " = new ArrayList<" + exchParamType + ">();");
} else {
- println(exchParamType + " stub" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt);");
+ println(exchParamType + " stub" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);");
println("objIdCnt++;");
}
}
String exchParamType = checkAndGetParamClass(getGenericType(paramType));
if (isArray(param)) {
println("for (int objId = 0; objId < numStubs" + i + "; objId++) {");
- println("stub" + i + "[objId] = new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt);");
+ println("stub" + i + "[objId] = new " + exchParamType + "_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);");
println("objIdCnt++;");
println("}");
} else if (isList(paramType)) {
println("for (int objId = 0; objId < numStubs" + i + "; objId++) {");
- println("stub" + i + ".add(new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt));");
+ println("stub" + i + ".add(new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt, ports));");
println("objIdCnt++;");
println("}");
}
println("private " + intface + " mainObj;");
// For callback skeletons, this is its own object Id
println("private int objectId = 0;");
+ println("private String callbackAddress;");
// Callback
if (callbackExist) {
+
println("private static int objIdCnt = 0;");
println("private IoTRMICall rmiCall;");
+ println("private int[] ports;\n");
}
println("\n");
}
*/
private void writeConstructorJavaCallbackSkeleton(String newSkelClass, String intface, InterfaceDecl intDecl, Collection<String> methods) {
- println("public " + newSkelClass + "(" + intface + " _mainObj, int _objectId) throws Exception {");
+ println("public " + newSkelClass + "(" + intface + " _mainObj, String _callbackAddress, int _objectId) throws Exception {");
+ println("callbackAddress = _callbackAddress;");
println("mainObj = _mainObj;");
println("objectId = _objectId;");
println("}\n");
println("#ifndef _" + newIntface.toUpperCase() + "_HPP__");
println("#define _" + newIntface.toUpperCase() + "_HPP__");
println("#include <iostream>");
+ updateIntfaceObjIdMap(intface, newIntface);
// Pass in set of methods and get import classes
Set<String> methods = intMeth.getValue();
Set<String> includeClasses = getIncludeClasses(methods, intDecl, intface, false);
/**
* HELPER: writeMethodCplusStub() writes the methods of the stub
*/
- private void writeMethodCplusStub(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses) {
+ private void writeMethodCplusStub(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses, boolean isGenCallbackStub) {
boolean isDefined = false;
for (String method : methods) {
println("}\n");
// Write the init callback helper method
if (isCallbackMethod && !isDefined) {
- writeInitCallbackCplusStub(callbackType, intDecl);
+ writeInitCallbackCplusStub(callbackType, intDecl, isGenCallbackStub);
writeInitCallbackSendInfoCplusStub(intDecl);
isDefined = true;
}
String param = methParams.get(i);
if (isArrayOrList(paramType, param)) { // Generate loop
println("for (" + getGenericType(paramType) + "* cb : " + getSimpleIdentifier(param) + ") {");
- println(callbackType + "_CallbackSkeleton* skel" + i + " = new " + callbackType + "_CallbackSkeleton(cb, objIdCnt++);");
+ println(callbackType + "_CallbackSkeleton* skel" + i + " = new " + callbackType + "_CallbackSkeleton(cb, callbackAddress, objIdCnt++);");
isArrayOrList = true;
callbackParam = getSimpleIdentifier(param);
} else
println(callbackType + "_CallbackSkeleton* skel" + i + " = new " + callbackType + "_CallbackSkeleton(" +
- getSimpleIdentifier(param) + ", objIdCnt++);");
+ getSimpleIdentifier(param) + ", callbackAddress, objIdCnt++);");
println("vecCallbackObj.push_back(skel" + i + ");");
if (isArrayOrList)
println("}");
// Get the object Id
Integer objId = mapIntfaceObjId.get(intface);
println("const static int objectId = " + objId + ";");
- mapNewIntfaceObjId.put(newIntface, objId);
- mapIntfaceObjId.put(intface, objId++);
+ //mapNewIntfaceObjId.put(newIntface, objId);
+ //mapIntfaceObjId.put(intface, objId++);
if (callbackExist) {
// We assume that each class only has one callback interface for now
Iterator it = callbackClasses.iterator();
/**
* HELPER: writeInitCallbackCplusStub() writes the initialization of callback
*/
- private void writeInitCallbackCplusStub(String intface, InterfaceDecl intDecl) {
+ private void writeInitCallbackCplusStub(String intface, InterfaceDecl intDecl, boolean isGenCallbackStub) {
println("void ___initCallBack() {");
println("bool bResult = false;");
- println("rmiObj = new IoTRMIObject(ports[0], &bResult);");
+ if (isGenCallbackStub) // Use the second port for a _CallbackStub class (callback in callback)
+ println("rmiObj = new IoTRMIObject(ports[1], &bResult);");
+ else
+ println("rmiObj = new IoTRMIObject(ports[0], &bResult);");
println("while (true) {");
println("char* method = rmiObj->getMethodBytes();");
writeCplusMethodCallbackPermission(intface);
int methodNumId = intDecl.getHelperMethodNumId(method);
println("int methodId = " + methodNumId + ";");
println("string retType = \"void\";");
- println("string paramCls[] = { \"int\", \"String\", \"int\" };");
+ println("string paramCls[] = { \"int*\", \"String\", \"int\" };");
println("int rev = 0;");
- println("void* paramObj[] = { &ports[0], &callbackAddress, &rev };");
+ println("void* paramObj[] = { &ports, &callbackAddress, &rev };");
println("void* retObj = NULL;");
println("rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);");
println("}\n");
writeConstructorCplusStub(newStubClass, callbackExist, callbackClasses);
writeDeconstructorCplusStub(newStubClass, callbackExist, callbackClasses);
// Write methods
- writeMethodCplusStub(methods, intDecl, callbackClasses);
+ writeMethodCplusStub(methods, intDecl, callbackClasses, false);
print("}"); println(";");
if (callbackExist) {
Iterator it = callbackClasses.iterator();
println("vector<" + callbackType + "*> vecCallbackObj;");
println("static int objIdCnt;");
// TODO: Need to initialize address and ports if we want to have callback-in-callback
- println("string address;");
+ println("string callbackAddress;");
println("vector<int> ports;\n");
writePropertiesCplusPermission(callbackType);
}
*/
private void writeConstructorCplusCallbackStub(String newStubClass, boolean callbackExist, Set<String> callbackClasses) {
- println(newStubClass + "(IoTRMICall* _rmiCall, int _objectId) {");
+ println(newStubClass + "(IoTRMICall* _rmiCall, int _objectId, vector<int> _ports) {");
println("objectId = _objectId;");
println("rmiCall = _rmiCall;");
+ println("ports = _ports;");
if (callbackExist) {
Iterator it = callbackClasses.iterator();
String callbackType = (String) it.next();
writeConstructorCplusCallbackStub(newStubClass, callbackExist, callbackClasses);
writeDeconstructorCplusStub(newStubClass, callbackExist, callbackClasses);
// Write methods
- writeMethodCplusStub(methods, intDecl, callbackClasses);
+ writeMethodCplusStub(methods, intDecl, callbackClasses, true);
println("};");
if (callbackExist) {
Iterator it = callbackClasses.iterator();
println("static int objIdCnt;");
println("vector<" + exchangeType + "*> vecCallbackObj;");
println("IoTRMICall *rmiCall;");
+ println("vector<int> ports;");
}
println("IoTRMIObject *rmiObj;\n");
// Keep track of object Ids of all stubs registered to this interface
else
println("void ___regCB() {");
println("int numParam = 3;");
- println("int param1 = 0;");
+ println("vector<int> param1;");
println("string param2 = \"\";");
println("int param3 = 0;");
- println("string paramCls[] = { \"int\", \"String\", \"int\" };");
+ println("string paramCls[] = { \"int*\", \"String\", \"int\" };");
println("void* paramObj[] = { ¶m1, ¶m2, ¶m3 };");
println("rmiObj->getMethodParams(paramCls, numParam, paramObj);");
println("bool bResult = false;");
- println("rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);");
+ if (callbackSkeleton)
+ println("rmiCall = new IoTRMICall(param1[1], param2.c_str(), param3, &bResult);");
+ else
+ println("rmiCall = new IoTRMICall(param1[0], param2.c_str(), param3, &bResult);");
println("}\n");
}
if (isArrayOrList(paramType, param)) {
println("vector<" + exchParamType + "*> stub" + i + ";");
println("for (int objId = 0; objId < numStubs" + i + "; objId++) {");
- println(exchParamType + "* cb" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt);");
+ println(exchParamType + "* cb" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);");
println("stub" + i + ".push_back(cb" + i + ");");
println("vecCallbackObj.push_back(cb" + i + ");");
println("objIdCnt++;");
println("}");
} else {
- println(exchParamType + "* stub" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt);");
+ println(exchParamType + "* stub" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);");
println("vecCallbackObj.push_back(stub" + i + ");");
println("objIdCnt++;");
}
println("IoTRMICall* rmiCall;");
println("vector<" + exchangeType + "*> vecCallbackObj;");
println("static int objIdCnt;");
+ println("vector<int> ports;\n");
}
println("\n");
}
// Basically the compiler needs to parse the policy (and requires) files for callback class first
private int getNewIntfaceObjectId(String newIntface) {
- if (!mapNewIntfaceObjId.containsKey(newIntface)) {
- throw new Error("IoTCompiler: Need to parse policy and requires files for callback class first! " +
- "Please place the two files for callback class in front...\n");
- } else {
+// if (!mapNewIntfaceObjId.containsKey(newIntface)) {
+// throw new Error("IoTCompiler: Need to parse policy and requires files for callback class first! " +
+// "Please place the two files for callback class in front...\n");
+// return -1;
+// } else {
int retObjId = mapNewIntfaceObjId.get(newIntface);
return retObjId;
- }
+// }
}
return retObj;
}
-
-
- public static void main(String[] args) throws Exception {
-
- String[] test = { "123", "456", "789" };
- byte[] b = IoTRMIUtil.getObjectBytes(test);
-
- Boolean[] test2 = new Boolean[] { true, false, false };
- byte[] b2 = IoTRMIUtil.getObjectBytes(test2);
-
- System.out.println(Arrays.toString(b));
- System.out.println(Arrays.toString(b2));
-
- String[] c = (String[]) IoTRMIUtil.getParamObjectArray(String[].class, b);
- System.out.println(Arrays.toString(c));
-
- Boolean[] c2 = (Boolean[]) IoTRMIUtil.getParamObjectArray(Boolean[].class, b2);
- System.out.println(Arrays.toString(c2));
-
- IoTRMICall rmiCall = new IoTRMICall(1234, "localhost", 0);
- byte[] retObjBytes = { 0, 0, 4, -46, 0, 0, 0, 10, 116, 101, 115, 116, 115, 116, 114, 105, 110, 103, 0, 0, 21, 56 };
- //Class<?>[] retCls = new Class<?>[] { int.class, String.class, int.class };
- Object[] retObj = rmiCall.getReturnObjects(retObjBytes, new Class<?>[] { int.class, String.class, int.class },
- new Class<?>[] { null, null, null });
- System.out.println("Ret object 1: " + retObj[0]);
- System.out.println("Ret object 2: " + retObj[1]);
- System.out.println("Ret object 3: " + retObj[2]);
-
- // List
- /*List<Long> list = new ArrayList<Long>();
- list.add(12345678l);
- list.add(23455432l);
- list.add(34566543l);
-
- byte[] objBytes = IoTRMIUtil.getObjectBytes(list);
- System.out.println(Arrays.toString(objBytes));
- Object obj = IoTRMIUtil.getParamObject(List.class, null, Long.class, objBytes);
-
- @SuppressWarnings("unchecked")
- List<Long> listStr = (List<Long>) obj;
- System.out.println("List: " + listStr.toString());*/
-
- //@SuppressWarnings("unchecked")
- //List<Long> listStr = (List<Long>) obj;
- //System.out.println("List: " + listStr.toString());
-
- }
}
// Receive method info
methodBytes = rmiServer.receiveBytes(methodBytes);
- //System.out.println("Method: " + Arrays.toString(methodBytes));
return methodBytes;
}
return retBytes;
}
-
-
- public static void main(String[] args) throws Exception {
-
- int port = 5010;
- IoTRMIObject rmiObj = new IoTRMIObject(port);
-
- Class<?>[] retCls = new Class<?>[] { int.class, String.class, int.class };
- Object[] retObj = new Object[] { 1234, "teststring", 5432 };
-
- System.out.println("Bytes: " + Arrays.toString(rmiObj.returnToBytes(retCls, retObj)));
- }
}
} else if ( (type == String[].class) ||
(type == String.class)) {
retObj = (Object) byteArrayToStringArray(paramBytes);
- //} else if (type.isArray()) {
- // This is an array but it's more than 1 dimension, e.g. 2-dimensional,
- // 3-dimensional, etc.
- // for loop to check inner array perhaps using object
- // then call this function recursively
- // combine the result altogether
-
} else
throw new Error("IoTRMIUtil: Unrecognizable type: " + type.getName());
// Arrays
} else if (obj.getClass().isArray()) {
retObjBytes = getArrayObjectBytes(obj);
- // Set and its implementations
- /*} else if (obj instanceof Set<?>) {
- retObjBytes = setToByteArray((Set<?>) obj);*/
// List and its implementations
} else if (obj instanceof List<?>) {
retObjBytes = listToByteArray((List<?>) obj);
- // Map and its implementations
- /*} else if (obj instanceof Map<?,?>) {
- retObjBytes = mapToByteArray((Map<?,?>) obj);*/
} else
throw new Error("IoTRMIUtil: Unrecognizable object: " + obj.getClass());
}
- // Collection data structures
- /*public static byte[] setToByteArray(Set<?> set) {
-
- // Find out the class of the type
- Iterator<?> it = set.iterator();
- Object[] arrObj = null;
- Object obj = it.next();
-
- if (obj instanceof Byte) {
- arrObj = set.toArray(new Byte[set.size()]);
- } else if (obj instanceof Short) {
- arrObj = set.toArray(new Short[set.size()]);
- } else if (obj instanceof Integer) {
- arrObj = set.toArray(new Integer[set.size()]);
- } else if (obj instanceof Long) {
- arrObj = set.toArray(new Long[set.size()]);
- } else if (obj instanceof Float) {
- arrObj = set.toArray(new Float[set.size()]);
- } else if (obj instanceof Double) {
- arrObj = set.toArray(new Double[set.size()]);
- } else if (obj instanceof Character) {
- arrObj = set.toArray(new Character[set.size()]);
- } else if (obj instanceof Boolean) {
- arrObj = set.toArray(new Boolean[set.size()]);
- } else if (obj instanceof String) {
- arrObj = set.toArray(new String[set.size()]);
- } else
- throw new Error("IoTRMIUtil: Unrecognizable object: " + obj.getClass());
-
- byte[] arrObjBytes = getArrayObjectBytes(arrObj);
- return arrObjBytes;
- }*/
-
-
public static byte[] listToByteArray(List<?> list) {
// Find out the class of the type
}
- // Convert keySet of a Map
- /*public static byte[] mapKeyToByteArray(Map<?,?> map) {
-
- // Map<K,V>
- // Find out the class of the type for K
- Iterator<?> it = map.keySet().iterator();
- Object[] arrObj = null;
- Object obj = it.next();
-
- if (obj instanceof Byte) {
- arrObj = map.keySet().toArray(new Byte[map.size()]);
- } else if (obj instanceof Short) {
- arrObj = map.keySet().toArray(new Short[map.size()]);
- } else if (obj instanceof Integer) {
- arrObj = map.keySet().toArray(new Integer[map.size()]);
- } else if (obj instanceof Long) {
- arrObj = map.keySet().toArray(new Long[map.size()]);
- } else if (obj instanceof Float) {
- arrObj = map.keySet().toArray(new Float[map.size()]);
- } else if (obj instanceof Double) {
- arrObj = map.keySet().toArray(new Double[map.size()]);
- } else if (obj instanceof Character) {
- arrObj = map.keySet().toArray(new Character[map.size()]);
- } else if (obj instanceof Boolean) {
- arrObj = map.keySet().toArray(new Boolean[map.size()]);
- } else if (obj instanceof String) {
- arrObj = map.keySet().toArray(new String[map.size()]);
- } else
- throw new Error("IoTRMIUtil: Unrecognizable object: " + obj.getClass());
- byte[] arrObjBytes = getArrayObjectBytes(arrObj);
-
- return arrObjBytes;
- }
-
-
- // Convert entrySet of a Map
- public static byte[] mapEntryToByteArray(Map<?,?> map) {
-
- // Map<K,V>
- // Find out the class of the type for V
- Iterator<?> it = map.values().iterator();
- Object[] arrObj = null;
- Object obj = it.next();
-
- if (obj instanceof Byte) {
- arrObj = map.values().toArray(new Byte[map.size()]);
- } else if (obj instanceof Short) {
- arrObj = map.values().toArray(new Short[map.size()]);
- } else if (obj instanceof Integer) {
- arrObj = map.values().toArray(new Integer[map.size()]);
- } else if (obj instanceof Long) {
- arrObj = map.values().toArray(new Long[map.size()]);
- } else if (obj instanceof Float) {
- arrObj = map.values().toArray(new Float[map.size()]);
- } else if (obj instanceof Double) {
- arrObj = map.values().toArray(new Double[map.size()]);
- } else if (obj instanceof Character) {
- arrObj = map.values().toArray(new Character[map.size()]);
- } else if (obj instanceof Boolean) {
- arrObj = map.values().toArray(new Boolean[map.size()]);
- } else if (obj instanceof String) {
- arrObj = map.values().toArray(new String[map.size()]);
- } else
- throw new Error("IoTRMIUtil: Unrecognizable object: " + obj.getClass());
-
- byte[] arrObjBytes = getArrayObjectBytes(arrObj);
- return arrObjBytes;
- }
-
-
- // Merge keySet and entrySet of a Map into one long byte array
- public static byte[] mapToByteArray(Map<?,?> map) {
-
- // Put map size in the packet
- byte[] numEntries = intToByteArray(map.size());
- byte[] keySetBytes = mapKeyToByteArray(map);
- byte[] entrySetBytes = mapEntryToByteArray(map);
- byte[] mapBytes = new byte[INT_LEN + keySetBytes.length + entrySetBytes.length];
- // Copy the bytes
- System.arraycopy(numEntries, 0, mapBytes, 0, INT_LEN);
- System.arraycopy(keySetBytes, 0, mapBytes, INT_LEN, keySetBytes.length);
- System.arraycopy(entrySetBytes, 0, mapBytes, (INT_LEN + keySetBytes.length), entrySetBytes.length);
-
- return mapBytes;
- }
-
-
- // Get a Set object from bytes
- public static Object getParamSetObject(Class<?> genericType, byte[] paramBytes) {
-
- Set<Object> retSet = new HashSet<Object>();
- Object retObj = null;
- if (genericType == Byte.class) {
- Byte[] retArr = byteArrayToByteArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Short.class) {
- Short[] retArr = byteArrayToShortArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Integer.class) {
- Integer[] retArr = byteArrayToIntegerArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Long.class) {
- Long[] retArr = byteArrayToLongArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Float.class) {
- Float[] retArr = byteArrayToFloatArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Double.class) {
- Double[] retArr = byteArrayToDoubleArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Boolean.class) {
- Boolean[] retArr = byteArrayToBooleanArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == Character.class) {
- Character[] retArr = byteArrayToCharacterArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else if (genericType == String.class) {
- String[] retArr = byteArrayToStringArray(paramBytes);
- Collections.addAll(retSet, retArr);
- } else
- throw new Error("IoTRMIUtil: Unrecognizable object: " + genericType.getSimpleName());
-
- return retSet;
- }*/
-
-
// Get a List object from bytes
public static Object getParamListObject(Class<?> genericType, byte[] paramBytes) {
}
- // Get a Key array for Map object from bytes
- /*public static Object getParamMapObject(Class<?> genTypeKey, Class<?> genTypeVal, byte[] paramBytes) {
-
- // The complete set of bytes always consists of all keys followed by all values - <K,V> pairs
- // Calculate number of elements
- byte[] numElBytes = new byte[INT_LEN];
- System.arraycopy(paramBytes, 0, numElBytes, 0, INT_LEN);
- int numEl = byteArrayToInt(numElBytes);
- int keyLen = numEl * getTypeSize(genTypeKey);
- int valLen = numEl * getTypeSize(genTypeVal);
- byte[] prmKeyBytes = new byte[keyLen];
- byte[] prmValBytes = new byte[valLen];
- // Copy bytes
- System.arraycopy(paramBytes, INT_LEN, prmKeyBytes, 0, keyLen);
- System.arraycopy(paramBytes, (INT_LEN + keyLen), prmValBytes, 0, valLen);
- // Get array of keys
- Object[] retObjKey = (Object[]) getParamObjectArray(genTypeKey, prmKeyBytes);
- Object[] retObjVal = (Object[]) getParamObjectArray(genTypeVal, prmValBytes);
- // Put everything back to a Map
- Map<Object,Object> retMap = new HashMap<Object,Object>();
- IoTRMITypes.arraysToMap(retMap, retObjKey, retObjVal);
-
- return retMap;
- }*/
-
-
/**
* Converters to byte array
*/
Class<?> clsSkel = Class.forName(strObjSkelName);
Class<?> clsInt = Class.forName(STR_OBJ_CLS_PFX + "." + STR_INTERFACE_PFX +
"." + sMessage.getObjectInterfaceName());
- Class[] clsSkelParams = { clsInt, int.class }; // Port number is integer
+ Class[] clsSkelParams = { clsInt, String.class, int.class }; // Port number is integer
Constructor<?> objSkelCons = clsSkel.getDeclaredConstructor(clsSkelParams);
- Object objSkelParams[] = { objMainCls, iRMIStubPort };
+ String callbackAddress = InetAddress.getLocalHost().getHostAddress(); // Callback address is this machine's address
+ Object objSkelParams[] = { objMainCls, callbackAddress, iRMIStubPort };
// Create a new thread for each skeleton
Thread objectThread = new Thread(new Runnable() {
public void run() {
--- /dev/null
+public interface Camera {
+
+ public void init();
+ public void start();
+ public void stop();
+ public byte[] getLatestFrame();
+ public long getTimestamp();
+ public List<Resolution> getSupportedResolutions();
+ public boolean setResolution(Resolution _res);
+ public boolean setFPS(int _fps);
+ public int getMaxFPS();
+ public int getMinFPS();
+ public void registerCallback(CameraCallback _callbackTo);
+
+ capability Initialize {
+ description = "Initialize object";
+ method = "init()";
+ method = "start()";
+ method = "stop()";
+ method = "registerCallback(CameraCallback _callbackTo)";
+ }
+
+ capability Frame {
+ description = "Latest frame and timestamp";
+ method = "getLatestFrame()";
+ method = "getTimestamp()";
+ }
+
+ capability Resolution {
+ description = "Manage resolutions";
+ method = "getSupportedResolutions()";
+ method = "setResolution(Resolution _res)";
+ }
+
+ capability FPS {
+ description = "Manage FPS";
+ method = "setFPS(int _fps)";
+ method = "getMaxFPS()";
+ method = "getMinFPS()";
+ }
+
+ enum Resolution {
+ RES_1080P,
+ RES_720P,
+ RES_VGA
+ }
+}
+
+
--- /dev/null
+public interface CameraCallback {
+
+ public void newCameraFrameAvailable(Camera _camera);
+
+ capability Callback {
+ description = "Callback method";
+ method = "newCameraFrameAvailable(Camera _camera)";
+ }
+}
+
+
--- /dev/null
+
+requires CameraCallback with Callback as interface CameraSmartCallback;
+
--- /dev/null
+
+requires Camera with Initialize, Frame, Resolution, FPS as interface CameraSmart;
+
--- /dev/null
+public interface Room {
+
+ public int getRoomID();
+
+ capability Basic {
+ description = "Get room ID";
+ method = "getRoomID()";
+ }
+}
+
+
--- /dev/null
+
+requires Room with Basic as interface RoomSmart;
+
--- /dev/null
+
+requires LightBulb with Initialize, Power, SetColorProperties, GetColorProperties, GetColorPropertiesRange as interface LightBulbSmart;
+