Exchanging cameras between benchmarks; updating database
[iot2.git] / benchmarks / Java / HomeSecurityController / CameraCallback_Skeleton.java
1 package HomeSecurityController;
2
3 import java.io.IOException;
4 import java.util.List;
5 import java.util.ArrayList;
6 import java.util.Arrays;
7 import java.util.Map;
8 import java.util.HashMap;
9 import java.util.concurrent.atomic.AtomicBoolean;
10 import iotrmi.Java.IoTRMIComm;
11 import iotrmi.Java.IoTRMICommClient;
12 import iotrmi.Java.IoTRMICommServer;
13 import iotrmi.Java.IoTRMIUtil;
14
15 import iotcode.interfaces.*;
16
17 public class CameraCallback_Skeleton implements CameraCallback {
18
19         private CameraCallback mainObj;
20         private int objectId = 3;
21         // Communications and synchronizations
22         private IoTRMIComm rmiComm;
23         private AtomicBoolean didAlreadyInitWaitInvoke;
24         private AtomicBoolean methodReceived;
25         private byte[] methodBytes = null;
26         // Permissions
27         private static Integer[] object3Permission = { 0 };
28         private static List<Integer> set3Allowed;
29         
30
31         public CameraCallback_Skeleton(CameraCallback _mainObj, int _portSend, int _portRecv) throws Exception {
32                 mainObj = _mainObj;
33                 rmiComm = new IoTRMICommServer(_portSend, _portRecv);
34                 set3Allowed = new ArrayList<Integer>(Arrays.asList(object3Permission));
35                 IoTRMIUtil.mapSkel.put(_mainObj, this);
36                 IoTRMIUtil.mapSkelId.put(_mainObj, objectId);
37                 didAlreadyInitWaitInvoke = new AtomicBoolean(false);
38                 methodReceived = new AtomicBoolean(false);
39                 rmiComm.registerSkeleton(objectId, methodReceived);
40                 Thread thread1 = new Thread() {
41                         public void run() {
42                                 try {
43                                         ___waitRequestInvokeMethod();
44                                 }
45                                 catch (Exception ex)
46                                 {
47                                         ex.printStackTrace();
48                                 }
49                         }
50                 };
51                 thread1.start();
52         }
53
54         public CameraCallback_Skeleton(CameraCallback _mainObj, IoTRMIComm _rmiComm, int _objectId) throws Exception {
55                 mainObj = _mainObj;
56                 rmiComm = _rmiComm;
57                 objectId = _objectId;
58                 set3Allowed = new ArrayList<Integer>(Arrays.asList(object3Permission));
59                 didAlreadyInitWaitInvoke = new AtomicBoolean(false);
60                 methodReceived = new AtomicBoolean(false);
61                 rmiComm.registerSkeleton(objectId, methodReceived);
62         }
63
64         public boolean didAlreadyInitWaitInvoke() {
65                 return didAlreadyInitWaitInvoke.get();
66         }
67
68         public void newCameraFrameAvailable(byte latestFrame[], long timeStamp) {
69                 mainObj.newCameraFrameAvailable(latestFrame, timeStamp);
70         }
71
72         public void ___newCameraFrameAvailable() {
73                 byte[] localMethodBytes = methodBytes;
74                 rmiComm.setGetMethodBytes();
75                 Object[] paramObj = rmiComm.getMethodParams(new Class<?>[] { byte[].class, long.class }, new Class<?>[] { null, null }, localMethodBytes);
76                 newCameraFrameAvailable((byte[]) paramObj[0], (long) paramObj[1]);
77         }
78
79         public void ___waitRequestInvokeMethod() throws IOException {
80                 didAlreadyInitWaitInvoke.compareAndSet(false, true);
81                 while (true) {
82                         if (!methodReceived.get()) {
83                                 continue;
84                         }
85                         methodBytes = rmiComm.getMethodBytes();
86                         methodReceived.set(false);
87                         int _objectId = IoTRMIComm.getObjectId(methodBytes);
88                         int methodId = IoTRMIComm.getMethodId(methodBytes);
89                         if (_objectId == objectId) {
90                                 if (!set3Allowed.contains(methodId)) {
91                                         throw new Error("Object with object Id: " + _objectId + "  is not allowed to access method: " + methodId);
92                                 }
93                         }
94                         else {
95                                 continue;
96                         }
97                         switch (methodId) {
98                                 case 0:
99                                 new Thread() {
100                                         public void run() {
101                                                 try {
102                                                         ___newCameraFrameAvailable();
103                                                 }
104                                                 catch (Exception ex) {
105                                                         ex.printStackTrace();
106                                                 }
107                                         }
108                                 }.start();
109                                 break;
110                                 default: 
111                                 throw new Error("Method Id " + methodId + " not recognized!");
112                         }
113                 }
114         }
115
116 }