WPIUtilJNI.java

// TODO - RobotCore - Modified files
 
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
 
package org.wpilib.util;
 
import org.wpilib.hardware.hal.HALUtil;
import org.wpilib.hardware.hal.PiNotifier.PiSignals;
 
import robotCore.RobotCore;
 
// import java.nio.ByteBuffer;

public class WPIUtilJNI  {
    public static void waitForObject(int handle) throws InterruptedException {
    //   // System.out.println(String.format("WPIUtilJNI.waitForObject(%d)", handle));
    //   // throw new UnsupportedOperationException("Unimplemented method 'waitForObject'");
    //   if (handle > 0) {
    //     NotifierJNI.waitForIt(handle);  // indicates notifier handle
    //   }
      PiSignals.waitForObject(handle);
        // TODO - Must verify
    }
 
    public static long now() {
    // throw new UnsupportedOperationException("Unimplemented method 'now'");
        return HALUtil.getMonotonicTime();
    }
 
    static long m_startTime = 0;
 
    public static long getProgramStartTime() {
      if (m_startTime == 0) {
        m_startTime = HALUtil.getMonotonicTime();
      }
      // System.out.println(String.format("NetworkTablesJNI.getProgramStartTime: %d", m_startTime));
    // throw new UnsupportedOperationException("Unimplemented method 'getProgramStartTime'");
        return m_startTime;       // TODO - Must verify
    }
 
    static private RobotCore m_robotCore;
 
    public static void checkMsvcRuntime() {
      m_robotCore = new RobotCore();
 
    // throw new UnsupportedOperationException("Unimplemented method 'checkMsvcRuntime'");
        // TODO - Must review
    }
 
  public static int makeEvent(boolean manualReset, boolean initialState) {
    // System.out.println(String.format("WPIUtilJNI.makeEvent(%b, %b", manualReset, initialState));
    // throw new UnsupportedOperationException("Unimplemented method 'makeEvent'");
    return 0;   // TODO - Must review
  }
 
  public static void destroyEvent(int eventHandle) {
    throw new UnsupportedOperationException("Unimplemented method 'destroyEvent'");
    // TODO - Must fix
  }
 
  public static void setEvent(int eventHandle) {
    throw new UnsupportedOperationException("Unimplemented method 'setEvent'");
    // TODO - Must fix
  }
 
  public static void resetEvent(int eventHandle) {
    throw new UnsupportedOperationException("Unimplemented method 'resetEvent'");
    // TODO - Must fix
  }
 
  public static int[] waitForObjects(int[] handles) throws InterruptedException {
    // System.out.println(String.format("WPIUtilJNI.waitForObjects(%d)", handles.length));
    // throw new UnsupportedOperationException("Unimplemented method 'waitForObjects'");
    return null;  // TODO - Must fix
  }
 
  public static boolean waitForObjectTimeout(int handle, double timeout) throws InterruptedException {
    throw new UnsupportedOperationException("Unimplemented method 'waitForObjectTimeout'");
    // return false; // TODO - Must fix
  }
 
  public static long getSystemTime() {
    throw new UnsupportedOperationException("Unimplemented method 'getSystemTime'");
    // return 0; // TODO - Must fix
  }
 
