ipc.java

卡内基梅隆大学（CMU）开发的移动机器人控制开发软件包。可对多种机器人进行控制

    } else {
	timerHashTable.put(Integer.toString(refVal), hashKey);
      timerRef.cptr = refVal;
      return IPC_OK;
    }
  }

  public static int addOneShotTimer (long tdelay, TIMER_HANDLER_TYPE handler) {
    return IPC.addTimer(tdelay, 1, handler);
  }

  public static int addPeriodicTimer (long tdelay,
				      TIMER_HANDLER_TYPE handler) {
    return IPC.addTimer(tdelay, TRIGGER_FOREVER, handler);
  }

  public static int removeTimer (Class handlerClass) {
    String hashKey = handlerClass.getName();
    String handlerNum = (String)timerHashTable.get(hashKey);

    timerHashTable.remove(hashKey);
    timerHashTable.remove(handlerNum);

    return IPC_removeTimer(Integer.parseInt(handlerNum));
  }

  public static int removeTimer (TIMER_HANDLER_TYPE handler) {
    return removeTimer(handler.getClass());
  }

  public static int removeTimerByRef (TIMER_REF timerRef) {
    String hashKey = Integer.toString(timerRef.cptr);
    String handlerNum = (String)timerHashTable.get(hashKey);

    timerHashTable.remove(hashKey);
    timerHashTable.remove(handlerNum);

    return IPC_removeTimerByRef(timerRef.cptr);
  }

  public static long timeInMillis () {
    return IPC_timeInMillis();
  }

  /*****************************************************************
   *
   *    INTERNAL FUNCTIONS
   *
   ****************************************************************/

  private native static int IPC_initialize();
  private native static int IPC_connectModule(String moduleName,
					      String serverName);
  private native static int IPC_connect(String moduleName);
  private native static int IPC_disconnect();
  private native static boolean IPC_isConnected();
  private native static boolean IPC_isModuleConnected(String moduleName);
  private native static int IPC_defineMsg(String msgName, String formatString);
  private native static boolean IPC_isMsgDefined(String msgName);
  private native static int IPC_dataLength (int msgInstance);
  private native static String IPC_msgInstanceName (int msgInstance);
  private native static int IPC_msgInstanceFormatter (int msgInstance);
  private native static int IPC_subscribe(String msgName, String handlerName,
					  int handlerNum);
  private native static int IPC_unsubscribe(String msgName, String handlerName);
  private native static int IPC_subscribeFD(int fd);
  private native static int IPC_unsubscribeFD(int fd);
  private native static int IPC_publish (String msgName, 
					 int length, int byteArray);
  private native static int IPC_listen(long timeoutMSecs);
  private native static int IPC_listenClear(long timeoutMSecs);
  private native static int IPC_listenWait(long timeoutMSecs);
  private native static int IPC_handleMessage(long timeoutMSecs);
  private native static int IPC_dispatch();
  private native static void IPC_perror(String msg);
  private native static int IPC_setCapacity (int capacity);
  private native static int IPC_setMsgQueueLength (String msgName, 
						   int queueLength);
  private native static int IPC_setMsgPriority (String msgName, int priority);
  private native static int IPC_setVerbosity (int verbosity);
  private native static int IPC_subscribeConnect ();
  private native static int IPC_subscribeDisconnect ();
  private native static int IPC_unsubscribeConnect ();
  private native static int IPC_unsubscribeDisconnect ();
  private native static int IPC_subscribeHandlerChange (String msgName);
  private native static int IPC_unsubscribeHandlerChange (String msgName);
  private native static int IPC_numHandlers (String msgName); 
  private native static int IPC_respond (int msgInstance, String msgName,
					 int length, int byteArray);
  private native static int IPC_queryNotify (String msgName,
					     int length, int byteArray,
					     int handlerNum);
  private native static int IPC_queryResponse (String msgName,
					       int length, int byteArray,
					       queryResponse response,
					       long timeoutMSecs);
  private native static int IPC_defineFormat (String formatName,
					      String formatString);
  private native static int IPC_checkMsgFormats (String formatName,
						 String formatString);
  private native static int IPC_getContext (); 
  private native static int IPC_setContext (int context);
  private native static long IPC_getPID();
  private native static void IPC_freeByteArray(int byteArray);
  private native static int IPC_msgFormatter(String msgName);
  private native static int IPC_addTimer(long tdelay, long count, 
					 int handlerNum);
  private native static int IPC_addTimerGetRef(long tdelay, long count, 
					       int handlerNum);
  private native static int IPC_removeTimer(int handlerNum);
  private native static int IPC_removeTimerByRef(int timerRef);
  private native static long IPC_timeInMillis();

  private static Map msgHashTable = Collections.synchronizedMap(new HashMap());
  private static List connectHandlers =
      Collections.synchronizedList(new ArrayList());
  private static List disconnectHandlers = 
      Collections.synchronizedList(new ArrayList());
  private static Map handlerChangeHashTable =
      Collections.synchronizedMap(new HashMap());
  private static Map fdHashTable = Collections.synchronizedMap(new HashMap());
  private static Map timerHashTable =
      Collections.synchronizedMap(new HashMap());
  private static int handlerNumber = 0;

  private static class queryResponse {
    int byteArray;
    int formatter;
  }

  private static class handlerHashData {
    handlerHashData (HANDLER_TYPE msgHandler, Class theClass) {
      handler = msgHandler; dataClass = theClass; }
    HANDLER_TYPE handler;
    Class dataClass;
  }

  // Change primitive types into types that IPC can handle (same with
  //  the JAVA object versions of those types).
  private static Class coerceDataClass (Class dataClass) {
    if (dataClass == int.class || dataClass == Integer.class) {
      return formatters.IPCInteger.class;
    } else if (dataClass == double.class || dataClass == Double.class) {
      return formatters.IPCDouble.class;
    } else if (dataClass == String.class) {
      return formatters.IPCString.class;
    } else if (dataClass == float.class || dataClass == Float.class) {
      return formatters.IPCFloat.class;
    } else if (dataClass == short.class || dataClass == Short.class) {
      return formatters.IPCShort.class;
    } else if (dataClass == long.class || dataClass == Long.class) {
      return formatters.IPCLong.class;
    } else if (dataClass == char.class) {
      return formatters.IPCChar.class;
    } else if (dataClass == boolean.class || dataClass == Boolean.class) {
      return formatters.IPCBoolean.class;
    } else if (dataClass == byte.class || dataClass == Byte.class) {
      return formatters.IPCByte.class;
    } else {
      return dataClass;
    }
  }

  // Change Java types that "objectize" primitives (plus String)
  //   to types that IPC can handle.
  private static Object coerceDataObject (Object dataObject) {
    Class dataClass = dataObject.getClass();

    if (formatters.IPCPrim.class.isAssignableFrom(dataClass)) {
      return dataObject;
    } else if (dataClass == Integer.class) {
      return new formatters.IPCInteger(((Integer)dataObject).intValue());
    } else if (dataClass == Double.class) {
      return new formatters.IPCDouble(((Double)dataObject).intValue());
    } else if (dataClass == String.class) {
      return new formatters.IPCString((String)dataObject);
    } else if (dataClass == Float.class) {
      return new formatters.IPCFloat(((Float)dataObject).floatValue());
    } else if (dataClass == Short.class) {
      return new formatters.IPCShort(((Short)dataObject).shortValue());
    } else if (dataClass == Long.class) {
      return new formatters.IPCLong(((Long)dataObject).longValue());
    } else if (dataClass == Boolean.class) {
      return new formatters.IPCBoolean(((Boolean)dataObject).booleanValue());
    } else if (dataClass == Byte.class) {
      return new formatters.IPCByte(((Byte)dataObject).byteValue());
    } else {
      return dataObject;
    }
  }

  private static Object unmarshallMsgData (int formatter, int byteArray,
					   Class msgDataClass) 
      throws Exception {
    Object object = null;

    // Throw an exception if class does not match formatter
    formatters.checkDataClass(formatter, msgDataClass);

    if (msgDataClass.isArray()) {
      // Create a top-level fixed-length array, based on the formatter.
      object = formatters.createFixedArray(msgDataClass.getComponentType(),
					   formatter);
    } else {
      // Create an object type that Java IPC can handle
      object = coerceDataClass(msgDataClass).newInstance();
    }
    formatters.unmarshall(formatter, byteArray, object);
    IPC_freeByteArray(byteArray);
    if (formatters.IPCPrim.class.isAssignableFrom(object.getClass())) {
	object = ((formatters.IPCPrim)object).coerce();
    }

    return object;
  }

  private static void msgCallbackHandler (int handlerNum, int msgInstance,
					  int byteArray) {
    handlerHashData handlerData = 
	(handlerHashData)msgHashTable.get(Integer.toString(handlerNum));

    if (handlerData != null) {
      Object object;
      try {
	  int formatter = IPC_msgInstanceFormatter(msgInstance);
	  object = unmarshallMsgData(formatter, byteArray,
				     handlerData.dataClass);
	  handlerData.handler.handle(new MSG_INSTANCE(msgInstance), object);
      } catch ( Exception e) {
	  handleException("msgCallbackHandler", 
			  IPC_msgInstanceName(msgInstance), e);
      }
    } else
      System.out.println("Ooops -- no handler for "+
			 IPC_msgInstanceName(msgInstance));
  }

  private static void queryNotifyCallbackHandler (int handlerNum,
						  int msgInstance,
						  int byteArray) {
    String hashKey = Integer.toString(handlerNum);
    handlerHashData handlerData = (handlerHashData)msgHashTable.get(hashKey);

    msgHashTable.remove(hashKey);
    if (handlerData != null) {
      Object object;
      try {
	object = unmarshallMsgData(IPC_msgInstanceFormatter(msgInstance),
				   byteArray, handlerData.dataClass);
	handlerData.handler.handle(new MSG_INSTANCE(msgInstance), object);
      } catch ( Exception e) { 
	handleException("queryNotifyCallbackHandler", 
			IPC_msgInstanceName(msgInstance), e);
      }
    } else
      System.out.println("Ooops -- no query notification handler for "+
			 IPC_msgInstanceName(msgInstance));
  }

  private static void fdCallbackHandler (int fd) {
    FD_HANDLER_TYPE handler =
      (FD_HANDLER_TYPE)fdHashTable.get(Integer.toString(fd));

    if (handler != null) {
      handler.handle(fd);
    } else
      System.out.println("Ooops -- no handler for fd");
  }

  private static void timerCallbackHandler (int handlerNum, long currentTime,
					    long scheduledTime) {
    TIMER_HANDLER_TYPE handler =
      (TIMER_HANDLER_TYPE)timerHashTable.get(Integer.toString(handlerNum));

    if (handler != null) {
      handler.handle(currentTime, scheduledTime);
    } else
      System.out.println("Ooops -- no handler for timer");
  }

  private static void connectCallbackHandler (String moduleName,
					      boolean isConnect) {
    Iterator iter = (isConnect ? connectHandlers.iterator()
		     : disconnectHandlers.iterator());

    while (iter.hasNext()) {
      CONNECT_HANDLE_TYPE handler = (CONNECT_HANDLE_TYPE)iter.next();
      handler.handle(moduleName);
    }
  }

  private static void changeCallbackHandler (String msgName, int numHandlers) {
    List handlerList = (List)handlerChangeHashTable.get(msgName);
    if (handlerList == null) {
      System.out.println("Ooops -- no change handlers for message "+msgName);
      return;
    }
    Iterator iter = handlerList.iterator();

    while (iter.hasNext()) {
      ((CHANGE_HANDLE_TYPE)iter.next()).handle(msgName, numHandlers);
    }
  }

  private static void handleException(String where, String msgName, 
				      Exception e) {
    System.err.println("ERROR: "+ where +": For message \""+msgName +"\": "+ 
		       e.getMessage());
    e.printStackTrace();
  }

  static {
    LDLoad.loadFromJar("Carmen.jar", "libipcjava.so");
  }
}