How to use

OSCMessage

in

com.illposed.osc

  public void run() {
    if (currentFeedbackSettings != null) {
      currentFeedbackSettings.updateFeedback();
      if (oscForwarder != null) {
        OSCBundle bundle = new OSCBundle();
        for (int c = 0; c < numChannels; c++) {
          for (int b = 0; b < bins; b++) {
            OSCMessage msg = new OSCMessage(textSerialPort.getText() + "/" + binLabels[b] + "/" + c);
            Object argument = new Object();
            argument = new Double(currentFeedbackSettings.getRewardFFTBins()[b][c]);
            // argument=new Float(meanFFTBins[b][c]);
            msg.addArgument(argument);
            bundle.addPacket(msg);
            oscForwarder.forwardMessage(msg);
          }
        }
      }
    }
    this.frame.repaint();
    // oscForwarder.forwardBundle(bundle);
    // focusOMeter.setCurrentFeedback(currentFeedback);
  }
}

  public void acceptMessage(java.util.Date time, OSCMessage message)
  {
    
    System.out.println("received " + message.getAddress() + ":");
    for (Object argument : message.getArguments())
      System.out.println(argument.toString());
  }
};

  private OSCMessage parsePseudoOSCMessage(final String s) {
    if (!s.startsWith("/")) {
      return null;
    }

    String[] parts = s.split(" ");

    String address = parts[0];
    if (parts.length > 1) {
      Collection<Object> args = new ArrayList<>();
      args.addAll(Arrays.asList(parts).subList(1, parts.length));
      return new OSCMessage(address, args);
    } else {
      return new OSCMessage(address);
    }
  }
}

/**
 * Converts the byte array to a simple message.
 * Assumes that the byte array is a message.
 * @return a message containing the data specified in the byte stream
 */
private OSCMessage convertMessage(final Input rawInput) {
  final OSCMessage message = new OSCMessage();
  message.setAddress(readString(rawInput));
  final CharSequence types = readTypes(rawInput);
  for (int ti = 0; ti < types.length(); ++ti) {
    if ('[' == types.charAt(ti)) {
      // we're looking at an array -- read it in
      message.addArgument(readArray(rawInput, types, ++ti));
      // then increment i to the end of the array
      while (types.charAt(ti) != ']') {
        ti++;
      }
    } else {
      message.addArgument(readArgument(rawInput, types.charAt(ti)));
    }
  }
  return message;
}

  private void sendMessage(final int key, final boolean pressedVsReleased) {
    int note = 5 - key;
    String address = "/exo/tt/note/" + note + "/" + (pressedVsReleased ? "on" : "off");
    OSCMessage m = new OSCMessage(address);

    try {
      byte[] buffer = m.getByteArray();
      DatagramPacket packet
          = new DatagramPacket(buffer, buffer.length, musicControlAddress, musicControlPort);
      musicOscSocket.send(packet);

      // TODO: temporary
      SemanticSynchrony.getLogger().log(Level.INFO, "sent music control OSC datagram to " + musicControlAddress + ":" + musicControlPort);
    } catch (IOException e) {
      SemanticSynchrony.getLogger().log(Level.SEVERE, "error in sending OSC datagram to coordinator", e);
    } catch (Exception e) {
      SemanticSynchrony.getLogger().log(Level.SEVERE, "unexpected error in sending OSC datagram to coordinator", e);
    }
  }
}

protected String arg(final OSCMessage m,
           final int index) throws MessageParseException {
  if (index < 0) {
    throw new IllegalArgumentException();
  }
  List args = m.getArguments();
  if (index >= args.size()) {
    throw new MessageParseException("not enough arguments");
  }
  Object a = args.get(index);
  if (!(a instanceof String)) {
    throw new MessageParseException("string-typed arguments expected");
  }
  return (String) a;
}

  private void dispatchMessage(final OSCMessage message, final Date time) {
    for (final Entry<AddressSelector, OSCListener> addrList : selectorToListener.entrySet()) {
      if (addrList.getKey().matches(message.getAddress())) {
        addrList.getValue().acceptMessage(time, message);
      }
    }
  }
}