  // static int createAlert(String group, String id, String text, int level) {
  //   throw new UnsupportedOperationException("Unimplemented method 'createAlert'");
  //   // return 0; // TODO - Must fix
  // }
private static String levelName(int level) {
  return switch (level) {
    case AlertDataJNI.LEVEL_HIGH -> "HIGH";
    case AlertDataJNI.LEVEL_MEDIUM -> "MEDIUM";
    case AlertDataJNI.LEVEL_LOW -> "LOW";
    default -> "LEVEL " + level;
  };
}
 
private static final class AlertState {
  final String group, id; final int level;
  volatile String text; volatile boolean active;
  AlertState(String g, String i, String t, int l) { group = g; id = i; text = t; level = l; }
}
private static final java.util.concurrent.ConcurrentHashMap<Integer, AlertState> s_alerts =
    new java.util.concurrent.ConcurrentHashMap<>();
private static final java.util.concurrent.atomic.AtomicInteger s_nextAlert = new java.util.concurrent.atomic.AtomicInteger();
 
static int createAlert(String group, String id, String text, int level) {
  int h = s_nextAlert.incrementAndGet();          // never 0: Alert treats 0 as "closed"
  s_alerts.put(h, new AlertState(group, id, text, level));
  return h;
}
static void destroyAlert(int h) { s_alerts.remove(h); }
 
static void setAlertActive(int h, boolean active) {
  AlertState a = s_alerts.get(h);
  if (a == null) return;
  if (active && !a.active) {                     // print on rising edge only
    System.err.println("ALERT [" + levelName(a.level) + "] " + a.group + "/" + a.id + ": " + a.text);
  }
  a.active = active;
}
static boolean isAlertActive(int h) { AlertState a = s_alerts.get(h); return a != null && a.active; }
static void setAlertText(int h, String t) { AlertState a = s_alerts.get(h); if (a != null) a.text = t; }
static String getAlertText(int h) { AlertState a = s_alerts.get(h); return a == null ? "" : a.text; }  
 
  // static void setAlertActive(int alertHandle, boolean active) {
  //   throw new UnsupportedOperationException("Unimplemented method 'setAlertActive'");
  //   // TODO - Must fix
  // }
 
  // static boolean isAlertActive(int alertHandle) {
  //   throw new UnsupportedOperationException("Unimplemented method 'isAlertActive'");
  //   // return false; // TODO - Must fix
  // }
 
  // static void setAlertText(int alertHandle, String text) {
  //   throw new UnsupportedOperationException("Unimplemented method 'setAlertText'");
  //   // TODO - Must fix
  // }
 
  // static String getAlertText(int alertHandle) {
  //   throw new UnsupportedOperationException("Unimplemented method 'getAlertText'");
  //   // return null;  // TODO - Must fix
  // }
 
