Files
SlimeVR-Server/src/main/java/dev/slimevr/gui/protocol/RPCHandler.java
T
2022-04-16 16:40:30 +02:00

323 lines
12 KiB
Java

package dev.slimevr.gui.protocol;
import com.fazecast.jSerialComm.SerialPort;
import com.google.flatbuffers.FlatBufferBuilder;
import dev.slimevr.platform.windows.WindowsNamedPipeBridge;
import dev.slimevr.serial.SerialListener;
import dev.slimevr.vr.processor.skeleton.SkeletonConfigValue;
import dev.slimevr.vr.trackers.*;
import io.eiren.util.logging.LogManager;
import slimevr_protocol.MessageBundle;
import slimevr_protocol.datatypes.TransactionId;
import slimevr_protocol.rpc.*;
import java.util.function.BiConsumer;
public class RPCHandler extends ProtocolHandler<RpcMessageHeader> implements SerialListener {
private final ProtocolAPI api;
private long currTransactionId = 0;
public RPCHandler(ProtocolAPI api) {
super();
this.api = api;
registerPacketListener(RpcMessage.ResetRequest, this::onResetRequest);
registerPacketListener(RpcMessage.AssignTrackerRequest, this::onAssignTrackerRequest);
registerPacketListener(RpcMessage.SettingsRequest, this::onSettingsRequest);
registerPacketListener(RpcMessage.ChangeSettingsRequest, this::onChangeSettingsRequest);
registerPacketListener(RpcMessage.RecordBVHRequest, this::onRecordBVHRequest);
registerPacketListener(RpcMessage.SkeletonResetAllRequest, this::onSkeletonResetAllRequest);
registerPacketListener(RpcMessage.SkeletonConfigRequest, this::onSkeletonConfigRequest);
registerPacketListener(RpcMessage.ChangeSkeletonConfigRequest, this::onChangeSkeletonConfigRequest);
registerPacketListener(RpcMessage.SetWifiRequest, this::onSetWifiRequest);
registerPacketListener(RpcMessage.OpenSerialRequest, this::onOpenSerialRequest);
registerPacketListener(RpcMessage.CloseSerialRequest, this::onCloseSerialRequest);
this.api.server.getSerialHandler().addListener(this);
}
public void onSetWifiRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
SetWifiRequest req = (SetWifiRequest) messageHeader.message(new SetWifiRequest());
if (req == null) return;
if (req.password() == null || req.ssid() == null || !this.api.server.getSerialHandler().isConnected())
return;
this.api.server.getSerialHandler().setWifi(req.ssid(), req.password());
}
public void onOpenSerialRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
OpenSerialRequest req = (OpenSerialRequest) messageHeader.message(new OpenSerialRequest());
if (req == null) return;
conn.getContext().setUseSerial(true);
this.api.server.getSerialHandler().openSerial();
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
SerialUpdateResponse.startSerialUpdateResponse(fbb);
SerialUpdateResponse.addClosed(fbb, !this.api.server.getSerialHandler().isConnected());
int update = SerialUpdateResponse.endSerialUpdateResponse(fbb);
int outbound = this.createRPCMessage(fbb, RpcMessage.SerialUpdateResponse, update);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onCloseSerialRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
CloseSerialRequest req = (CloseSerialRequest) messageHeader.message(new CloseSerialRequest());
if (req == null) return;
conn.getContext().setUseSerial(false);
this.api.server.getSerialHandler().closeSerial();
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
SerialUpdateResponse.startSerialUpdateResponse(fbb);
SerialUpdateResponse.addClosed(fbb, !this.api.server.getSerialHandler().isConnected());
int update = SerialUpdateResponse.endSerialUpdateResponse(fbb);
int outbound = this.createRPCMessage(fbb, RpcMessage.SerialUpdateResponse, update);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onSkeletonResetAllRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
SkeletonResetAllRequest req = (SkeletonResetAllRequest) messageHeader.message(new SkeletonResetAllRequest());
if (req == null) return;
this.api.server.humanPoseProcessor.getSkeletonConfig().resetConfigs();
this.api.server.saveConfig();
// might not be a good idea maybe let the client ask again
FlatBufferBuilder fbb = new FlatBufferBuilder(300);
int config = RPCBuilder.createSkeletonConfig(fbb, this.api.server.humanPoseProcessor);
int outbound = this.createRPCMessage(fbb, RpcMessage.SkeletonConfigResponse, config);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onSkeletonConfigRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
SkeletonConfigRequest req = (SkeletonConfigRequest) messageHeader.message(new SkeletonConfigRequest());
if (req == null) return;
FlatBufferBuilder fbb = new FlatBufferBuilder(300);
int config = RPCBuilder.createSkeletonConfig(fbb, this.api.server.humanPoseProcessor);
int outbound = this.createRPCMessage(fbb, RpcMessage.SkeletonConfigResponse, config);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onChangeSkeletonConfigRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
ChangeSkeletonConfigRequest req = (ChangeSkeletonConfigRequest) messageHeader.message(new ChangeSkeletonConfigRequest());
if (req == null) return;
SkeletonConfigValue joint = SkeletonConfigValue.getById(req.bone());
this.api.server.humanPoseProcessor.setSkeletonConfig(joint, req.value());
this.api.server.humanPoseProcessor.getSkeletonConfig().saveToConfig(this.api.server.config);
this.api.server.saveConfig();
}
public void onRecordBVHRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
RecordBVHRequest req = (RecordBVHRequest) messageHeader.message(new RecordBVHRequest());
if (req == null) return;
if (req.stop()) {
if (this.api.server.getBvhRecorder().isRecording())
this.api.server.getBvhRecorder().endRecording();
} else {
if (!this.api.server.getBvhRecorder().isRecording())
this.api.server.getBvhRecorder().startRecording();
}
FlatBufferBuilder fbb = new FlatBufferBuilder(40);
int status = RecordBVHStatus.createRecordBVHStatus(fbb, this.api.server.getBvhRecorder().isRecording());
int outbound = this.createRPCMessage(fbb, RpcMessage.RecordBVHStatus, status);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onResetRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
ResetRequest req = (ResetRequest) messageHeader.message(new ResetRequest());
if (req == null) return;
if (req.resetType() == ResetType.Quick)
this.api.server.resetTrackersYaw();
if (req.resetType() == ResetType.Full)
this.api.server.resetTrackers();
LogManager.log.severe("[WebSocketAPI] Reset performed");
}
public void onAssignTrackerRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
AssignTrackerRequest req = (AssignTrackerRequest) messageHeader.message(new AssignTrackerRequest());
if (req == null) return;
Tracker tracker = this.api.server.getTrackerById(req.trackerId().unpack());
if (tracker == null)
return ;
tracker.setBodyPosition(TrackerPosition.getById(req.bodyPosition()));
if (tracker instanceof IMUTracker) {
IMUTracker imu = (IMUTracker) tracker;
// TrackerMountingRotation rot = TrackerMountingRotation.fromAngle(req.mountingRotation());
// if (rot != null)
// imu.setMountingRotation(rot);
}
this.api.server.trackerUpdated(tracker);
}
public void onSettingsRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
WindowsNamedPipeBridge bridge = this.api.server.getVRBridge(WindowsNamedPipeBridge.class);
int steamvrTrackerSettings = SteamVRTrackersSetting.createSteamVRTrackersSetting(fbb,
bridge.getShareSetting(TrackerRole.WAIST),
bridge.getShareSetting(TrackerRole.CHEST),
bridge.getShareSetting(TrackerRole.LEFT_FOOT) && bridge.getShareSetting(TrackerRole.RIGHT_FOOT),
bridge.getShareSetting(TrackerRole.LEFT_KNEE) &&bridge.getShareSetting(TrackerRole.RIGHT_KNEE),
bridge.getShareSetting(TrackerRole.LEFT_ELBOW) && bridge.getShareSetting(TrackerRole.RIGHT_ELBOW)
);
int filterSettings = FilteringSettings.createFilteringSettings(
fbb,
TrackerFilters.valueOf(this.api.server.config.getString("filters.type", "NONE")).id,
(int)(this.api.server.config.getFloat("filters.amount", 0.3f) * 100),
this.api.server.config.getInt("filters.tickCount", 2)
);
int settings = SettingsResponse.createSettingsResponse(fbb, steamvrTrackerSettings, filterSettings);
int outbound = createRPCMessage(fbb, RpcMessage.SettingsResponse, settings);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onChangeSettingsRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
ChangeSettingsRequest req = (ChangeSettingsRequest) messageHeader.message(new ChangeSettingsRequest());
if (req == null) return;
if (req.steamVrTrackers() != null) {
WindowsNamedPipeBridge bridge = this.api.server.getVRBridge(WindowsNamedPipeBridge.class);
bridge.changeShareSettings(TrackerRole.WAIST, req.steamVrTrackers().waist());
bridge.changeShareSettings(TrackerRole.CHEST, req.steamVrTrackers().chest());
bridge.changeShareSettings(TrackerRole.LEFT_FOOT, req.steamVrTrackers().legs());
bridge.changeShareSettings(TrackerRole.RIGHT_FOOT, req.steamVrTrackers().legs());
bridge.changeShareSettings(TrackerRole.LEFT_KNEE, req.steamVrTrackers().knees());
bridge.changeShareSettings(TrackerRole.RIGHT_KNEE, req.steamVrTrackers().knees());
bridge.changeShareSettings(TrackerRole.LEFT_ELBOW, req.steamVrTrackers().elbows());
bridge.changeShareSettings(TrackerRole.RIGHT_ELBOW, req.steamVrTrackers().elbows());
}
if (req.filtering() != null) {
TrackerFilters type = TrackerFilters.fromId(req.filtering().type());
if (type != null) {
this.api.server.updateTrackersFilters(type, (float)req.filtering().intensity() / 100.0f, req.filtering().ticks());
}
}
}
@Override
public void onMessage(GenericConnection conn, RpcMessageHeader message) {
BiConsumer<GenericConnection, RpcMessageHeader> consumer = this.handlers[message.messageType()];
if (consumer != null)
consumer.accept(conn, message);
else
LogManager.log.info("[ProtocolAPI] Unhandled RPC packet received id: " + message.messageType());
}
public int createRPCMessage(FlatBufferBuilder fbb, byte messageType, int messageOffset) {
int [] data = new int[1];
RpcMessageHeader.startRpcMessageHeader(fbb);
RpcMessageHeader.addMessage(fbb, messageOffset);
RpcMessageHeader.addMessageType(fbb, messageType);
RpcMessageHeader.addTxId(fbb, TransactionId.createTransactionId(fbb, currTransactionId++));
data[0] = RpcMessageHeader.endRpcMessageHeader(fbb);
int messages = MessageBundle.createRpcMsgsVector(fbb, data);
return createMessage(fbb, -1, messages);
}
@Override
public int messagesCount() {
return RpcMessage.names.length;
}
@Override
public void onSerialConnected(SerialPort port) {
this.api.getAPIServers().forEach((server) -> {
server.getAPIConnections()
.values()
.stream()
.filter(conn -> conn.getContext().useSerial())
.forEach((conn) -> {
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
SerialUpdateResponse.startSerialUpdateResponse(fbb);
SerialUpdateResponse.addClosed(fbb, false);
int update = SerialUpdateResponse.endSerialUpdateResponse(fbb);
int outbound = this.createRPCMessage(fbb, RpcMessage.SerialUpdateResponse, update);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
});
});
}
@Override
public void onSerialDisconnected() {
this.api.getAPIServers().forEach((server) -> {
server.getAPIConnections()
.values()
.stream()
.filter(conn -> conn.getContext().useSerial())
.forEach((conn) -> {
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
SerialUpdateResponse.startSerialUpdateResponse(fbb);
SerialUpdateResponse.addClosed(fbb, true);
int update = SerialUpdateResponse.endSerialUpdateResponse(fbb);
int outbound = this.createRPCMessage(fbb, RpcMessage.SerialUpdateResponse, update);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
conn.getContext().setUseSerial(false);
});
});
}
@Override
public void onSerialLog(String str) {
this.api.getAPIServers().forEach((server) -> {
server.getAPIConnections()
.values()
.stream()
.filter(conn -> conn.getContext().useSerial())
.forEach((conn) -> {
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
int logOffset = fbb.createString(str);
SerialUpdateResponse.startSerialUpdateResponse(fbb);
SerialUpdateResponse.addLog(fbb, logOffset);
int update = SerialUpdateResponse.endSerialUpdateResponse(fbb);
int outbound = this.createRPCMessage(fbb, RpcMessage.SerialUpdateResponse, update);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
});
});
}
}