public void sendOSCMessageToCoordinator(final OSCMessage m) {
  if (getCoordinatorConnection().isActive()) {
    try {
      if (null == coordinatorOscSocket) {
        coordinatorOscPort = getCoordinatorService().description.getOscPort();
        coordinatorOscAddress = getCoordinatorService().address;
        coordinatorOscSocket = new DatagramSocket();
      }
      byte[] buffer = m.getByteArray();
      DatagramPacket packet
          = new DatagramPacket(buffer, buffer.length, coordinatorOscAddress, coordinatorOscPort);
      coordinatorOscSocket.send(packet);
      logger.log(Level.INFO, "sent OSC datagram to " + coordinatorOscAddress + ":" + coordinatorOscPort);
    } catch (IOException e) {
      logger.log(Level.SEVERE, "error in sending OSC datagram to coordinator", e);
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "unexpected error in sending OSC datagram to coordinator", t);
    }
  }
}

protected void oscSend(String command, int timestamp, String...data) {
 if (sender != null) {
  List<Object> args = new ArrayList<Object>(6);
  args.add(timestamp);
  for (int i = 0; i < data.length; i++) {
   args.add(data[i]);
  }
  OSCMessage msg = new OSCMessage("/" + command, args);
  try {
   sender.send(msg);
  } catch (Exception ex) {
   Log.error("Error sending OSC message", ex);
  }
 }
}

protected void registerCommonHandlers() {
  receiver.register(absoluteAddress(OSC_ERROR), message -> {
    List<Object> args = message.getArguments();
    if (wrongArgs(OSC_ERROR, 1, args.size())) {
      return;
    }
    logger.log(Level.SEVERE, "error message from Extend-o-Hand: " + args.get(0));
  });
  receiver.register(absoluteAddress(OSC_INFO), message -> {
    List<Object> args = message.getArguments();
    if (wrongArgs(OSC_INFO, 1, args.size())) {
      return;
    }
    logger.log(Level.INFO, "info message from Extend-o-Hand: " + args.get(0));
  });
  receiver.register(absoluteAddress(OSC_PING), message -> {
    // note: currently, no argument is provided, or needed;
    // the ping is used by the Extend-o-Hand to notify the user of a connection
    logger.info("ping received from Extend-o-Hand. Replying.");
    sendPingReplyMessage();
  });
  receiver.register(absoluteAddress(OSC_PING_REPLY), message -> {
    // note: argument is ignored for now; in future, it could be used to synchronize clocks
    // we assume this reply is a response to the latest ping
    // TODO: we don't have to... why not send and receive latestPing in the message
    long delay = System.currentTimeMillis() - latestPing;
    logger.log(Level.INFO, "ping reply received from Extend-o-Hand in " + delay + "ms");
  });
}

/**
 * Passes an OSC message to the attached sender.
 * Note: this method is synchronized for the sake of senders of uncertain thread safety
 *
 * @param message the OSC message to send
 */
public synchronized void send(final OSCMessage message) {
  if (null == sender) {
    logger.warning("can't send message with address " + message.getAddress() + "; no sender has been defined");
  } else {
    if (null != messages) {
      messages.offer(message);
    } else {
      if (throttlingPeriod > 0) {
        throttle();
      }
      sendInternal(message);
    }
  }
}

public void sendOSCMessageToCoordinator(final OSCMessage m) {
  if (getCoordinatorConnection().isActive()) {
    try {
      if (null == coordinatorOscSocket) {
        coordinatorOscPort = getCoordinatorService().description.getOscPort();
        coordinatorOscAddress = getCoordinatorService().address;
        coordinatorOscSocket = new DatagramSocket();
      }
      byte[] buffer = m.getByteArray();
      DatagramPacket packet
          = new DatagramPacket(buffer, buffer.length, coordinatorOscAddress, coordinatorOscPort);
      coordinatorOscSocket.send(packet);
      logger.log(Level.INFO, "sent OSC datagram to " + coordinatorOscAddress + ":" + coordinatorOscPort);
    } catch (IOException e) {
      logger.log(Level.SEVERE, "error in sending OSC datagram to coordinator", e);
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "unexpected error in sending OSC datagram to coordinator", t);
    }
  }
}