  // static void destroyAlert(int alertHandle) {
  //   throw new UnsupportedOperationException("Unimplemented method 'destroyAlert'");
  //   // TODO - Must fix
  // }
 
  
 
 
//   /** Checks if the MSVC runtime is valid. Throws a runtime exception if not. */
//   public static native void checkMsvcRuntime();
 
//   /**
//    * Write the given string to stderr.
//    *
//    * @param str String to write.
//    */
//   public static native void writeStderr(String str);
 
//   /**
//    * Enable mock time. The mock time is initially set to 0. This also sets program start time to 0.
//    */
//   public static native void enableMockTime();
 
//   /** Disable mock time. */
//   public static native void disableMockTime();
 
//   /**
//    * Set mock time.
//    *
//    * @param time The desired time in nanoseconds.
//    */
//   public static native void setMockTime(long time);
 
//   /**
//    * Returns the time.
//    *
//    * @return The time.
//    */
//   public static native long now();
 
//   /**
//    * Returns the timestamp at which the program started.
//    *
//    * @return The program start timestamp in nanoseconds.
//    */
//   public static native long getProgramStartTime();
 
//   /**
//    * Returns the system time.
//    *
//    * @return The system time.
//    */
//   public static native long getSystemTime();
 
//   static native int createAlert(String group, String id, String text, int level);
 
//   static native void destroyAlert(int alertHandle);
 
//   static native void setAlertActive(int alertHandle, boolean active);
 
//   static native boolean isAlertActive(int alertHandle);
 
//   static native void setAlertText(int alertHandle, String text);
 
//   static native String getAlertText(int alertHandle);
 
//   /**
//    * Creates an event. Events have binary state (signaled or not signaled) and may be either
//    * automatically reset or manually reset. Automatic-reset events go to non-signaled state when a
//    * WaitForObject is woken up by the event; manual-reset events require ResetEvent() to be called
//    * to set the event to non-signaled state; if ResetEvent() is not called, any waiter on that event
//    * will immediately wake when called.
//    *
//    * @param manualReset true for manual reset, false for automatic reset
//    * @param initialState true to make the event initially in signaled state
//    * @return Event handle
//    */
//   public static native int makeEvent(boolean manualReset, boolean initialState);
 
//   /**
//    * Destroys an event. Destruction wakes up any waiters.
//    *
//    * @param eventHandle event handle
//    */
//   public static native void destroyEvent(int eventHandle);
 
//   /**
//    * Sets an event to signaled state.
//    *
//    * @param eventHandle event handle
//    */
//   public static native void setEvent(int eventHandle);
 
//   /**
//    * Sets an event to non-signaled state.
//    *
//    * @param eventHandle event handle
//    */
//   public static native void resetEvent(int eventHandle);
 
//   /**
//    * Creates a semaphore. Semaphores keep an internal counter. Releasing the semaphore increases the
//    * count. A semaphore with a non-zero count is considered signaled. When a waiter wakes up it
//    * atomically decrements the count by 1. This is generally useful in a single-supplier,
//    * multiple-consumer scenario.
//    *
//    * @param initialCount initial value for the semaphore's internal counter
//    * @param maximumCount maximum value for the semaphore's internal counter
//    * @return Semaphore handle
//    */
//   public static native int makeSemaphore(int initialCount, int maximumCount);
 
//   /**
//    * Destroys a semaphore. Destruction wakes up any waiters.
//    *
//    * @param semHandle semaphore handle
//    */
//   public static native void destroySemaphore(int semHandle);
 
//   /**
//    * Releases N counts of a semaphore.
//    *
//    * @param semHandle semaphore handle
//    * @param releaseCount amount to add to semaphore's internal counter; must be positive
//    * @return True on successful release, false on failure (e.g. release count would exceed maximum
//    *     value, or handle invalid)
//    */
//   public static native boolean releaseSemaphore(int semHandle, int releaseCount);
 
//   static native long allocateRawFrame();
 
//   static native void freeRawFrame(long frame);
 
//   static native long getRawFrameDataPtr(long frame);
 
//   static native void setRawFrameData(
//       long frame, ByteBuffer data, int size, int width, int height, int stride, int pixelFormat);
 
//   static native void setRawFrameInfo(
//       long frame, int size, int width, int height, int stride, int pixelFormat);
 
//   static native void setRawFrameTime(long frame, long timestamp, int timeSource);
 
//   /**
//    * Waits for a handle to be signaled.
//    *
//    * @param handle handle to wait on
//    * @throws InterruptedException on failure (e.g. object was destroyed)
//    */
//   public static native void waitForObject(int handle) throws InterruptedException;
 
//   /**
//    * Waits for a handle to be signaled, with timeout.
//    *
//    * @param handle handle to wait on
//    * @param timeout timeout in seconds
//    * @return True if timeout reached without handle being signaled
//    * @throws InterruptedException on failure (e.g. object was destroyed)
//    */
//   public static native boolean waitForObjectTimeout(int handle, double timeout)
//       throws InterruptedException;
 
//   /**
//    * Waits for one or more handles to be signaled.
//    *
//    * <p>Invalid handles are treated as signaled; the returned array will have the handle error bit
//    * set for any invalid handles.
//    *
//    * @param handles array of handles to wait on
//    * @return array of signaled handles
//    * @throws InterruptedException on failure (e.g. no objects were signaled)
//    */
//   public static native int[] waitForObjects(int[] handles) throws InterruptedException;
 
//   /**
//    * Waits for one or more handles to be signaled, with timeout.
//    *
//    * <p>Invalid handles are treated as signaled; the returned array will have the handle error bit
//    * set for any invalid handles.
//    *
//    * @param handles array of handles to wait on
//    * @param timeout timeout in seconds
//    * @return array of signaled handles; empty if timeout reached without any handle being signaled
//    * @throws InterruptedException on failure (e.g. no objects were signaled and no timeout)
//    */
//   public static native int[] waitForObjectsTimeout(int[] handles, double timeout)
//       throws InterruptedException;
 
//   /** Utility class. */
//   private WPIUtilJNI() {}
}