benchmarks/Java/IrrigationController/CameraSmart_Stub.java

   1 package IrrigationController;
   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 CameraSmart_Stub implements CameraSmart {
  18
  19         private int objectId = 2;
  20         private IoTRMIComm rmiComm;
  21         // Synchronization variables
  22         private AtomicBoolean retValueReceived8 = new AtomicBoolean(false);
  23         private AtomicBoolean retValueReceived7 = new AtomicBoolean(false);
  24         private AtomicBoolean retValueReceived9 = new AtomicBoolean(false);
  25         private AtomicBoolean retValueReceived6 = new AtomicBoolean(false);
  26         private AtomicBoolean retValueReceived4 = new AtomicBoolean(false);
  27         private AtomicBoolean retValueReceived3 = new AtomicBoolean(false);
  28         private AtomicBoolean retValueReceived5 = new AtomicBoolean(false);
  29
  30
  31         public CameraSmart_Stub(int _localPortSend, int _localPortRecv, int _portSend, int _portRecv, String _skeletonAddress, int _rev) throws Exception {
  32                 if (_localPortSend != 0 && _localPortRecv != 0) {
  33                         rmiComm = new IoTRMICommClient(_localPortSend, _localPortRecv, _portSend, _portRecv, _skeletonAddress, _rev);
  34                 } else
  35                 {
  36                         rmiComm = new IoTRMICommClient(_portSend, _portRecv, _skeletonAddress, _rev);
  37                 }
  38                 rmiComm.registerStub(objectId, 8, retValueReceived8);
  39                 rmiComm.registerStub(objectId, 7, retValueReceived7);
  40                 rmiComm.registerStub(objectId, 9, retValueReceived9);
  41                 rmiComm.registerStub(objectId, 6, retValueReceived6);
  42                 rmiComm.registerStub(objectId, 4, retValueReceived4);
  43                 rmiComm.registerStub(objectId, 3, retValueReceived3);
  44                 rmiComm.registerStub(objectId, 5, retValueReceived5);
  45                 IoTRMIUtil.mapStub.put(objectId, this);
  46         }
  47
  48         public CameraSmart_Stub(IoTRMIComm _rmiComm, int _objectId) throws Exception {
  49                 rmiComm = _rmiComm;
  50                 objectId = _objectId;
  51                 rmiComm.registerStub(objectId, 8, retValueReceived8);
  52                 rmiComm.registerStub(objectId, 7, retValueReceived7);
  53                 rmiComm.registerStub(objectId, 9, retValueReceived9);
  54                 rmiComm.registerStub(objectId, 6, retValueReceived6);
  55                 rmiComm.registerStub(objectId, 4, retValueReceived4);
  56                 rmiComm.registerStub(objectId, 3, retValueReceived3);
  57                 rmiComm.registerStub(objectId, 5, retValueReceived5);
  58         }
  59
  60         public int getMaxFPS() {
  61                 int methodId = 8;
  62                 Class<?> retType = int.class;
  63                 Class<?>[] paramCls = new Class<?>[] {  };
  64                 Object[] paramObj = new Object[] {  };
  65                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  66                 // Waiting for return value
  67                 while (!retValueReceived8.get());
  68                 Object retObj = rmiComm.getReturnValue(retType, null);
  69                 retValueReceived8.set(false);
  70                 rmiComm.setGetReturnBytes();
  71
  72                 return (int)retObj;
  73         }
  74
  75         public boolean setFPS(int _fps) {
  76                 int methodId = 7;
  77                 Class<?> retType = boolean.class;
  78                 Class<?>[] paramCls = new Class<?>[] { int.class };
  79                 Object[] paramObj = new Object[] { _fps };
  80                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  81                 // Waiting for return value
  82                 while (!retValueReceived7.get());
  83                 Object retObj = rmiComm.getReturnValue(retType, null);
  84                 retValueReceived7.set(false);
  85                 rmiComm.setGetReturnBytes();
  86
  87                 return (boolean)retObj;
  88         }
  89
  90         public int getMinFPS() {
  91                 int methodId = 9;
  92                 Class<?> retType = int.class;
  93                 Class<?>[] paramCls = new Class<?>[] {  };
  94                 Object[] paramObj = new Object[] {  };
  95                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  96                 // Waiting for return value
  97                 while (!retValueReceived9.get());
  98                 Object retObj = rmiComm.getReturnValue(retType, null);
  99                 retValueReceived9.set(false);
 100                 rmiComm.setGetReturnBytes();
 101
 102                 return (int)retObj;
 103         }
 104
 105         public boolean setResolution(Resolution _res) {
 106                 int methodId = 6;
 107                 Class<?> retType = boolean.class;
 108                 int paramEnum0[] = new int[1];
 109                 paramEnum0[0] = _res.ordinal();
 110                 Class<?>[] paramCls = new Class<?>[] { int[].class };
 111                 Object[] paramObj = new Object[] { paramEnum0 };
 112                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 113                 // Waiting for return value
 114                 while (!retValueReceived6.get());
 115                 Object retObj = rmiComm.getReturnValue(retType, null);
 116                 retValueReceived6.set(false);
 117                 rmiComm.setGetReturnBytes();
 118
 119                 return (boolean)retObj;
 120         }
 121
 122         public void stop() {
 123                 int methodId = 2;
 124                 Class<?> retType = void.class;
 125                 Class<?>[] paramCls = new Class<?>[] {  };
 126                 Object[] paramObj = new Object[] {  };
 127                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 128         }
 129
 130         public void start() {
 131                 int methodId = 1;
 132                 Class<?> retType = void.class;
 133                 Class<?>[] paramCls = new Class<?>[] {  };
 134                 Object[] paramObj = new Object[] {  };
 135                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 136         }
 137
 138         public long getTimestamp() {
 139                 int methodId = 4;
 140                 Class<?> retType = long.class;
 141                 Class<?>[] paramCls = new Class<?>[] {  };
 142                 Object[] paramObj = new Object[] {  };
 143                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 144                 // Waiting for return value
 145                 while (!retValueReceived4.get());
 146                 Object retObj = rmiComm.getReturnValue(retType, null);
 147                 retValueReceived4.set(false);
 148                 rmiComm.setGetReturnBytes();
 149
 150                 return (long)retObj;
 151         }
 152
 153         public byte[] getLatestFrame() {
 154                 int methodId = 3;
 155                 Class<?> retType = byte[].class;
 156                 Class<?>[] paramCls = new Class<?>[] {  };
 157                 Object[] paramObj = new Object[] {  };
 158                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 159                 // Waiting for return value
 160                 while (!retValueReceived3.get());
 161                 Object retObj = rmiComm.getReturnValue(retType, null);
 162                 retValueReceived3.set(false);
 163                 rmiComm.setGetReturnBytes();
 164
 165                 return (byte[])retObj;
 166         }
 167
 168         public void init() {
 169                 int methodId = 0;
 170                 Class<?> retType = void.class;
 171                 Class<?>[] paramCls = new Class<?>[] {  };
 172                 Object[] paramObj = new Object[] {  };
 173                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 174         }
 175
 176         public void registerCallback(CameraCallback _callbackTo) {
 177                 int[] objIdSent0 = new int[1];
 178                 try {
 179                         if (!IoTRMIUtil.mapSkel.containsKey(_callbackTo)) {
 180                                 int newObjIdSent = rmiComm.getObjectIdCounter();
 181                                 objIdSent0[0] = newObjIdSent;
 182                                 rmiComm.decrementObjectIdCounter();
 183                                 CameraCallback_Skeleton skel0 = new CameraCallback_Skeleton(_callbackTo, rmiComm, newObjIdSent);
 184                                 IoTRMIUtil.mapSkel.put(_callbackTo, skel0);
 185                                 IoTRMIUtil.mapSkelId.put(_callbackTo, newObjIdSent);
 186                                 Thread thread = new Thread() {
 187                                         public void run() {
 188                                                 try {
 189                                                         skel0.___waitRequestInvokeMethod();
 190                                                         } catch (Exception ex) {
 191                                                         ex.printStackTrace();
 192                                                         throw new Error("Exception when trying to run ___waitRequestInvokeMethod() for CameraCallback_Skeleton!");
 193                                                 }
 194                                         }
 195                                 };
 196                                 thread.start();
 197                                 while(!skel0.didAlreadyInitWaitInvoke());
 198                         }
 199                         else
 200                         {
 201                                 int newObjIdSent = IoTRMIUtil.mapSkelId.get(_callbackTo);
 202                                 objIdSent0[0] = newObjIdSent;
 203                         }
 204                 } catch (Exception ex) {
 205                         ex.printStackTrace();
 206                         throw new Error("Exception when generating skeleton objects!");
 207                 }
 208
 209                 int methodId = 10;
 210                 Class<?> retType = void.class;
 211                 Class<?>[] paramCls = new Class<?>[] { int[].class };
 212                 Object[] paramObj = new Object[] { objIdSent0 };
 213                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 214         }
 215
 216         public List<Resolution> getSupportedResolutions() {
 217                 int methodId = 5;
 218                 Class<?> retType = int[].class;
 219                 Class<?>[] paramCls = new Class<?>[] {  };
 220                 Object[] paramObj = new Object[] {  };
 221                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 222                 // Waiting for return value
 223                 while (!retValueReceived5.get());
 224                 Object retObj = rmiComm.getReturnValue(retType, null);
 225                 retValueReceived5.set(false);
 226                 rmiComm.setGetReturnBytes();
 227
 228                 int[] retEnum = (int[]) retObj;
 229                 Resolution[] enumVals = Resolution.values();
 230                 int retLen = retEnum.length;
 231                 List<Resolution> enumRetVal = new ArrayList<Resolution>();
 232                 for (int i = 0; i < retLen; i++) {
 233                         enumRetVal.add(enumVals[retEnum[i]]);
 234                 }
 235                 return enumRetVal;
 236         }
 237
 238 }