protected void oscSend(String command, int timestamp, int...data) {
 if (sender != null) {
  List<Object> args = new ArrayList<Object>(6);
  args.add(timestamp);
  for (int i = 0; i < data.length; i++) {
   args.add(data[i]);
  }
  OSCMessage msg = new OSCMessage("/" + command, args);
  try {
   sender.send(msg);
  } catch (Exception ex) {
   Log.error("Error sending OSC message", ex);
  }
 }
}

OSCMessage msg = new OSCMessage(outputs[cb]);
Object argument = new Object();
float val = ((float) fftData.rewardFFTBins[b][c] - minValues[cb]) / rangeValues[cb];
msg.addArgument(argument);
bundle.addPacket(msg);

public void start() throws SocketException {
  OSCListener handshakeListener = (date, oscMessage) -> {
    List<Object> args = oscMessage.getArguments();
    if (badArgs(args, 1, SmSnActivityOntology.EXO_ACTIVITY_HANDSHAKE)) {
      return;
    List<Object> args = oscMessage.getArguments();
    if (badArgs(args, 1, SmSnActivityOntology.EXO_ACTIVITY_HANDOFF)) {
      return;
    List<Object> args = oscMessage.getArguments();
    if (badArgs(args, 2, SmSnActivityOntology.EXO_ACTIVITY_GIVE)) {
      return;
    List<Object> args = oscMessage.getArguments();
    if (badArgs(args, 1, SmSnActivityOntology.EXO_ACTIVITY_HIGHFIVE)) {
      return;
      logger.info("info message via OSC: " + oscMessage.getArguments().get(0));
      logger.warning("error message via OSC: " + oscMessage.getArguments().get(0));

/**
 * Passes an OSC message to the attached sender.
 * Note: this method is synchronized for the sake of senders of uncertain thread safety
 *
 * @param message the OSC message to send
 */
public synchronized void send(final OSCMessage message) {
  if (null == sender) {
    logger.warning("can't send message with address " + message.getAddress() + "; no sender has been defined");
  } else {
    if (null != messages) {
      messages.offer(message);
    } else {
      if (throttlingPeriod > 0) {
        throttle();
      }
      sendInternal(message);
    }
  }
}

protected void oscSend(String command, int timestamp, float...data) {
 if (sender != null) {
  List<Object> args = new ArrayList<Object>(6);
  args.add(timestamp);
  for (int i = 0; i < data.length; i++) {
   args.add(data[i]);
  }
  OSCMessage msg = new OSCMessage("/" + command, args);
  try {
   sender.send(msg);
  } catch (Exception ex) {
   Log.error("Error sending OSC message", ex);
  }
 }
}

  public void sendMulticueMessage(final int toneFrequency,
                  final int toneDurationMs,
                  final int color,
                  final int vibrationDurationMs) {
    if (toneFrequency < 0 || toneFrequency > 20000) {
      throw new IllegalArgumentException("tone frequency is out of range: " + vibrationDurationMs);
    }

    if (toneDurationMs < 0 || toneDurationMs > 60000) {
      throw new IllegalArgumentException("tone duration is out of range: " + toneDurationMs);
    }

    if (vibrationDurationMs < 0 || vibrationDurationMs > 60000) {
      throw new IllegalArgumentException("vibration duration is out of range: " + vibrationDurationMs);
    }

    OSCMessage m = new OSCMessage(absoluteAddress(OSC_MULTI));
    m.addArgument(toneFrequency);
    m.addArgument(toneDurationMs);
    m.addArgument(color);
    m.addArgument(vibrationDurationMs);
    send(m);
  }
}

List<Object> args = message.getArguments();
if (wrongArgs(OSC_KEYS, 1, args.size())) {
  return;
List<Object> args = message.getArguments();
if (wrongArgs(OSC_PHOTO_DATA, 7, args.size())) {
  return;

/**
 * Routes an OSC message to the appropriate handler
 *
 * @param message the received message to be handled
 * @return whether a matching handler was found
 */
public boolean receive(final OSCMessage message) {
  OscMessageHandler handler = handlers.get(message.getAddress());
  boolean handled;
  if (null == handler) {
    handled = false;
  } else {
    handler.handle(message);
    handled = true;
  }
  // give the message to the listeners after any time-critical handlers have been served
  for (OSCMessageListener listener : listeners) {
    listener.handle(message);
  }
  return handled;
}