congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
OSCMessage
Code IndexAdd Tabnine to your IDE (free)

How to use
OSCMessage
in
com.illposed.osc

Best Java code snippets using com.illposed.osc.OSCMessage (Showing top 20 results out of 315)

origin: fossasia/neurolab-desktop

  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);
  }
}
origin: fossasia/neurolab-desktop

  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());
  }
};
origin: synchrony/smsn

  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);
    }
  }
}
origin: hoijui/JavaOSC

/**
 * 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;
}
origin: synchrony/smsn

  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);
    }
  }
}
origin: synchrony/smsn

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;
}
origin: hoijui/JavaOSC

  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);
      }
    }
  }
}
origin: net.fortytwo.smsn/smsn-p2p

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);
    }
  }
}
origin: mirador/mirador

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);
  }
 }
}
origin: synchrony/smsn

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");
  });
}
origin: net.fortytwo.smsn/smsn-p2p

/**
 * 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);
    }
  }
}
origin: synchrony/smsn

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);
    }
  }
}
origin: mirador/mirador

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);
  }
 }
}
origin: fossasia/neurolab-desktop

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);
origin: synchrony/smsn

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));
origin: synchrony/smsn

/**
 * 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);
    }
  }
}
origin: mirador/mirador

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);
  }
 }
}
origin: synchrony/smsn

  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);
  }
}
origin: synchrony/smsn

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;
origin: net.fortytwo.smsn/smsn-p2p

/**
 * 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;
}
com.illposed.oscOSCMessage

Javadoc

An simple (non-bundle) OSC message. An OSC Message is made up of an Address Pattern (the receiver of the message) and Arguments (the content of the message).

Most used methods

  • <init>
    Creates an OSCMessage with an address and arguments already initialized.
  • addArgument
    Add an argument to the list of arguments.
  • getArguments
    The arguments of this message.
  • getAddress
  • getByteArray
  • checkAddress
    Throws an exception if the given address is invalid. We explicitly allow null here, because we want
  • computeAddressByteArray
    Convert the address into a byte array. Used internally only.
  • computeArgumentsByteArray
    Convert the arguments into a byte array. Used internally only.
  • contentChanged
  • isValidAddress
    Checks whether a given string is a valid OSC Address Pattern.
  • setAddress
    Set the address of this message.
  • setAddress

Popular in Java

  • Start an intent from android
  • runOnUiThread (Activity)
  • getContentResolver (Context)
  • scheduleAtFixedRate (Timer)
  • URLEncoder (java.net)
    This class is used to encode a string using the format required by application/x-www-form-urlencoded
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • Manifest (java.util.jar)
    The Manifest class is used to obtain attribute information for a JarFile and its entries.
  • JList (javax.swing)
  • JTable (javax.swing)
  • Options (org.apache.commons.cli)
    Main entry-point into the library. Options represents a collection of Option objects, which describ
  • Top 12 Jupyter Notebook Extensions
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now