From 83d38eefabde63f6a688487af693694c24ee1019 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 25 Sep 2021 13:26:00 -0700 Subject: [PATCH 01/10] Add partial websocket implementation and video feed code --- package.json | 5 +- src/App.tsx | 35 +- src/keyboard-buttons.ts | 49 + src/protos/input.proto | 26 + src/protos/protos.d.ts | 894 ++++++++++ src/protos/protos.js | 2210 +++++++++++++++++++++++++ src/static/video-feed/sandstorm.png | Bin 0 -> 1144548 bytes src/static/video-feed/scoreboard.css | 108 ++ src/static/video-feed/scoreboard.html | 53 + src/static/video-feed/video-feed.css | 30 + src/static/video-feed/video.html | 17 + src/video-feed/Scoreboard.js | 314 ++++ src/video-feed/ShepherdOverlay.tsx | 11 + src/video-feed/VideoFeed.tsx | 151 ++ src/video-feed/index.tsx | 5 + tsconfig.json | 3 + yarn.lock | 191 ++- 17 files changed, 4085 insertions(+), 17 deletions(-) create mode 100644 src/keyboard-buttons.ts create mode 100644 src/protos/input.proto create mode 100644 src/protos/protos.d.ts create mode 100644 src/protos/protos.js create mode 100644 src/static/video-feed/sandstorm.png create mode 100644 src/static/video-feed/scoreboard.css create mode 100644 src/static/video-feed/scoreboard.html create mode 100644 src/static/video-feed/video-feed.css create mode 100644 src/static/video-feed/video.html create mode 100644 src/video-feed/Scoreboard.js create mode 100644 src/video-feed/ShepherdOverlay.tsx create mode 100644 src/video-feed/VideoFeed.tsx create mode 100644 src/video-feed/index.tsx diff --git a/package.json b/package.json index 807ffa8..124a061 100644 --- a/package.json +++ b/package.json @@ -10,11 +10,14 @@ "@types/node": "^12.0.0", "@types/react": "^17.0.0", "@types/react-dom": "^17.0.0", + "protobufjs": "^6.11.2", "react": "^17.0.2", "react-dom": "^17.0.2", "react-scripts": "4.0.3", + "socket.io-client": "^4.2.0", "typescript": "^4.1.2", - "web-vitals": "^1.0.1" + "web-vitals": "^1.0.1", + "ws": "^8.2.2" }, "scripts": { "start": "react-scripts start", diff --git a/src/App.tsx b/src/App.tsx index a53698a..83b2d12 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -1,24 +1,29 @@ import React from 'react'; import logo from './logo.svg'; +import { io } from "socket.io-client"; +// import {VideoFeed} from './video-feed/VideoFeed'; import './App.css'; -function App() { +export const App = () => { + const ws = new WebSocket('wss://127.0.0.1:8080'); + const socket = io('wss://127.0.0.1:8080'); //'http://localhost:8080'); + socket.on('connect', () => console.log('socket connected')); + // console.log('ready state', ws.readyState); + + // ws.addEventListener('close', (ev: Event) => console.log('Connection closed', ev)); + + // ws.addEventListener('open', (ev: Event) => console.log('web socket open', ev)); + + // ws.addEventListener('message', (message: Event) => { + // console.log('received: %s', message); + // }); + + // ws.addEventListener('error', (ev: Event) => console.log('error', ev)) + return (
-
- logo -

- Edit src/App.tsx and save to reload. -

- - Learn React - -
+

Dawn is the best software team.

+ {/* */}
); } diff --git a/src/keyboard-buttons.ts b/src/keyboard-buttons.ts new file mode 100644 index 0000000..6f5d9c4 --- /dev/null +++ b/src/keyboard-buttons.ts @@ -0,0 +1,49 @@ +export const keyboardButtons = { + a: 0, + b: 1, + c: 2, + d: 3, + e: 4, + f: 5, + g: 6, + h: 7, + i: 8, + j: 9, + k: 10, + l: 11, + m: 12, + n: 13, + o: 14, + p: 15, + q: 16, + r: 17, + s: 18, + t: 19, + u: 20, + v: 21, + w: 22, + x: 23, + y: 24, + z: 25, + '1': 26, + '2': 27, + '3': 28, + '4': 29, + '5': 30, + '6': 31, + '7': 32, + '8': 33, + '9': 34, + '0': 35, + ',': 36, + '.': 37, + '/': 38, + ';': 39, + "'": 40, + '[': 41, + ']': 42, + ArrowLeft: 43, + ArrowRight: 44, + ArrowUp: 45, + ArrowDown: 46 + }; \ No newline at end of file diff --git a/src/protos/input.proto b/src/protos/input.proto new file mode 100644 index 0000000..50834c5 --- /dev/null +++ b/src/protos/input.proto @@ -0,0 +1,26 @@ +/* + * Defines a message for communicating user inputs + */ + +syntax = "proto3"; + +option optimize_for = LITE_RUNTIME; + +// Message for the current state of an input +message Input { + bool connected = 1; + fixed64 buttons = 2; + repeated float axes = 3; + Source source = 4; +} + +// An array of all inputs from all sources +message UserInputs { + repeated Input inputs = 1; +} + +// Enum specifying which input source the data is from +enum Source { + GAMEPAD = 0; + KEYBOARD = 1; +} \ No newline at end of file diff --git a/src/protos/protos.d.ts b/src/protos/protos.d.ts new file mode 100644 index 0000000..4c88a21 --- /dev/null +++ b/src/protos/protos.d.ts @@ -0,0 +1,894 @@ +import * as $protobuf from "protobufjs"; +/** Properties of a Param. */ +export interface IParam { + + /** Param name */ + name?: (string|null); + + /** Param fval */ + fval?: (number|null); + + /** Param ival */ + ival?: (number|null); + + /** Param bval */ + bval?: (boolean|null); +} + +/** Represents a Param. */ +export class Param implements IParam { + + /** + * Constructs a new Param. + * @param [properties] Properties to set + */ + constructor(properties?: IParam); + + /** Param name. */ + public name: string; + + /** Param fval. */ + public fval: number; + + /** Param ival. */ + public ival: number; + + /** Param bval. */ + public bval: boolean; + + /** Param val. */ + public val?: ("fval"|"ival"|"bval"); + + /** + * Creates a new Param instance using the specified properties. + * @param [properties] Properties to set + * @returns Param instance + */ + public static create(properties?: IParam): Param; + + /** + * Encodes the specified Param message. Does not implicitly {@link Param.verify|verify} messages. + * @param message Param message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IParam, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Param message, length delimited. Does not implicitly {@link Param.verify|verify} messages. + * @param message Param message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IParam, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Param message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Param; + + /** + * Decodes a Param message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Param; + + /** + * Verifies a Param message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Param message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Param + */ + public static fromObject(object: { [k: string]: any }): Param; + + /** + * Creates a plain object from a Param message. Also converts values to other types if specified. + * @param message Param + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Param, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Param to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a Device. */ +export interface IDevice { + + /** Device name */ + name?: (string|null); + + /** Device uid */ + uid?: (number|Long|null); + + /** Device type */ + type?: (number|null); + + /** Device params */ + params?: (IParam[]|null); +} + +/** Represents a Device. */ +export class Device implements IDevice { + + /** + * Constructs a new Device. + * @param [properties] Properties to set + */ + constructor(properties?: IDevice); + + /** Device name. */ + public name: string; + + /** Device uid. */ + public uid: (number|Long); + + /** Device type. */ + public type: number; + + /** Device params. */ + public params: Param[]; + + /** + * Creates a new Device instance using the specified properties. + * @param [properties] Properties to set + * @returns Device instance + */ + public static create(properties?: IDevice): Device; + + /** + * Encodes the specified Device message. Does not implicitly {@link Device.verify|verify} messages. + * @param message Device message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IDevice, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Device message, length delimited. Does not implicitly {@link Device.verify|verify} messages. + * @param message Device message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IDevice, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Device message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Device; + + /** + * Decodes a Device message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Device; + + /** + * Verifies a Device message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Device message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Device + */ + public static fromObject(object: { [k: string]: any }): Device; + + /** + * Creates a plain object from a Device message. Also converts values to other types if specified. + * @param message Device + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Device, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Device to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a DevData. */ +export interface IDevData { + + /** DevData devices */ + devices?: (IDevice[]|null); +} + +/** Represents a DevData. */ +export class DevData implements IDevData { + + /** + * Constructs a new DevData. + * @param [properties] Properties to set + */ + constructor(properties?: IDevData); + + /** DevData devices. */ + public devices: Device[]; + + /** + * Creates a new DevData instance using the specified properties. + * @param [properties] Properties to set + * @returns DevData instance + */ + public static create(properties?: IDevData): DevData; + + /** + * Encodes the specified DevData message. Does not implicitly {@link DevData.verify|verify} messages. + * @param message DevData message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IDevData, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified DevData message, length delimited. Does not implicitly {@link DevData.verify|verify} messages. + * @param message DevData message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IDevData, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DevData message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DevData; + + /** + * Decodes a DevData message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DevData; + + /** + * Verifies a DevData message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a DevData message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns DevData + */ + public static fromObject(object: { [k: string]: any }): DevData; + + /** + * Creates a plain object from a DevData message. Also converts values to other types if specified. + * @param message DevData + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: DevData, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this DevData to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of an Input. */ +export interface IInput { + + /** Input connected */ + connected?: (boolean|null); + + /** Input buttons */ + buttons?: (number|Long|null); + + /** Input axes */ + axes?: (number[]|null); + + /** Input source */ + source?: (Source|null); +} + +/** Represents an Input. */ +export class Input implements IInput { + + /** + * Constructs a new Input. + * @param [properties] Properties to set + */ + constructor(properties?: IInput); + + /** Input connected. */ + public connected: boolean; + + /** Input buttons. */ + public buttons: (number|Long); + + /** Input axes. */ + public axes: number[]; + + /** Input source. */ + public source: Source; + + /** + * Creates a new Input instance using the specified properties. + * @param [properties] Properties to set + * @returns Input instance + */ + public static create(properties?: IInput): Input; + + /** + * Encodes the specified Input message. Does not implicitly {@link Input.verify|verify} messages. + * @param message Input message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IInput, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Input message, length delimited. Does not implicitly {@link Input.verify|verify} messages. + * @param message Input message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IInput, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an Input message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Input; + + /** + * Decodes an Input message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Input; + + /** + * Verifies an Input message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates an Input message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Input + */ + public static fromObject(object: { [k: string]: any }): Input; + + /** + * Creates a plain object from an Input message. Also converts values to other types if specified. + * @param message Input + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Input, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Input to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a UserInputs. */ +export interface IUserInputs { + + /** UserInputs inputs */ + inputs?: (IInput[]|null); +} + +/** Represents a UserInputs. */ +export class UserInputs implements IUserInputs { + + /** + * Constructs a new UserInputs. + * @param [properties] Properties to set + */ + constructor(properties?: IUserInputs); + + /** UserInputs inputs. */ + public inputs: Input[]; + + /** + * Creates a new UserInputs instance using the specified properties. + * @param [properties] Properties to set + * @returns UserInputs instance + */ + public static create(properties?: IUserInputs): UserInputs; + + /** + * Encodes the specified UserInputs message. Does not implicitly {@link UserInputs.verify|verify} messages. + * @param message UserInputs message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IUserInputs, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified UserInputs message, length delimited. Does not implicitly {@link UserInputs.verify|verify} messages. + * @param message UserInputs message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IUserInputs, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a UserInputs message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UserInputs; + + /** + * Decodes a UserInputs message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UserInputs; + + /** + * Verifies a UserInputs message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a UserInputs message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns UserInputs + */ + public static fromObject(object: { [k: string]: any }): UserInputs; + + /** + * Creates a plain object from a UserInputs message. Also converts values to other types if specified. + * @param message UserInputs + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: UserInputs, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this UserInputs to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Source enum. */ +export enum Source { + GAMEPAD = 0, + KEYBOARD = 1 +} + +/** Mode enum. */ +export enum Mode { + IDLE = 0, + AUTO = 1, + TELEOP = 2, + ESTOP = 3, + CHALLENGE = 4 +} + +/** Properties of a RunMode. */ +export interface IRunMode { + + /** RunMode mode */ + mode?: (Mode|null); +} + +/** Represents a RunMode. */ +export class RunMode implements IRunMode { + + /** + * Constructs a new RunMode. + * @param [properties] Properties to set + */ + constructor(properties?: IRunMode); + + /** RunMode mode. */ + public mode: Mode; + + /** + * Creates a new RunMode instance using the specified properties. + * @param [properties] Properties to set + * @returns RunMode instance + */ + public static create(properties?: IRunMode): RunMode; + + /** + * Encodes the specified RunMode message. Does not implicitly {@link RunMode.verify|verify} messages. + * @param message RunMode message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IRunMode, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified RunMode message, length delimited. Does not implicitly {@link RunMode.verify|verify} messages. + * @param message RunMode message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IRunMode, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a RunMode message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): RunMode; + + /** + * Decodes a RunMode message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): RunMode; + + /** + * Verifies a RunMode message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a RunMode message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns RunMode + */ + public static fromObject(object: { [k: string]: any }): RunMode; + + /** + * Creates a plain object from a RunMode message. Also converts values to other types if specified. + * @param message RunMode + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: RunMode, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this RunMode to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Pos enum. */ +export enum Pos { + LEFT = 0, + RIGHT = 1 +} + +/** Properties of a StartPos. */ +export interface IStartPos { + + /** StartPos pos */ + pos?: (Pos|null); +} + +/** Represents a StartPos. */ +export class StartPos implements IStartPos { + + /** + * Constructs a new StartPos. + * @param [properties] Properties to set + */ + constructor(properties?: IStartPos); + + /** StartPos pos. */ + public pos: Pos; + + /** + * Creates a new StartPos instance using the specified properties. + * @param [properties] Properties to set + * @returns StartPos instance + */ + public static create(properties?: IStartPos): StartPos; + + /** + * Encodes the specified StartPos message. Does not implicitly {@link StartPos.verify|verify} messages. + * @param message StartPos message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IStartPos, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified StartPos message, length delimited. Does not implicitly {@link StartPos.verify|verify} messages. + * @param message StartPos message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IStartPos, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a StartPos message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): StartPos; + + /** + * Decodes a StartPos message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): StartPos; + + /** + * Verifies a StartPos message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a StartPos message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns StartPos + */ + public static fromObject(object: { [k: string]: any }): StartPos; + + /** + * Creates a plain object from a StartPos message. Also converts values to other types if specified. + * @param message StartPos + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: StartPos, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this StartPos to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a Text. */ +export interface IText { + + /** Text payload */ + payload?: (string[]|null); +} + +/** Represents a Text. */ +export class Text implements IText { + + /** + * Constructs a new Text. + * @param [properties] Properties to set + */ + constructor(properties?: IText); + + /** Text payload. */ + public payload: string[]; + + /** + * Creates a new Text instance using the specified properties. + * @param [properties] Properties to set + * @returns Text instance + */ + public static create(properties?: IText): Text; + + /** + * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages. + * @param message Text message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IText, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages. + * @param message Text message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IText, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Text message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Text; + + /** + * Decodes a Text message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Text; + + /** + * Verifies a Text message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Text message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Text + */ + public static fromObject(object: { [k: string]: any }): Text; + + /** + * Creates a plain object from a Text message. Also converts values to other types if specified. + * @param message Text + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Text, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Text to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a TimeStamps. */ +export interface ITimeStamps { + + /** TimeStamps dawnTimestamp */ + dawnTimestamp?: (number|Long|null); + + /** TimeStamps runtimeTimestamp */ + runtimeTimestamp?: (number|Long|null); +} + +/** Represents a TimeStamps. */ +export class TimeStamps implements ITimeStamps { + + /** + * Constructs a new TimeStamps. + * @param [properties] Properties to set + */ + constructor(properties?: ITimeStamps); + + /** TimeStamps dawnTimestamp. */ + public dawnTimestamp: (number|Long); + + /** TimeStamps runtimeTimestamp. */ + public runtimeTimestamp: (number|Long); + + /** + * Creates a new TimeStamps instance using the specified properties. + * @param [properties] Properties to set + * @returns TimeStamps instance + */ + public static create(properties?: ITimeStamps): TimeStamps; + + /** + * Encodes the specified TimeStamps message. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @param message TimeStamps message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: ITimeStamps, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified TimeStamps message, length delimited. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @param message TimeStamps message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: ITimeStamps, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a TimeStamps message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TimeStamps; + + /** + * Decodes a TimeStamps message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TimeStamps; + + /** + * Verifies a TimeStamps message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a TimeStamps message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns TimeStamps + */ + public static fromObject(object: { [k: string]: any }): TimeStamps; + + /** + * Creates a plain object from a TimeStamps message. Also converts values to other types if specified. + * @param message TimeStamps + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: TimeStamps, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this TimeStamps to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} diff --git a/src/protos/protos.js b/src/protos/protos.js new file mode 100644 index 0000000..7d09715 --- /dev/null +++ b/src/protos/protos.js @@ -0,0 +1,2210 @@ +/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ +import * as $protobuf from "protobufjs/minimal"; + +// Common aliases +const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; + +// Exported root namespace +const $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + +export const Param = $root.Param = (() => { + + /** + * Properties of a Param. + * @exports IParam + * @interface IParam + * @property {string|null} [name] Param name + * @property {number|null} [fval] Param fval + * @property {number|null} [ival] Param ival + * @property {boolean|null} [bval] Param bval + */ + + /** + * Constructs a new Param. + * @exports Param + * @classdesc Represents a Param. + * @implements IParam + * @constructor + * @param {IParam=} [properties] Properties to set + */ + function Param(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Param name. + * @member {string} name + * @memberof Param + * @instance + */ + Param.prototype.name = ""; + + /** + * Param fval. + * @member {number} fval + * @memberof Param + * @instance + */ + Param.prototype.fval = 0; + + /** + * Param ival. + * @member {number} ival + * @memberof Param + * @instance + */ + Param.prototype.ival = 0; + + /** + * Param bval. + * @member {boolean} bval + * @memberof Param + * @instance + */ + Param.prototype.bval = false; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * Param val. + * @member {"fval"|"ival"|"bval"|undefined} val + * @memberof Param + * @instance + */ + Object.defineProperty(Param.prototype, "val", { + get: $util.oneOfGetter($oneOfFields = ["fval", "ival", "bval"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Creates a new Param instance using the specified properties. + * @function create + * @memberof Param + * @static + * @param {IParam=} [properties] Properties to set + * @returns {Param} Param instance + */ + Param.create = function create(properties) { + return new Param(properties); + }; + + /** + * Encodes the specified Param message. Does not implicitly {@link Param.verify|verify} messages. + * @function encode + * @memberof Param + * @static + * @param {IParam} message Param message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Param.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.name != null && Object.hasOwnProperty.call(message, "name")) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); + if (message.fval != null && Object.hasOwnProperty.call(message, "fval")) + writer.uint32(/* id 2, wireType 5 =*/21).float(message.fval); + if (message.ival != null && Object.hasOwnProperty.call(message, "ival")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.ival); + if (message.bval != null && Object.hasOwnProperty.call(message, "bval")) + writer.uint32(/* id 4, wireType 0 =*/32).bool(message.bval); + return writer; + }; + + /** + * Encodes the specified Param message, length delimited. Does not implicitly {@link Param.verify|verify} messages. + * @function encodeDelimited + * @memberof Param + * @static + * @param {IParam} message Param message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Param.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Param message from the specified reader or buffer. + * @function decode + * @memberof Param + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Param} Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Param.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Param(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.fval = reader.float(); + break; + case 3: + message.ival = reader.int32(); + break; + case 4: + message.bval = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Param message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Param + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Param} Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Param.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Param message. + * @function verify + * @memberof Param + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Param.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + let properties = {}; + if (message.name != null && message.hasOwnProperty("name")) + if (!$util.isString(message.name)) + return "name: string expected"; + if (message.fval != null && message.hasOwnProperty("fval")) { + properties.val = 1; + if (typeof message.fval !== "number") + return "fval: number expected"; + } + if (message.ival != null && message.hasOwnProperty("ival")) { + if (properties.val === 1) + return "val: multiple values"; + properties.val = 1; + if (!$util.isInteger(message.ival)) + return "ival: integer expected"; + } + if (message.bval != null && message.hasOwnProperty("bval")) { + if (properties.val === 1) + return "val: multiple values"; + properties.val = 1; + if (typeof message.bval !== "boolean") + return "bval: boolean expected"; + } + return null; + }; + + /** + * Creates a Param message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Param + * @static + * @param {Object.} object Plain object + * @returns {Param} Param + */ + Param.fromObject = function fromObject(object) { + if (object instanceof $root.Param) + return object; + let message = new $root.Param(); + if (object.name != null) + message.name = String(object.name); + if (object.fval != null) + message.fval = Number(object.fval); + if (object.ival != null) + message.ival = object.ival | 0; + if (object.bval != null) + message.bval = Boolean(object.bval); + return message; + }; + + /** + * Creates a plain object from a Param message. Also converts values to other types if specified. + * @function toObject + * @memberof Param + * @static + * @param {Param} message Param + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Param.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) + object.name = ""; + if (message.name != null && message.hasOwnProperty("name")) + object.name = message.name; + if (message.fval != null && message.hasOwnProperty("fval")) { + object.fval = options.json && !isFinite(message.fval) ? String(message.fval) : message.fval; + if (options.oneofs) + object.val = "fval"; + } + if (message.ival != null && message.hasOwnProperty("ival")) { + object.ival = message.ival; + if (options.oneofs) + object.val = "ival"; + } + if (message.bval != null && message.hasOwnProperty("bval")) { + object.bval = message.bval; + if (options.oneofs) + object.val = "bval"; + } + return object; + }; + + /** + * Converts this Param to JSON. + * @function toJSON + * @memberof Param + * @instance + * @returns {Object.} JSON object + */ + Param.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Param; +})(); + +export const Device = $root.Device = (() => { + + /** + * Properties of a Device. + * @exports IDevice + * @interface IDevice + * @property {string|null} [name] Device name + * @property {number|Long|null} [uid] Device uid + * @property {number|null} [type] Device type + * @property {Array.|null} [params] Device params + */ + + /** + * Constructs a new Device. + * @exports Device + * @classdesc Represents a Device. + * @implements IDevice + * @constructor + * @param {IDevice=} [properties] Properties to set + */ + function Device(properties) { + this.params = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Device name. + * @member {string} name + * @memberof Device + * @instance + */ + Device.prototype.name = ""; + + /** + * Device uid. + * @member {number|Long} uid + * @memberof Device + * @instance + */ + Device.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0; + + /** + * Device type. + * @member {number} type + * @memberof Device + * @instance + */ + Device.prototype.type = 0; + + /** + * Device params. + * @member {Array.} params + * @memberof Device + * @instance + */ + Device.prototype.params = $util.emptyArray; + + /** + * Creates a new Device instance using the specified properties. + * @function create + * @memberof Device + * @static + * @param {IDevice=} [properties] Properties to set + * @returns {Device} Device instance + */ + Device.create = function create(properties) { + return new Device(properties); + }; + + /** + * Encodes the specified Device message. Does not implicitly {@link Device.verify|verify} messages. + * @function encode + * @memberof Device + * @static + * @param {IDevice} message Device message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Device.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.name != null && Object.hasOwnProperty.call(message, "name")) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); + if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) + writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.uid); + if (message.type != null && Object.hasOwnProperty.call(message, "type")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.type); + if (message.params != null && message.params.length) + for (let i = 0; i < message.params.length; ++i) + $root.Param.encode(message.params[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified Device message, length delimited. Does not implicitly {@link Device.verify|verify} messages. + * @function encodeDelimited + * @memberof Device + * @static + * @param {IDevice} message Device message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Device.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Device message from the specified reader or buffer. + * @function decode + * @memberof Device + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Device} Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Device.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Device(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.uid = reader.uint64(); + break; + case 3: + message.type = reader.int32(); + break; + case 4: + if (!(message.params && message.params.length)) + message.params = []; + message.params.push($root.Param.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Device message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Device + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Device} Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Device.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Device message. + * @function verify + * @memberof Device + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Device.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.name != null && message.hasOwnProperty("name")) + if (!$util.isString(message.name)) + return "name: string expected"; + if (message.uid != null && message.hasOwnProperty("uid")) + if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high))) + return "uid: integer|Long expected"; + if (message.type != null && message.hasOwnProperty("type")) + if (!$util.isInteger(message.type)) + return "type: integer expected"; + if (message.params != null && message.hasOwnProperty("params")) { + if (!Array.isArray(message.params)) + return "params: array expected"; + for (let i = 0; i < message.params.length; ++i) { + let error = $root.Param.verify(message.params[i]); + if (error) + return "params." + error; + } + } + return null; + }; + + /** + * Creates a Device message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Device + * @static + * @param {Object.} object Plain object + * @returns {Device} Device + */ + Device.fromObject = function fromObject(object) { + if (object instanceof $root.Device) + return object; + let message = new $root.Device(); + if (object.name != null) + message.name = String(object.name); + if (object.uid != null) + if ($util.Long) + (message.uid = $util.Long.fromValue(object.uid)).unsigned = true; + else if (typeof object.uid === "string") + message.uid = parseInt(object.uid, 10); + else if (typeof object.uid === "number") + message.uid = object.uid; + else if (typeof object.uid === "object") + message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true); + if (object.type != null) + message.type = object.type | 0; + if (object.params) { + if (!Array.isArray(object.params)) + throw TypeError(".Device.params: array expected"); + message.params = []; + for (let i = 0; i < object.params.length; ++i) { + if (typeof object.params[i] !== "object") + throw TypeError(".Device.params: object expected"); + message.params[i] = $root.Param.fromObject(object.params[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a Device message. Also converts values to other types if specified. + * @function toObject + * @memberof Device + * @static + * @param {Device} message Device + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Device.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.params = []; + if (options.defaults) { + object.name = ""; + if ($util.Long) { + let long = new $util.Long(0, 0, true); + object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.uid = options.longs === String ? "0" : 0; + object.type = 0; + } + if (message.name != null && message.hasOwnProperty("name")) + object.name = message.name; + if (message.uid != null && message.hasOwnProperty("uid")) + if (typeof message.uid === "number") + object.uid = options.longs === String ? String(message.uid) : message.uid; + else + object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid; + if (message.type != null && message.hasOwnProperty("type")) + object.type = message.type; + if (message.params && message.params.length) { + object.params = []; + for (let j = 0; j < message.params.length; ++j) + object.params[j] = $root.Param.toObject(message.params[j], options); + } + return object; + }; + + /** + * Converts this Device to JSON. + * @function toJSON + * @memberof Device + * @instance + * @returns {Object.} JSON object + */ + Device.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Device; +})(); + +export const DevData = $root.DevData = (() => { + + /** + * Properties of a DevData. + * @exports IDevData + * @interface IDevData + * @property {Array.|null} [devices] DevData devices + */ + + /** + * Constructs a new DevData. + * @exports DevData + * @classdesc Represents a DevData. + * @implements IDevData + * @constructor + * @param {IDevData=} [properties] Properties to set + */ + function DevData(properties) { + this.devices = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * DevData devices. + * @member {Array.} devices + * @memberof DevData + * @instance + */ + DevData.prototype.devices = $util.emptyArray; + + /** + * Creates a new DevData instance using the specified properties. + * @function create + * @memberof DevData + * @static + * @param {IDevData=} [properties] Properties to set + * @returns {DevData} DevData instance + */ + DevData.create = function create(properties) { + return new DevData(properties); + }; + + /** + * Encodes the specified DevData message. Does not implicitly {@link DevData.verify|verify} messages. + * @function encode + * @memberof DevData + * @static + * @param {IDevData} message DevData message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + DevData.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.devices != null && message.devices.length) + for (let i = 0; i < message.devices.length; ++i) + $root.Device.encode(message.devices[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified DevData message, length delimited. Does not implicitly {@link DevData.verify|verify} messages. + * @function encodeDelimited + * @memberof DevData + * @static + * @param {IDevData} message DevData message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + DevData.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a DevData message from the specified reader or buffer. + * @function decode + * @memberof DevData + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {DevData} DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + DevData.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DevData(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.devices && message.devices.length)) + message.devices = []; + message.devices.push($root.Device.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a DevData message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof DevData + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {DevData} DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + DevData.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a DevData message. + * @function verify + * @memberof DevData + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + DevData.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.devices != null && message.hasOwnProperty("devices")) { + if (!Array.isArray(message.devices)) + return "devices: array expected"; + for (let i = 0; i < message.devices.length; ++i) { + let error = $root.Device.verify(message.devices[i]); + if (error) + return "devices." + error; + } + } + return null; + }; + + /** + * Creates a DevData message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof DevData + * @static + * @param {Object.} object Plain object + * @returns {DevData} DevData + */ + DevData.fromObject = function fromObject(object) { + if (object instanceof $root.DevData) + return object; + let message = new $root.DevData(); + if (object.devices) { + if (!Array.isArray(object.devices)) + throw TypeError(".DevData.devices: array expected"); + message.devices = []; + for (let i = 0; i < object.devices.length; ++i) { + if (typeof object.devices[i] !== "object") + throw TypeError(".DevData.devices: object expected"); + message.devices[i] = $root.Device.fromObject(object.devices[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a DevData message. Also converts values to other types if specified. + * @function toObject + * @memberof DevData + * @static + * @param {DevData} message DevData + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + DevData.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.devices = []; + if (message.devices && message.devices.length) { + object.devices = []; + for (let j = 0; j < message.devices.length; ++j) + object.devices[j] = $root.Device.toObject(message.devices[j], options); + } + return object; + }; + + /** + * Converts this DevData to JSON. + * @function toJSON + * @memberof DevData + * @instance + * @returns {Object.} JSON object + */ + DevData.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return DevData; +})(); + +export const Input = $root.Input = (() => { + + /** + * Properties of an Input. + * @exports IInput + * @interface IInput + * @property {boolean|null} [connected] Input connected + * @property {number|Long|null} [buttons] Input buttons + * @property {Array.|null} [axes] Input axes + * @property {Source|null} [source] Input source + */ + + /** + * Constructs a new Input. + * @exports Input + * @classdesc Represents an Input. + * @implements IInput + * @constructor + * @param {IInput=} [properties] Properties to set + */ + function Input(properties) { + this.axes = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Input connected. + * @member {boolean} connected + * @memberof Input + * @instance + */ + Input.prototype.connected = false; + + /** + * Input buttons. + * @member {number|Long} buttons + * @memberof Input + * @instance + */ + Input.prototype.buttons = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * Input axes. + * @member {Array.} axes + * @memberof Input + * @instance + */ + Input.prototype.axes = $util.emptyArray; + + /** + * Input source. + * @member {Source} source + * @memberof Input + * @instance + */ + Input.prototype.source = 0; + + /** + * Creates a new Input instance using the specified properties. + * @function create + * @memberof Input + * @static + * @param {IInput=} [properties] Properties to set + * @returns {Input} Input instance + */ + Input.create = function create(properties) { + return new Input(properties); + }; + + /** + * Encodes the specified Input message. Does not implicitly {@link Input.verify|verify} messages. + * @function encode + * @memberof Input + * @static + * @param {IInput} message Input message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Input.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.connected != null && Object.hasOwnProperty.call(message, "connected")) + writer.uint32(/* id 1, wireType 0 =*/8).bool(message.connected); + if (message.buttons != null && Object.hasOwnProperty.call(message, "buttons")) + writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.buttons); + if (message.axes != null && message.axes.length) { + writer.uint32(/* id 3, wireType 2 =*/26).fork(); + for (let i = 0; i < message.axes.length; ++i) + writer.float(message.axes[i]); + writer.ldelim(); + } + if (message.source != null && Object.hasOwnProperty.call(message, "source")) + writer.uint32(/* id 4, wireType 0 =*/32).int32(message.source); + return writer; + }; + + /** + * Encodes the specified Input message, length delimited. Does not implicitly {@link Input.verify|verify} messages. + * @function encodeDelimited + * @memberof Input + * @static + * @param {IInput} message Input message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Input.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes an Input message from the specified reader or buffer. + * @function decode + * @memberof Input + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Input} Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Input.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Input(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.connected = reader.bool(); + break; + case 2: + message.buttons = reader.fixed64(); + break; + case 3: + if (!(message.axes && message.axes.length)) + message.axes = []; + if ((tag & 7) === 2) { + let end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.axes.push(reader.float()); + } else + message.axes.push(reader.float()); + break; + case 4: + message.source = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes an Input message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Input + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Input} Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Input.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies an Input message. + * @function verify + * @memberof Input + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Input.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.connected != null && message.hasOwnProperty("connected")) + if (typeof message.connected !== "boolean") + return "connected: boolean expected"; + if (message.buttons != null && message.hasOwnProperty("buttons")) + if (!$util.isInteger(message.buttons) && !(message.buttons && $util.isInteger(message.buttons.low) && $util.isInteger(message.buttons.high))) + return "buttons: integer|Long expected"; + if (message.axes != null && message.hasOwnProperty("axes")) { + if (!Array.isArray(message.axes)) + return "axes: array expected"; + for (let i = 0; i < message.axes.length; ++i) + if (typeof message.axes[i] !== "number") + return "axes: number[] expected"; + } + if (message.source != null && message.hasOwnProperty("source")) + switch (message.source) { + default: + return "source: enum value expected"; + case 0: + case 1: + break; + } + return null; + }; + + /** + * Creates an Input message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Input + * @static + * @param {Object.} object Plain object + * @returns {Input} Input + */ + Input.fromObject = function fromObject(object) { + if (object instanceof $root.Input) + return object; + let message = new $root.Input(); + if (object.connected != null) + message.connected = Boolean(object.connected); + if (object.buttons != null) + if ($util.Long) + (message.buttons = $util.Long.fromValue(object.buttons)).unsigned = false; + else if (typeof object.buttons === "string") + message.buttons = parseInt(object.buttons, 10); + else if (typeof object.buttons === "number") + message.buttons = object.buttons; + else if (typeof object.buttons === "object") + message.buttons = new $util.LongBits(object.buttons.low >>> 0, object.buttons.high >>> 0).toNumber(); + if (object.axes) { + if (!Array.isArray(object.axes)) + throw TypeError(".Input.axes: array expected"); + message.axes = []; + for (let i = 0; i < object.axes.length; ++i) + message.axes[i] = Number(object.axes[i]); + } + switch (object.source) { + case "GAMEPAD": + case 0: + message.source = 0; + break; + case "KEYBOARD": + case 1: + message.source = 1; + break; + } + return message; + }; + + /** + * Creates a plain object from an Input message. Also converts values to other types if specified. + * @function toObject + * @memberof Input + * @static + * @param {Input} message Input + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Input.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.axes = []; + if (options.defaults) { + object.connected = false; + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.buttons = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.buttons = options.longs === String ? "0" : 0; + object.source = options.enums === String ? "GAMEPAD" : 0; + } + if (message.connected != null && message.hasOwnProperty("connected")) + object.connected = message.connected; + if (message.buttons != null && message.hasOwnProperty("buttons")) + if (typeof message.buttons === "number") + object.buttons = options.longs === String ? String(message.buttons) : message.buttons; + else + object.buttons = options.longs === String ? $util.Long.prototype.toString.call(message.buttons) : options.longs === Number ? new $util.LongBits(message.buttons.low >>> 0, message.buttons.high >>> 0).toNumber() : message.buttons; + if (message.axes && message.axes.length) { + object.axes = []; + for (let j = 0; j < message.axes.length; ++j) + object.axes[j] = options.json && !isFinite(message.axes[j]) ? String(message.axes[j]) : message.axes[j]; + } + if (message.source != null && message.hasOwnProperty("source")) + object.source = options.enums === String ? $root.Source[message.source] : message.source; + return object; + }; + + /** + * Converts this Input to JSON. + * @function toJSON + * @memberof Input + * @instance + * @returns {Object.} JSON object + */ + Input.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Input; +})(); + +export const UserInputs = $root.UserInputs = (() => { + + /** + * Properties of a UserInputs. + * @exports IUserInputs + * @interface IUserInputs + * @property {Array.|null} [inputs] UserInputs inputs + */ + + /** + * Constructs a new UserInputs. + * @exports UserInputs + * @classdesc Represents a UserInputs. + * @implements IUserInputs + * @constructor + * @param {IUserInputs=} [properties] Properties to set + */ + function UserInputs(properties) { + this.inputs = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * UserInputs inputs. + * @member {Array.} inputs + * @memberof UserInputs + * @instance + */ + UserInputs.prototype.inputs = $util.emptyArray; + + /** + * Creates a new UserInputs instance using the specified properties. + * @function create + * @memberof UserInputs + * @static + * @param {IUserInputs=} [properties] Properties to set + * @returns {UserInputs} UserInputs instance + */ + UserInputs.create = function create(properties) { + return new UserInputs(properties); + }; + + /** + * Encodes the specified UserInputs message. Does not implicitly {@link UserInputs.verify|verify} messages. + * @function encode + * @memberof UserInputs + * @static + * @param {IUserInputs} message UserInputs message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + UserInputs.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.inputs != null && message.inputs.length) + for (let i = 0; i < message.inputs.length; ++i) + $root.Input.encode(message.inputs[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified UserInputs message, length delimited. Does not implicitly {@link UserInputs.verify|verify} messages. + * @function encodeDelimited + * @memberof UserInputs + * @static + * @param {IUserInputs} message UserInputs message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + UserInputs.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a UserInputs message from the specified reader or buffer. + * @function decode + * @memberof UserInputs + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {UserInputs} UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + UserInputs.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.UserInputs(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.inputs && message.inputs.length)) + message.inputs = []; + message.inputs.push($root.Input.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a UserInputs message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof UserInputs + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {UserInputs} UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + UserInputs.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a UserInputs message. + * @function verify + * @memberof UserInputs + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + UserInputs.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.inputs != null && message.hasOwnProperty("inputs")) { + if (!Array.isArray(message.inputs)) + return "inputs: array expected"; + for (let i = 0; i < message.inputs.length; ++i) { + let error = $root.Input.verify(message.inputs[i]); + if (error) + return "inputs." + error; + } + } + return null; + }; + + /** + * Creates a UserInputs message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof UserInputs + * @static + * @param {Object.} object Plain object + * @returns {UserInputs} UserInputs + */ + UserInputs.fromObject = function fromObject(object) { + if (object instanceof $root.UserInputs) + return object; + let message = new $root.UserInputs(); + if (object.inputs) { + if (!Array.isArray(object.inputs)) + throw TypeError(".UserInputs.inputs: array expected"); + message.inputs = []; + for (let i = 0; i < object.inputs.length; ++i) { + if (typeof object.inputs[i] !== "object") + throw TypeError(".UserInputs.inputs: object expected"); + message.inputs[i] = $root.Input.fromObject(object.inputs[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a UserInputs message. Also converts values to other types if specified. + * @function toObject + * @memberof UserInputs + * @static + * @param {UserInputs} message UserInputs + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + UserInputs.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.inputs = []; + if (message.inputs && message.inputs.length) { + object.inputs = []; + for (let j = 0; j < message.inputs.length; ++j) + object.inputs[j] = $root.Input.toObject(message.inputs[j], options); + } + return object; + }; + + /** + * Converts this UserInputs to JSON. + * @function toJSON + * @memberof UserInputs + * @instance + * @returns {Object.} JSON object + */ + UserInputs.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return UserInputs; +})(); + +/** + * Source enum. + * @exports Source + * @enum {number} + * @property {number} GAMEPAD=0 GAMEPAD value + * @property {number} KEYBOARD=1 KEYBOARD value + */ +export const Source = $root.Source = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "GAMEPAD"] = 0; + values[valuesById[1] = "KEYBOARD"] = 1; + return values; +})(); + +/** + * Mode enum. + * @exports Mode + * @enum {number} + * @property {number} IDLE=0 IDLE value + * @property {number} AUTO=1 AUTO value + * @property {number} TELEOP=2 TELEOP value + * @property {number} ESTOP=3 ESTOP value + * @property {number} CHALLENGE=4 CHALLENGE value + */ +export const Mode = $root.Mode = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "IDLE"] = 0; + values[valuesById[1] = "AUTO"] = 1; + values[valuesById[2] = "TELEOP"] = 2; + values[valuesById[3] = "ESTOP"] = 3; + values[valuesById[4] = "CHALLENGE"] = 4; + return values; +})(); + +export const RunMode = $root.RunMode = (() => { + + /** + * Properties of a RunMode. + * @exports IRunMode + * @interface IRunMode + * @property {Mode|null} [mode] RunMode mode + */ + + /** + * Constructs a new RunMode. + * @exports RunMode + * @classdesc Represents a RunMode. + * @implements IRunMode + * @constructor + * @param {IRunMode=} [properties] Properties to set + */ + function RunMode(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * RunMode mode. + * @member {Mode} mode + * @memberof RunMode + * @instance + */ + RunMode.prototype.mode = 0; + + /** + * Creates a new RunMode instance using the specified properties. + * @function create + * @memberof RunMode + * @static + * @param {IRunMode=} [properties] Properties to set + * @returns {RunMode} RunMode instance + */ + RunMode.create = function create(properties) { + return new RunMode(properties); + }; + + /** + * Encodes the specified RunMode message. Does not implicitly {@link RunMode.verify|verify} messages. + * @function encode + * @memberof RunMode + * @static + * @param {IRunMode} message RunMode message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RunMode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.mode != null && Object.hasOwnProperty.call(message, "mode")) + writer.uint32(/* id 1, wireType 0 =*/8).int32(message.mode); + return writer; + }; + + /** + * Encodes the specified RunMode message, length delimited. Does not implicitly {@link RunMode.verify|verify} messages. + * @function encodeDelimited + * @memberof RunMode + * @static + * @param {IRunMode} message RunMode message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RunMode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a RunMode message from the specified reader or buffer. + * @function decode + * @memberof RunMode + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {RunMode} RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RunMode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.RunMode(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.mode = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a RunMode message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof RunMode + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {RunMode} RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RunMode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a RunMode message. + * @function verify + * @memberof RunMode + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + RunMode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.mode != null && message.hasOwnProperty("mode")) + switch (message.mode) { + default: + return "mode: enum value expected"; + case 0: + case 1: + case 2: + case 3: + case 4: + break; + } + return null; + }; + + /** + * Creates a RunMode message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof RunMode + * @static + * @param {Object.} object Plain object + * @returns {RunMode} RunMode + */ + RunMode.fromObject = function fromObject(object) { + if (object instanceof $root.RunMode) + return object; + let message = new $root.RunMode(); + switch (object.mode) { + case "IDLE": + case 0: + message.mode = 0; + break; + case "AUTO": + case 1: + message.mode = 1; + break; + case "TELEOP": + case 2: + message.mode = 2; + break; + case "ESTOP": + case 3: + message.mode = 3; + break; + case "CHALLENGE": + case 4: + message.mode = 4; + break; + } + return message; + }; + + /** + * Creates a plain object from a RunMode message. Also converts values to other types if specified. + * @function toObject + * @memberof RunMode + * @static + * @param {RunMode} message RunMode + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + RunMode.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) + object.mode = options.enums === String ? "IDLE" : 0; + if (message.mode != null && message.hasOwnProperty("mode")) + object.mode = options.enums === String ? $root.Mode[message.mode] : message.mode; + return object; + }; + + /** + * Converts this RunMode to JSON. + * @function toJSON + * @memberof RunMode + * @instance + * @returns {Object.} JSON object + */ + RunMode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return RunMode; +})(); + +/** + * Pos enum. + * @exports Pos + * @enum {number} + * @property {number} LEFT=0 LEFT value + * @property {number} RIGHT=1 RIGHT value + */ +export const Pos = $root.Pos = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "LEFT"] = 0; + values[valuesById[1] = "RIGHT"] = 1; + return values; +})(); + +export const StartPos = $root.StartPos = (() => { + + /** + * Properties of a StartPos. + * @exports IStartPos + * @interface IStartPos + * @property {Pos|null} [pos] StartPos pos + */ + + /** + * Constructs a new StartPos. + * @exports StartPos + * @classdesc Represents a StartPos. + * @implements IStartPos + * @constructor + * @param {IStartPos=} [properties] Properties to set + */ + function StartPos(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * StartPos pos. + * @member {Pos} pos + * @memberof StartPos + * @instance + */ + StartPos.prototype.pos = 0; + + /** + * Creates a new StartPos instance using the specified properties. + * @function create + * @memberof StartPos + * @static + * @param {IStartPos=} [properties] Properties to set + * @returns {StartPos} StartPos instance + */ + StartPos.create = function create(properties) { + return new StartPos(properties); + }; + + /** + * Encodes the specified StartPos message. Does not implicitly {@link StartPos.verify|verify} messages. + * @function encode + * @memberof StartPos + * @static + * @param {IStartPos} message StartPos message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + StartPos.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.pos != null && Object.hasOwnProperty.call(message, "pos")) + writer.uint32(/* id 1, wireType 0 =*/8).int32(message.pos); + return writer; + }; + + /** + * Encodes the specified StartPos message, length delimited. Does not implicitly {@link StartPos.verify|verify} messages. + * @function encodeDelimited + * @memberof StartPos + * @static + * @param {IStartPos} message StartPos message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + StartPos.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a StartPos message from the specified reader or buffer. + * @function decode + * @memberof StartPos + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {StartPos} StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + StartPos.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.StartPos(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pos = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a StartPos message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof StartPos + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {StartPos} StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + StartPos.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a StartPos message. + * @function verify + * @memberof StartPos + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + StartPos.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.pos != null && message.hasOwnProperty("pos")) + switch (message.pos) { + default: + return "pos: enum value expected"; + case 0: + case 1: + break; + } + return null; + }; + + /** + * Creates a StartPos message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof StartPos + * @static + * @param {Object.} object Plain object + * @returns {StartPos} StartPos + */ + StartPos.fromObject = function fromObject(object) { + if (object instanceof $root.StartPos) + return object; + let message = new $root.StartPos(); + switch (object.pos) { + case "LEFT": + case 0: + message.pos = 0; + break; + case "RIGHT": + case 1: + message.pos = 1; + break; + } + return message; + }; + + /** + * Creates a plain object from a StartPos message. Also converts values to other types if specified. + * @function toObject + * @memberof StartPos + * @static + * @param {StartPos} message StartPos + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + StartPos.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) + object.pos = options.enums === String ? "LEFT" : 0; + if (message.pos != null && message.hasOwnProperty("pos")) + object.pos = options.enums === String ? $root.Pos[message.pos] : message.pos; + return object; + }; + + /** + * Converts this StartPos to JSON. + * @function toJSON + * @memberof StartPos + * @instance + * @returns {Object.} JSON object + */ + StartPos.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return StartPos; +})(); + +export const Text = $root.Text = (() => { + + /** + * Properties of a Text. + * @exports IText + * @interface IText + * @property {Array.|null} [payload] Text payload + */ + + /** + * Constructs a new Text. + * @exports Text + * @classdesc Represents a Text. + * @implements IText + * @constructor + * @param {IText=} [properties] Properties to set + */ + function Text(properties) { + this.payload = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Text payload. + * @member {Array.} payload + * @memberof Text + * @instance + */ + Text.prototype.payload = $util.emptyArray; + + /** + * Creates a new Text instance using the specified properties. + * @function create + * @memberof Text + * @static + * @param {IText=} [properties] Properties to set + * @returns {Text} Text instance + */ + Text.create = function create(properties) { + return new Text(properties); + }; + + /** + * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages. + * @function encode + * @memberof Text + * @static + * @param {IText} message Text message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Text.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.payload != null && message.payload.length) + for (let i = 0; i < message.payload.length; ++i) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.payload[i]); + return writer; + }; + + /** + * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages. + * @function encodeDelimited + * @memberof Text + * @static + * @param {IText} message Text message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Text.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Text message from the specified reader or buffer. + * @function decode + * @memberof Text + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Text} Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Text.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Text(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.payload && message.payload.length)) + message.payload = []; + message.payload.push(reader.string()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Text message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Text + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Text} Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Text.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Text message. + * @function verify + * @memberof Text + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Text.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.payload != null && message.hasOwnProperty("payload")) { + if (!Array.isArray(message.payload)) + return "payload: array expected"; + for (let i = 0; i < message.payload.length; ++i) + if (!$util.isString(message.payload[i])) + return "payload: string[] expected"; + } + return null; + }; + + /** + * Creates a Text message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Text + * @static + * @param {Object.} object Plain object + * @returns {Text} Text + */ + Text.fromObject = function fromObject(object) { + if (object instanceof $root.Text) + return object; + let message = new $root.Text(); + if (object.payload) { + if (!Array.isArray(object.payload)) + throw TypeError(".Text.payload: array expected"); + message.payload = []; + for (let i = 0; i < object.payload.length; ++i) + message.payload[i] = String(object.payload[i]); + } + return message; + }; + + /** + * Creates a plain object from a Text message. Also converts values to other types if specified. + * @function toObject + * @memberof Text + * @static + * @param {Text} message Text + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Text.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.payload = []; + if (message.payload && message.payload.length) { + object.payload = []; + for (let j = 0; j < message.payload.length; ++j) + object.payload[j] = message.payload[j]; + } + return object; + }; + + /** + * Converts this Text to JSON. + * @function toJSON + * @memberof Text + * @instance + * @returns {Object.} JSON object + */ + Text.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Text; +})(); + +export const TimeStamps = $root.TimeStamps = (() => { + + /** + * Properties of a TimeStamps. + * @exports ITimeStamps + * @interface ITimeStamps + * @property {number|Long|null} [dawnTimestamp] TimeStamps dawnTimestamp + * @property {number|Long|null} [runtimeTimestamp] TimeStamps runtimeTimestamp + */ + + /** + * Constructs a new TimeStamps. + * @exports TimeStamps + * @classdesc Represents a TimeStamps. + * @implements ITimeStamps + * @constructor + * @param {ITimeStamps=} [properties] Properties to set + */ + function TimeStamps(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * TimeStamps dawnTimestamp. + * @member {number|Long} dawnTimestamp + * @memberof TimeStamps + * @instance + */ + TimeStamps.prototype.dawnTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * TimeStamps runtimeTimestamp. + * @member {number|Long} runtimeTimestamp + * @memberof TimeStamps + * @instance + */ + TimeStamps.prototype.runtimeTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * Creates a new TimeStamps instance using the specified properties. + * @function create + * @memberof TimeStamps + * @static + * @param {ITimeStamps=} [properties] Properties to set + * @returns {TimeStamps} TimeStamps instance + */ + TimeStamps.create = function create(properties) { + return new TimeStamps(properties); + }; + + /** + * Encodes the specified TimeStamps message. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @function encode + * @memberof TimeStamps + * @static + * @param {ITimeStamps} message TimeStamps message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + TimeStamps.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.dawnTimestamp != null && Object.hasOwnProperty.call(message, "dawnTimestamp")) + writer.uint32(/* id 1, wireType 1 =*/9).fixed64(message.dawnTimestamp); + if (message.runtimeTimestamp != null && Object.hasOwnProperty.call(message, "runtimeTimestamp")) + writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.runtimeTimestamp); + return writer; + }; + + /** + * Encodes the specified TimeStamps message, length delimited. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @function encodeDelimited + * @memberof TimeStamps + * @static + * @param {ITimeStamps} message TimeStamps message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + TimeStamps.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a TimeStamps message from the specified reader or buffer. + * @function decode + * @memberof TimeStamps + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {TimeStamps} TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + TimeStamps.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TimeStamps(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.dawnTimestamp = reader.fixed64(); + break; + case 2: + message.runtimeTimestamp = reader.fixed64(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a TimeStamps message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof TimeStamps + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {TimeStamps} TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + TimeStamps.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a TimeStamps message. + * @function verify + * @memberof TimeStamps + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + TimeStamps.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.dawnTimestamp != null && message.hasOwnProperty("dawnTimestamp")) + if (!$util.isInteger(message.dawnTimestamp) && !(message.dawnTimestamp && $util.isInteger(message.dawnTimestamp.low) && $util.isInteger(message.dawnTimestamp.high))) + return "dawnTimestamp: integer|Long expected"; + if (message.runtimeTimestamp != null && message.hasOwnProperty("runtimeTimestamp")) + if (!$util.isInteger(message.runtimeTimestamp) && !(message.runtimeTimestamp && $util.isInteger(message.runtimeTimestamp.low) && $util.isInteger(message.runtimeTimestamp.high))) + return "runtimeTimestamp: integer|Long expected"; + return null; + }; + + /** + * Creates a TimeStamps message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof TimeStamps + * @static + * @param {Object.} object Plain object + * @returns {TimeStamps} TimeStamps + */ + TimeStamps.fromObject = function fromObject(object) { + if (object instanceof $root.TimeStamps) + return object; + let message = new $root.TimeStamps(); + if (object.dawnTimestamp != null) + if ($util.Long) + (message.dawnTimestamp = $util.Long.fromValue(object.dawnTimestamp)).unsigned = false; + else if (typeof object.dawnTimestamp === "string") + message.dawnTimestamp = parseInt(object.dawnTimestamp, 10); + else if (typeof object.dawnTimestamp === "number") + message.dawnTimestamp = object.dawnTimestamp; + else if (typeof object.dawnTimestamp === "object") + message.dawnTimestamp = new $util.LongBits(object.dawnTimestamp.low >>> 0, object.dawnTimestamp.high >>> 0).toNumber(); + if (object.runtimeTimestamp != null) + if ($util.Long) + (message.runtimeTimestamp = $util.Long.fromValue(object.runtimeTimestamp)).unsigned = false; + else if (typeof object.runtimeTimestamp === "string") + message.runtimeTimestamp = parseInt(object.runtimeTimestamp, 10); + else if (typeof object.runtimeTimestamp === "number") + message.runtimeTimestamp = object.runtimeTimestamp; + else if (typeof object.runtimeTimestamp === "object") + message.runtimeTimestamp = new $util.LongBits(object.runtimeTimestamp.low >>> 0, object.runtimeTimestamp.high >>> 0).toNumber(); + return message; + }; + + /** + * Creates a plain object from a TimeStamps message. Also converts values to other types if specified. + * @function toObject + * @memberof TimeStamps + * @static + * @param {TimeStamps} message TimeStamps + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + TimeStamps.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) { + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.dawnTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.dawnTimestamp = options.longs === String ? "0" : 0; + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.runtimeTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.runtimeTimestamp = options.longs === String ? "0" : 0; + } + if (message.dawnTimestamp != null && message.hasOwnProperty("dawnTimestamp")) + if (typeof message.dawnTimestamp === "number") + object.dawnTimestamp = options.longs === String ? String(message.dawnTimestamp) : message.dawnTimestamp; + else + object.dawnTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.dawnTimestamp) : options.longs === Number ? new $util.LongBits(message.dawnTimestamp.low >>> 0, message.dawnTimestamp.high >>> 0).toNumber() : message.dawnTimestamp; + if (message.runtimeTimestamp != null && message.hasOwnProperty("runtimeTimestamp")) + if (typeof message.runtimeTimestamp === "number") + object.runtimeTimestamp = options.longs === String ? String(message.runtimeTimestamp) : message.runtimeTimestamp; + else + object.runtimeTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.runtimeTimestamp) : options.longs === Number ? new $util.LongBits(message.runtimeTimestamp.low >>> 0, message.runtimeTimestamp.high >>> 0).toNumber() : message.runtimeTimestamp; + return object; + }; + + /** + * Converts this TimeStamps to JSON. + * @function toJSON + * @memberof TimeStamps + * @instance + * @returns {Object.} JSON object + */ + TimeStamps.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return TimeStamps; +})(); + +export { $root as default }; diff --git a/src/static/video-feed/sandstorm.png b/src/static/video-feed/sandstorm.png new file mode 100644 index 0000000000000000000000000000000000000000..3f41a7269f4d4ac46e210593d446cc81334d2127 GIT binary patch literal 1144548 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

W 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�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%0A?M@g>$05G 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 -MD9y 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 V7}#xBhuK#eYFgNmtN2dfe*&N{W}yH8 literal 0 HcmV?d00001 diff --git a/src/static/video-feed/scoreboard.css b/src/static/video-feed/scoreboard.css new file mode 100644 index 0000000..54065e8 --- /dev/null +++ b/src/static/video-feed/scoreboard.css @@ -0,0 +1,108 @@ +body { + background-size: cover; + height: 100vh; + width: 100%; + background-color: transparent; +} + +p { + padding-left: 5px; +} + +.scoreboard-outer-container { + position: absolute; + top: 0; + right: 0; + width: 60%; + height: 100%; +} + +.scoreboard-container { + display: flex; + justify-content: space-evenly; + align-items: stretch; + flex-direction: row; + padding: 10px; + height: 200px; +} + +.total-container { + display: flex; + justify-content: space-evenly; + align-items: stretch; + flex-direction: row; + padding: 10px; + height: 250px; +} + +#stagename-container { + height: calc(10vh); +} + +.robotinfo, .time, .penalty, .stamps { + margin: 20px; + border: solid black; + background-color: white; + border-radius: 25px; + text-align: center; + font-family: "Comic Sans MS", "Comic Sans", cursive; + font-size: 2.4vw; + justify-content: center; + align-content: center; + display: flex; + flex-direction: column; +} + +.totalinfo { + margin: 15px; + border: solid black; + background-color: white; + border-radius: 25px; + text-align: center; + font-family: "Comic Sans MS", "Comic Sans", cursive; + width: calc(40vh); + visibility: visible; + font-size: 200%; + justify-content: center; + align-content: center; + display: flex; + flex-direction: column; +} + +#total { + visibility: visible; + font-size: 200% +} + +.stagename { + height: calc(10vh); + width: calc(45vh) +} + +.time, .penalty, .stamps { + flex-direction: column; + vertical-align: top; + flex-grow: 1; + flex-wrap: wrap; +} + +.robotinfo { + flex-grow: 2; +} + +.time { + color: black; +} + +.penalty { + color: red; +} + +.stamps { + color: green; +} + +mark.black { + color: black; + background: none; +} diff --git a/src/static/video-feed/scoreboard.html b/src/static/video-feed/scoreboard.html new file mode 100644 index 0000000..ef3a1aa --- /dev/null +++ b/src/static/video-feed/scoreboard.html @@ -0,0 +1,53 @@ + + + + + + + +

+
+ + +
+ Team 123 +
Bo Gears Elem.
+
+ +
+
Time
+
0:00
+
+ +
+
Penalty
+
+ 0:00
+
+ +
+
Stamps
+
- 0:00
+
+
+ +
+
+
Total Score
+
0
+
+
+
+ + + + diff --git a/src/static/video-feed/video-feed.css b/src/static/video-feed/video-feed.css new file mode 100644 index 0000000..cf69493 --- /dev/null +++ b/src/static/video-feed/video-feed.css @@ -0,0 +1,30 @@ +.video-feed-container { + position: relative; + height: 100%; + overflow: hidden; + width: 100%; + z-index: -1; +} + +#overhead-video-feed { + width: 30%; + height: 30%; + position: absolute; + top: 0; + left: 0; +} + +#shepherd-overlay { + position: absolute; + top: 0; + width: 100%; + height: 100%; +} + +#footer { + display: flex; + padding: 8px; + position: absolute; + bottom: 0; + right: 0; +} diff --git a/src/static/video-feed/video.html b/src/static/video-feed/video.html new file mode 100644 index 0000000..36c0a6c --- /dev/null +++ b/src/static/video-feed/video.html @@ -0,0 +1,17 @@ + + + + + + + + + Video Feed + + +
+ + + diff --git a/src/video-feed/Scoreboard.js b/src/video-feed/Scoreboard.js new file mode 100644 index 0000000..9d50b6b --- /dev/null +++ b/src/video-feed/Scoreboard.js @@ -0,0 +1,314 @@ +const io = require('socket.io-client'); +const { ipcRenderer } = require('electron'); +const $ = require('jquery'); +var socket = io('/'); +console.log('socket', socket); +addSocketCallbacks(socket); + +ipcRenderer.on('shepherdScoreboardServerIpAddress', (e, ipAddress) => { + socket.disconnect(); + socket = io.connect(`${ipAddress}`); + console.log('new socket', socket); + addSocketCallbacks(socket); +}) + +function addSocketCallbacks(socket) { + socket.on('connect', (data) => { + console.log('connected to scoreboard server'); + socket.emit('join', 'scoreboard'); + }); + + socket.on('team', (match_info) => { + console.log(`received team header with info ${match_info}`); + match_info = JSON.parse(match_info) + const team_name = match_info.team_name + const team_num = match_info.team_num + updateTeam(team_name, team_num) + setImageVisible('#total', false); + setImageVisible('.totalinfo', false); + }) + + socket.on('stage_timer_start', (secondsInStage) => { + const time = JSON.parse(secondsInStage).time + stageTimerStart(time) + }) + + // STAGE{stage, start_time} + socket.on('stage', (stage_details) => { + const stage = JSON.parse(stage_details).stage + const start_time = JSON.parse(stage_details).start_time + console.log("got stage header") + console.log(stage_details) + if (stage === "setup") { + setTime(0); + setStamp(0); + setPenalty(0); + } else if (stage === "end") { + stageTimer = false; + } else { + setStageName(stage); + setStartTime(start_time); + } + }) + + socket.on("reset_timers", () => { + resetTimers(); + }) + + + // SCORES{time, penalty, stamp_time, score, start_time} + socket.on("score", (scores) => { + console.log("receiving score"); + scores = JSON.parse(scores); + console.log(`scores are ${JSON.stringify(scores)}`); + const { time, penalty, stamp_time } = scores; + + console.log("THIS SHOULD PRINT") + console.log(time) + if (time) { + console.log("Setting time") + setTime(time); + setTotal(time + stamp_time + penalty) + } + setStamp(stamp_time); + setPenalty(penalty); + console.log(time) + // if (time) { + // console.log("Setting total") + // setTotal(time - stamp_time + penalty) + // } + }) + + socket.on("sandstorm", (sandstorm) => { + const on = JSON.parse(sandstorm).on; + if (on) { + console.log("Setting sandstorm"); + setSandstorm(); + } else { + console.log("Removing sandstorm"); + removeSandstorm(); + } + }) +} + +var stageTimer = true; +var timerA = true; +var globaltime = 0; +var startTime = 0; + +function setSandstorm() { + $('body').css('background-image', 'url(../../static/video-feed/sandstorm.png)'); +} + +function removeSandstorm() { + $('body').css('background-image', 'url()'); +} + +function setTime(time) { + stageTimer = false; + globaltime = time; + $('#stage-timer').html(secondsToTimeString(time)); +} + +function setStamp(stamp_time) { + $('#stamp_time').html("-" + secondsToTimeString(-1 * stamp_time)); +} + +function setPenalty(penalty) { + $('#penalty').html("+" + secondsToTimeString(penalty)); +} + +function setTotal(total) { + // Hypothetically make it visible here + console.log("Inside setTotal") + $('#total').html(secondsToTimeString(total)); + setImageVisible('#total', true); + setImageVisible('.totalinfo', true); +} + +function testScore(score) { + $('#score').html(score); +} + +function resetTimers() { + stageTimer = false; + timerA = false; +} + +const SETUP = "setup" +const AUTO_WAIT = "auto_wait" +const AUTO = "auto" +const WAIT = "wait" +const TELEOP = "teleop" +const END = "end" + +const stage_names = { + "setup": "Setup", + "auto_wait": "Autonomous Wait", "auto": "Autonomous Period", + "teleop": "Teleop Period", "end": "Post-Match" +} + +function setStageName(stage) { + $('#stage').html(stage_names[stage]) +} + +function updateTeam(team_name, team_num) { + //set the name and numbers of the school and the match number jk + $('#team-name').html(team_name) + $('#team-num').html("Team " + team_num) +} + +function stageTimerStart(startTime) { + stageTimer = true; + runStageTimer(startTime); +} + +function runStageTimer(startTime) { + console.log("stage timer is ", stageTimer); + if (stageTimer) { + const currTime = new Date().getTime() / 1000; + console.log(currTime); + console.log(startTime); + let time = (currTime - startTime); + $('#stage-timer').html(secondsToTimeString(time)); + setTimeout(runStageTimer, 200, startTime); + } else { + // supposedly do nothing + return + } +} + +function pad(number) { + return (number < 10 ? '0' : '') + number +} + +function secondsToTimeString(seconds) { + if (seconds < 0) { + const time = Math.floor(-1 * seconds * 100) / 100; + return "-" + Math.floor(time / 60) + ":" + pad(Math.floor(time % 60)); + } else { + const time = Math.floor(seconds * 100) / 100; + return Math.floor(time / 60) + ":" + pad(Math.floor(time % 60)); + } +} + +function setImageVisible(id, visible) { + console.log("Set visible/invisible") + $(id).css("visibility", (visible ? 'visible' : 'hidden')); +} + +function progress(timeleft, timetotal, $element) { + var progressBarWidth = timeleft * $element.width() / timetotal; + if (timeleft == timetotal) { + $element.find('div').animate({ width: progressBarWidth }, 0, 'linear').html(Math.floor(timeleft / 60) + ":" + pad(timeleft % 60)); + } else { + $element.find('div').animate({ width: progressBarWidth }, 1000, 'linear').html(Math.floor(timeleft / 60) + ":" + pad(timeleft % 60)); + } + if (timeleft > 0) { + setTimeout(function () { + if (overTimer) { + progress(timeleft - 1, timetotal, $element); + } else { + progress(0, 0, $element) + } + }, 1000); + } else { + $element.find('div').animate({ width: 0 }, 1000, 'linear').html("") + $('#overdriveText').css('color', 'white'); + // $('#overdriveText').html("OVERDRIVE!!! " + block + " size!!!"); + } +}; + +var a = 0 + , pi = Math.PI + , t = 30 + +var counter = t; + +console.log($("textbox").text() + "x") +console.log(t) + +function draw() { + // a should depend on the amount of time left + a++; + a %= 360; + var r = (a * pi / 180) + , x = Math.sin(r) * 15000 + , y = Math.cos(r) * - 15000 + , mid = (a > 180) ? 1 : 0 + , anim = + 'M 0 0 v -15000 A 15000 15000 1 ' + + mid + ' 1 ' + + x + ' ' + + y + ' z'; + //[x,y].forEach(function( d ){ + // d = Math.round( d * 1e3 ) / 1e3; + //}); + $("#loader").attr('d', anim); + console.log(counter); + + // time left should be calculated using a timer that runs separately + if (a % (360 / t) == 0) { + counter -= 1; + if (counter <= 9) { + $("#textbox").css("left = '85px';") + } + $("#textbox").html(counter); + } + if (a == 0) { + return; + } + setTimeout(draw, 20); // Redraw +}; + +function runTimer1() { + timerA = true; + console.log("timerA set to true") + console.log(timerA) + //setTimeout(timer1, 0) + launchButtonTimer('.timer1', '.circle_animation1', timerA); +} + +function timer1() { + /* how long the timer will run (seconds) */ + + var time = 30; + var initialOffset = '440'; + var i = 1; + + /* Need initial run as interval hasn't yet occured... */ + $('.circle_animation1').css('stroke-dashoffset', initialOffset - (1 * (initialOffset / time))); + + var interval = setInterval(function () { + $('.timer1').text(time - i); + if (i == time || !timerA) { + clearInterval(interval); + $('.timer1').text(30); + $('.circle_animation1').css('stroke-dashoffset', '0') + return; + } + $('.circle_animation1').css('stroke-dashoffset', initialOffset - ((i + 1) * (initialOffset / time))); + i++; + }, 1000); + +} + +function setStartTime(start_time) { + // A function that takes in the starting time of the stage as sent by Shepherd. We calculate + // the difference between the current time and the sent timestamp, and set the starting time + // to be the amount of time given in the round minus the offset. + // + // Args: + // start_time = timestamp sent by Shepherd of when the stage began in seconds + start_time = start_time / 1000; // seconds + + stageTimerStart(start_time); +} + + +/* FOR TESTING: */ +// var jq = document.createElement('script'); +// jq.src = "https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"; +// document.getElementsByTagName('head')[0].appendChild(jq); +// // ... give time for script to load, then type (or see below for non wait option) +// jQuery.noConflict(); \ No newline at end of file diff --git a/src/video-feed/ShepherdOverlay.tsx b/src/video-feed/ShepherdOverlay.tsx new file mode 100644 index 0000000..cb48338 --- /dev/null +++ b/src/video-feed/ShepherdOverlay.tsx @@ -0,0 +1,11 @@ +import parse from 'html-react-parser'; +import './scoreboard'; +import '../../../static/video-feed/scoreboard.css'; + +const shepherdScoreHtml = require('../../../static/video-feed/scoreboard.html'); + +export const ShepherdOverlay = () => { + return ( + parse(shepherdScoreHtml) + ); +}; diff --git a/src/video-feed/VideoFeed.tsx b/src/video-feed/VideoFeed.tsx new file mode 100644 index 0000000..c089dab --- /dev/null +++ b/src/video-feed/VideoFeed.tsx @@ -0,0 +1,151 @@ +import React, { useEffect, useRef, useState } from 'react'; +import { Button } from 'react-bootstrap'; +import OvenPlayer from 'ovenplayer'; +import { keyboardButtons } from '../keyboard-buttons'; +import * as protos from '../../protos/protos'; + +import '../static/video-feed/video-feed.css'; +import { ShepherdOverlay } from './ShepherdOverlay'; + +type Props = { + webSocket: WebSocket +} + +export const VideoFeed = (props: Props) => { + const [isKeyboardModeToggled, setIsKeyboardModeToggled] = useState(false); + const {webSocket} = props; + const [keyboardBitmap, setKeyboardBitmap] = useState(0); + const keyboardBitmapRef = useRef(0); + keyboardBitmapRef.current = keyboardBitmap; + + useEffect(() => { + const driverVideoFeed = OvenPlayer.create('driver-video-feed', { + sources: [ + { + type: 'webRTC', + file: 'ws://64.227.109.107:3333/driver/stream', + label: '720p' + } + ], + autoStart: true, + controls: false + }); + + const overheadVideoFeed = OvenPlayer.create('overhead-video-feed', { + sources: [ + { + type: 'webRTC', + file: 'ws://64.227.109.107:3333/overhead/stream', + label: '720p' + } + ], + autoStart: true, + controls: false + }); + + overheadVideoFeed.on('error', (error: any) => { + console.log(error); + }); + + driverVideoFeed.on('error', (error: any) => { + console.log(error); + }); + }, []); + + useEffect(() => { + const keyboardConnectionStatus = new protos.Input({ + connected: isKeyboardModeToggled, + axes: [], + buttons: 0, + source: protos.Source.KEYBOARD + }) + webSocket.send(protos.UserInputs.encode({ inputs: keyboardConnectionStatus }).finish()); +// ipcRenderer.send('stateUpdate', [keyboardConnectionStatus], Source.KEYBOARD); + }, [isKeyboardModeToggled, webSocket]); + + const sendKeyboardInputsToRuntime = (keyboardBitmap_: number) => { + const keyboard = new protos.Input({ + connected: true, + axes: [], + buttons: keyboardBitmap_, + source: protos.Source.KEYBOARD + }); + webSocket.send(protos.UserInputs.encode({ inputs: keyboard }).finish()); + }; + + const bitShiftLeft = (value: number, numPositions: number) => { + return value * Math.pow(2, numPositions); + }; + + // toggle keyboard control and add/remove listening for key presses to control robot + const toggleKeyboardControl = () => { + if (!isKeyboardModeToggled) { + // We need passive true so that we are able to remove the event listener when we are not in Keyboard Control mode + window.addEventListener('keydown', turnCharacterOn, { passive: true }); + window.addEventListener('keyup', turnCharacterOff, { passive: true }); + } else { + window.removeEventListener('keydown', turnCharacterOn); + window.removeEventListener('keyup', turnCharacterOff); + setKeyboardBitmap(0); + } + + setIsKeyboardModeToggled(!isKeyboardModeToggled); + }; + + const updateKeyboardBitmap = (currentCharacter: string, isKeyPressed: boolean) => { + const keyboardNum = keyboardButtons[currentCharacter]; + let newKeyboardBitmap: number = keyboardBitmapRef.current; + + const shift = bitShiftLeft(1, keyboardNum); + const MAX_INT32_BITS = 2147483648; // 2^31 + + const shiftHighBits = shift / MAX_INT32_BITS; + const shiftLowBits = shift % MAX_INT32_BITS; + const mapHighBits = newKeyboardBitmap / MAX_INT32_BITS; + const mapLowBits = newKeyboardBitmap % MAX_INT32_BITS; + + if (!isKeyPressed) { + newKeyboardBitmap = (~shiftHighBits & mapHighBits) * MAX_INT32_BITS + (~shiftLowBits & mapLowBits); + } else if (isKeyPressed) { + newKeyboardBitmap = (shiftHighBits | mapHighBits) * MAX_INT32_BITS + (shiftLowBits | mapLowBits); + } + setKeyboardBitmap(newKeyboardBitmap); + sendKeyboardInputsToRuntime(newKeyboardBitmap); + }; + + const turnCharacterOff = (e: KeyboardEvent) => { + updateKeyboardBitmap(e.key, false); + }; + + const turnCharacterOn = (e: KeyboardEvent) => { + // Handle special ctrl + q edge case + if (e.ctrlKey && e.key === 'q') { + setIsKeyboardModeToggled(false); + } else { + updateKeyboardBitmap(e.key, true); + } + }; + + return ( + <> +
+
+
+
+ +
{ShepherdOverlay()}
+ + + + ); +}; \ No newline at end of file diff --git a/src/video-feed/index.tsx b/src/video-feed/index.tsx new file mode 100644 index 0000000..e35b509 --- /dev/null +++ b/src/video-feed/index.tsx @@ -0,0 +1,5 @@ +import React from 'react'; +import ReactDOM from 'react-dom'; +import { VideoFeed } from './VideoFeed'; + +ReactDOM.render(, document.getElementById('video-feed-window')); diff --git a/tsconfig.json b/tsconfig.json index a273b0c..d0ca0f9 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -22,5 +22,8 @@ }, "include": [ "src" + ], + "exclude": [ + "src/video-feed/**" ] } diff --git a/yarn.lock b/yarn.lock index aac3c2b..066b10c 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1448,6 +1448,59 @@ schema-utils "^2.6.5" source-map "^0.7.3" +"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf" + integrity sha1-m4sMxmPWaafY9vXQiToU00jzD78= + +"@protobufjs/base64@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735" + integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg== + +"@protobufjs/codegen@^2.0.4": + version "2.0.4" + resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb" + integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg== + +"@protobufjs/eventemitter@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70" + integrity sha1-NVy8mLr61ZePntCV85diHx0Ga3A= + +"@protobufjs/fetch@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45" + integrity sha1-upn7WYYUr2VwDBYZ/wbUVLDYTEU= + dependencies: + "@protobufjs/aspromise" "^1.1.1" + "@protobufjs/inquire" "^1.1.0" + +"@protobufjs/float@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1" + integrity sha1-Xp4avctz/Ap8uLKR33jIy9l7h9E= + +"@protobufjs/inquire@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089" + integrity sha1-/yAOPnzyQp4tyvwRQIKOjMY48Ik= + +"@protobufjs/path@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d" + integrity sha1-bMKyDFya1q0NzP0hynZz2Nf79o0= + +"@protobufjs/pool@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54" + integrity sha1-Cf0V8tbTq/qbZbw2ZQbWrXhG/1Q= + +"@protobufjs/utf8@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570" + integrity sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA= + "@rollup/plugin-node-resolve@^7.1.1": version "7.1.3" resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-7.1.3.tgz#80de384edfbd7bfc9101164910f86078151a3eca" @@ -1688,6 +1741,11 @@ dependencies: "@babel/types" "^7.3.0" +"@types/component-emitter@^1.2.10": + version "1.2.10" + resolved "https://registry.yarnpkg.com/@types/component-emitter/-/component-emitter-1.2.10.tgz#ef5b1589b9f16544642e473db5ea5639107ef3ea" + integrity sha512-bsjleuRKWmGqajMerkzox19aGbscQX5rmmvvXl3wlIp5gMG1HgkiwPxsN5p070fBDKTNSPgojVbuY1+HWMbFhg== + "@types/eslint@^7.2.6": version "7.2.6" resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-7.2.6.tgz#5e9aff555a975596c03a98b59ecd103decc70c3c" @@ -1771,6 +1829,11 @@ resolved "https://registry.yarnpkg.com/@types/json5/-/json5-0.0.29.tgz#ee28707ae94e11d2b827bcbe5270bcea7f3e71ee" integrity sha1-7ihweulOEdK4J7y+UnC86n8+ce4= +"@types/long@^4.0.1": + version "4.0.1" + resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.1.tgz#459c65fa1867dafe6a8f322c4c51695663cc55e9" + integrity sha512-5tXH6Bx/kNGd3MgffdmP4dy2Z+G4eaXw0SE81Tq3BNadtnMR5/ySMzX4SLEzHJzSmPNn4HIdpQsBvXMUykr58w== + "@types/minimatch@*": version "3.0.3" resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.3.tgz#3dca0e3f33b200fc7d1139c0cd96c1268cadfd9d" @@ -1781,6 +1844,11 @@ resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.31.tgz#72286bd33d137aa0d152d47ec7c1762563d34055" integrity sha512-vFHy/ezP5qI0rFgJ7aQnjDXwAMrG0KqqIH7tQG5PPv3BWBayOPIQNBjVc/P6hhdZfMx51REc6tfDNXHUio893g== +"@types/node@>=13.7.0": + version "16.9.1" + resolved "https://registry.yarnpkg.com/@types/node/-/node-16.9.1.tgz#0611b37db4246c937feef529ddcc018cf8e35708" + integrity sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g== + "@types/node@^12.0.0": version "12.20.24" resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.24.tgz#c37ac69cb2948afb4cef95f424fa0037971a9a5c" @@ -2725,11 +2793,21 @@ babylon@^6.18.0: resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3" integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ== +backo2@~1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/backo2/-/backo2-1.0.2.tgz#31ab1ac8b129363463e35b3ebb69f4dfcfba7947" + integrity sha1-MasayLEpNjRj41s+u2n038+6eUc= + balanced-match@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767" integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c= +base64-arraybuffer@0.1.4: + version "0.1.4" + resolved "https://registry.yarnpkg.com/base64-arraybuffer/-/base64-arraybuffer-0.1.4.tgz#9818c79e059b1355f97e0428a017c838e90ba812" + integrity sha1-mBjHngWbE1X5fgQooBfIOOkLqBI= + base64-js@^1.0.2: version "1.5.1" resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" @@ -3406,7 +3484,7 @@ commondir@^1.0.1: resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b" integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs= -component-emitter@^1.2.1: +component-emitter@^1.2.1, component-emitter@~1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0" integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg== @@ -3942,6 +4020,13 @@ debug@^4.0.1, debug@^4.1.0, debug@^4.1.1: dependencies: ms "2.1.2" +debug@~4.3.1, debug@~4.3.2: + version "4.3.2" + resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.2.tgz#f0a49c18ac8779e31d4a0c6029dfb76873c7428b" + integrity sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw== + dependencies: + ms "2.1.2" + decamelize@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" @@ -4318,6 +4403,29 @@ end-of-stream@^1.0.0, end-of-stream@^1.1.0: dependencies: once "^1.4.0" +engine.io-client@~5.2.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/engine.io-client/-/engine.io-client-5.2.0.tgz#ae38c79a4af16258c0300e6819c0ea8ecc1597cd" + integrity sha512-BcIBXGBkT7wKecwnfrSV79G2X5lSUSgeAGgoo60plXf8UsQEvCQww/KMwXSMhVjb98fFYNq20CC5eo8IOAPqsg== + dependencies: + base64-arraybuffer "0.1.4" + component-emitter "~1.3.0" + debug "~4.3.1" + engine.io-parser "~4.0.1" + has-cors "1.1.0" + parseqs "0.0.6" + parseuri "0.0.6" + ws "~7.4.2" + xmlhttprequest-ssl "~2.0.0" + yeast "0.1.2" + +engine.io-parser@~4.0.1: + version "4.0.3" + resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-4.0.3.tgz#83d3a17acfd4226f19e721bb22a1ee8f7662d2f6" + integrity sha512-xEAAY0msNnESNPc00e19y5heTPX4y/TJ36gr8t1voOaNmTojP9b3oK3BbJLFufW2XFPQaaijpFewm2g2Um3uqA== + dependencies: + base64-arraybuffer "0.1.4" + enhanced-resolve@^4.3.0: version "4.5.0" resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec" @@ -5387,6 +5495,11 @@ harmony-reflect@^1.4.6: resolved "https://registry.yarnpkg.com/harmony-reflect/-/harmony-reflect-1.6.1.tgz#c108d4f2bb451efef7a37861fdbdae72c9bdefa9" integrity sha512-WJTeyp0JzGtHcuMsi7rw2VwtkvLa+JyfEKJCFyfcS0+CDkjQ5lHPu7zEhFZP+PDSRrEgXa5Ah0l1MbgbE41XjA== +has-cors@1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/has-cors/-/has-cors-1.1.0.tgz#5e474793f7ea9843d1bb99c23eef49ff126fff39" + integrity sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk= + has-flag@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" @@ -7007,6 +7120,11 @@ loglevel@^1.6.8: resolved "https://registry.yarnpkg.com/loglevel/-/loglevel-1.7.1.tgz#005fde2f5e6e47068f935ff28573e125ef72f197" integrity sha512-Hesni4s5UkWkwCGJMQGAh71PaLUmKFM60dHvq0zi/vDhhrzuk+4GgNbTXJ12YYQJn6ZKBDNIjYcuQGKudvqrIw== +long@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/long/-/long-4.0.0.tgz#9a7b71cfb7d361a194ea555241c92f7468d5bf28" + integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA== + loose-envify@^1.1.0, loose-envify@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf" @@ -7904,6 +8022,16 @@ parse5@5.1.1: resolved "https://registry.yarnpkg.com/parse5/-/parse5-5.1.1.tgz#f68e4e5ba1852ac2cadc00f4555fff6c2abb6178" integrity sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug== +parseqs@0.0.6: + version "0.0.6" + resolved "https://registry.yarnpkg.com/parseqs/-/parseqs-0.0.6.tgz#8e4bb5a19d1cdc844a08ac974d34e273afa670d5" + integrity sha512-jeAGzMDbfSHHA091hr0r31eYfTig+29g3GKKE/PPbEQ65X0lmMwlEoqmhzu0iztID5uJpZsFlUPDP8ThPL7M8w== + +parseuri@0.0.6: + version "0.0.6" + resolved "https://registry.yarnpkg.com/parseuri/-/parseuri-0.0.6.tgz#e1496e829e3ac2ff47f39a4dd044b32823c4a25a" + integrity sha512-AUjen8sAkGgao7UyCX6Ahv0gIK2fABKmYjvP4xmy5JaKvcbTRueIqIPHLAfq30xJddqSE033IOMUSOMCcK3Sow== + parseurl@~1.3.2, parseurl@~1.3.3: version "1.3.3" resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4" @@ -8846,6 +8974,25 @@ prop-types@^15.7.2: object-assign "^4.1.1" react-is "^16.8.1" +protobufjs@^6.11.2: + version "6.11.2" + resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-6.11.2.tgz#de39fabd4ed32beaa08e9bb1e30d08544c1edf8b" + integrity sha512-4BQJoPooKJl2G9j3XftkIXjoC9C0Av2NOrWmbLWT1vH32GcSUHjM0Arra6UfTsVyfMAuFzaLucXn1sadxJydAw== + dependencies: + "@protobufjs/aspromise" "^1.1.2" + "@protobufjs/base64" "^1.1.2" + "@protobufjs/codegen" "^2.0.4" + "@protobufjs/eventemitter" "^1.1.0" + "@protobufjs/fetch" "^1.1.0" + "@protobufjs/float" "^1.0.2" + "@protobufjs/inquire" "^1.1.0" + "@protobufjs/path" "^1.1.2" + "@protobufjs/pool" "^1.1.0" + "@protobufjs/utf8" "^1.1.0" + "@types/long" "^4.0.1" + "@types/node" ">=13.7.0" + long "^4.0.0" + proxy-addr@~2.0.5: version "2.0.6" resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.6.tgz#fdc2336505447d3f2f2c638ed272caf614bbb2bf" @@ -9924,6 +10071,28 @@ snapdragon@^0.8.1: source-map-resolve "^0.5.0" use "^3.1.0" +socket.io-client@^4.2.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/socket.io-client/-/socket.io-client-4.2.0.tgz#195feed3de40283b1ae3f7d02cf91d3eb2c905c1" + integrity sha512-3GJ2KMh7inJUNAOjgf8NaKJZJa9uRyfryh2LrVJyKyxmzoXlfW9DeDNqylJn0ovOFt4e/kRLNWzMt/YqqEWYSA== + dependencies: + "@types/component-emitter" "^1.2.10" + backo2 "~1.0.2" + component-emitter "~1.3.0" + debug "~4.3.2" + engine.io-client "~5.2.0" + parseuri "0.0.6" + socket.io-parser "~4.0.4" + +socket.io-parser@~4.0.4: + version "4.0.4" + resolved "https://registry.yarnpkg.com/socket.io-parser/-/socket.io-parser-4.0.4.tgz#9ea21b0d61508d18196ef04a2c6b9ab630f4c2b0" + integrity sha512-t+b0SS+IxG7Rxzda2EVvyBZbvFPBCjJoyHuE0P//7OAsN23GItzDRdWa6ALxZI/8R5ygK7jAR6t028/z+7295g== + dependencies: + "@types/component-emitter" "^1.2.10" + component-emitter "~1.3.0" + debug "~4.3.1" + sockjs-client@^1.5.0: version "1.5.0" resolved "https://registry.yarnpkg.com/sockjs-client/-/sockjs-client-1.5.0.tgz#2f8ff5d4b659e0d092f7aba0b7c386bd2aa20add" @@ -11419,6 +11588,16 @@ ws@^7.2.3: resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.3.tgz#1f9643de34a543b8edb124bdcbc457ae55a6e5cd" integrity sha512-hr6vCR76GsossIRsr8OLR9acVVm1jyfEWvhbNjtgPOrfvAlKzvyeg/P6r8RuDjRyrcQoPQT7K0DGEPc7Ae6jzA== +ws@^8.2.2: + version "8.2.2" + resolved "https://registry.yarnpkg.com/ws/-/ws-8.2.2.tgz#ca684330c6dd6076a737250ed81ac1606cb0a63e" + integrity sha512-Q6B6H2oc8QY3llc3cB8kVmQ6pnJWVQbP7Q5algTcIxx7YEpc0oU4NBVHlztA7Ekzfhw2r0rPducMUiCGWKQRzw== + +ws@~7.4.2: + version "7.4.6" + resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.6.tgz#5654ca8ecdeee47c33a9a4bf6d28e2be2980377c" + integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A== + xml-name-validator@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-3.0.0.tgz#6ae73e06de4d8c6e47f9fb181f78d648ad457c6a" @@ -11429,6 +11608,11 @@ xmlchars@^2.2.0: resolved "https://registry.yarnpkg.com/xmlchars/-/xmlchars-2.2.0.tgz#060fe1bcb7f9c76fe2a17db86a9bc3ab894210cb" integrity sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw== +xmlhttprequest-ssl@~2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/xmlhttprequest-ssl/-/xmlhttprequest-ssl-2.0.0.tgz#91360c86b914e67f44dce769180027c0da618c67" + integrity sha512-QKxVRxiRACQcVuQEYFsI1hhkrMlrXHPegbbd1yn9UHOmRxY+si12nQYzri3vbzt8VdTTRviqcKxcyllFas5z2A== + xtend@^4.0.0, xtend@~4.0.1: version "4.0.2" resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54" @@ -11503,6 +11687,11 @@ yargs@^15.4.1: y18n "^4.0.0" yargs-parser "^18.1.2" +yeast@0.1.2: + version "0.1.2" + resolved "https://registry.yarnpkg.com/yeast/-/yeast-0.1.2.tgz#008e06d8094320c372dbc2f8ed76a0ca6c8ac419" + integrity sha1-AI4G2AlDIMNy28L47XagymyKxBk= + yocto-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" From 5bc4521516f8a69d499db7404765483760a12964 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 2 Oct 2021 13:43:04 -0700 Subject: [PATCH 02/10] Comment out RuntimeConnection for now --- src/connections/RuntimeConnection.ts | 327 +++++++++++++++++++++++++++ 1 file changed, 327 insertions(+) create mode 100644 src/connections/RuntimeConnection.ts diff --git a/src/connections/RuntimeConnection.ts b/src/connections/RuntimeConnection.ts new file mode 100644 index 0000000..5c745d1 --- /dev/null +++ b/src/connections/RuntimeConnection.ts @@ -0,0 +1,327 @@ +export {}; +// import { Logger } from '../utils'; + +// /** +// * Define port constants, which must match with Runtime +// */ +// const DEFAULT_CONNECTION_PORT = 5000; + +// /** +// * Runtime IP Address used for TCP and UDP connections +// */ +// let runtimeIP = '192.168.0.0'; + +// /** +// * Define message ID constants, which must match with Runtime +// */ +// enum MsgType { +// RUN_MODE = 0, +// START_POS = 1, +// LOG = 2, +// DEVICE_DATA = 3, +// // 4 reserved for some Shepherd msg type +// INPUTS = 5, +// TIME_STAMPS = 6 +// } + +// interface TCPPacket { +// type: MsgType; +// length: number; +// payload: Buffer; +// } + +// /** Given a data buffer, read as many TCP Packets as possible. +// * If there are leftover bytes, return them so that they can be used in the next cycle of data. +// */ +// function readPackets(data: Buffer, previousLeftoverBytes?: Buffer): { leftoverBytes?: Buffer; processedTCPPackets: TCPPacket[] } { +// const HEADER_NUM_BYTES = 3; + +// const bytesToRead = Buffer.concat([previousLeftoverBytes ?? new Uint8Array(), data]); +// const processedTCPPackets: TCPPacket[] = []; + +// let leftoverBytes; +// let currentPos = 0; + +// while (currentPos < bytesToRead.length) { +// let header: Buffer; +// let msgType: number; +// let msgLength: number; +// let payload: Buffer; + +// if (currentPos + HEADER_NUM_BYTES <= bytesToRead.length) { +// // Have enough bytes to read in 3 byte header +// header = bytesToRead.slice(currentPos, currentPos + HEADER_NUM_BYTES); +// msgType = header[0]; +// msgLength = (header[2] << 8) | header[1]; +// } else { +// // Don't have enough bytes to read 3 byte header so we save the bytes for the next data cycle +// leftoverBytes = bytesToRead.slice(currentPos); + +// return { +// leftoverBytes, +// processedTCPPackets +// }; +// } + +// currentPos += HEADER_NUM_BYTES; + +// if (currentPos + msgLength <= bytesToRead.length) { +// // Have enough bytes to read entire payload from 1 TCP packet +// payload = bytesToRead.slice(currentPos, currentPos + msgLength); +// } else { +// // Don't have enough bytes to read entire payload +// leftoverBytes = bytesToRead.slice(currentPos); + +// return { +// // Note: Need to save header so we know how many bytes to read for this packet in the next data cycle +// leftoverBytes: Buffer.concat([header, leftoverBytes]), +// processedTCPPackets +// }; +// } + +// const newTCPPacket = { type: msgType, length: msgLength, payload }; +// processedTCPPackets.push(newTCPPacket); + +// currentPos += msgLength; +// } + +// return { +// leftoverBytes, +// processedTCPPackets +// }; +// } + +// /** +// * Create TCP packet header and prepend to +// * payload to send to Runtime. +// */ +// function createPacket(payload: unknown, messageType: MsgType): Buffer { +// let encodedPayload: Uint8Array; + +// switch (messageType) { +// case MsgType.DEVICE_DATA: +// encodedPayload = protos.DevData.encode(payload as protos.IDevData).finish(); +// break; +// case MsgType.RUN_MODE: +// encodedPayload = protos.RunMode.encode(payload as protos.IRunMode).finish(); +// break; +// case MsgType.START_POS: +// encodedPayload = protos.StartPos.encode(payload as protos.IStartPos).finish(); +// break; +// case MsgType.TIME_STAMPS: +// encodedPayload = protos.TimeStamps.encode(payload as protos.ITimeStamps).finish(); +// break; +// case MsgType.INPUTS: +// // Special case for 2021 competition where Input data is sent over tunneled TCP connection +// encodedPayload = protos.UserInputs.encode({ inputs: payload as protos.Input[] }).finish(); +// break; +// default: +// console.log('ERROR: trying to create TCP Packet with unknown message type'); +// encodedPayload = new Uint8Array(); +// break; +// } + +// const msgLength = Buffer.byteLength(encodedPayload); +// const msgLengthArr = new Uint8Array([msgLength & 0x00ff, msgLength & 0xff00]); // Assuming little-endian byte order, since runs on x64 +// const msgTypeArr = new Uint8Array([messageType]); + +// return Buffer.concat([msgTypeArr, msgLengthArr, encodedPayload], msgLength + 3); +// } + +// class RuntimeConnection { +// logger: Logger; +// socket: WebSocket; +// leftoverBytes: Buffer | undefined; + +// constructor(logger: Logger) { +// this.logger = logger; +// this.socket = new TCPSocket(); + +// // Connect to most recent IP +// setInterval(() => { +// if (!this.socket.connecting && this.socket.pending) { +// if (runtimeIP !== defaults.IPADDRESS) { +// let port = DEFAULT_TCP_PORT; +// let ip = runtimeIP; +// if (runtimeIP.includes(':')) { +// const split = runtimeIP.split(':'); +// ip = split[0]; +// port = Number(split[1]); +// } +// console.log(`RuntimeConnection: Trying to TCP connect to ${ip}:${port}`); +// this.socket.connect(port, ip); +// } +// } +// }, 1000); + +// this.socket.on('connect', () => { +// this.logger.log('Runtime connected'); +// this.socket.write(new Uint8Array([1])); // Runtime needs first byte to be 1 to recognize client as Dawn (instead of Shepherd) +// }); + +// this.socket.on('end', () => { +// // RendererBridge.reduxDispatch(runtimeDisconnect()); +// this.logger.log('Runtime disconnected'); +// }); + +// this.socket.on('error', (err: string) => { +// this.logger.log(err); +// }); + +// /** +// * Runtime TCP Message Handler. +// * TODO: Distinguish between challenge outputs and console logs +// * when using payload to update console +// */ +// this.socket.on('data', (data) => { +// const { leftoverBytes, processedTCPPackets } = readPackets(data, this.leftoverBytes); + +// for (const packet of processedTCPPackets) { +// let decoded; + +// switch (packet.type) { +// case MsgType.LOG: +// decoded = protos.Text.decode(packet.payload); +// RendererBridge.reduxDispatch(updateConsole(decoded.payload)); +// break; + +// case MsgType.TIME_STAMPS: +// decoded = protos.TimeStamps.decode(packet.payload); +// const oneWayLatency = (Date.now() - Number(decoded.dawnTimestamp)) / 2; + +// // TODO: we can probably do an average of n timestamps so the display doesn't change too frequently +// RendererBridge.reduxDispatch(setLatencyValue(oneWayLatency)); +// break; + +// case MsgType.DEVICE_DATA: +// try { +// RendererBridge.reduxDispatch(infoPerMessage()); +// const sensorData: protos.Device[] = protos.DevData.decode(packet.payload).devices; +// const peripherals: Peripheral[] = []; +// sensorData.forEach((device) => { +// if (device.type.toString() === '0') { +// device.type = 0; +// } +// peripherals.push({ ...device, uid: device.uid.toString() }); +// }); +// RendererBridge.reduxDispatch(updatePeripherals(peripherals)); +// } catch (err) { +// this.logger.log(err); +// } +// break; + +// default: +// this.logger.log(`Unsupported received message type: ${packet.type}`) +// } +// } + +// this.leftoverBytes = leftoverBytes; +// }); + +// /** +// * TCP Socket IPC Connections +// */ +// ipcMain.on('runModeUpdate', (event: IpcMainEvent, ...args: any[]) => this.whenConnectionEstablished(this.sendRunMode, event, ...args)); +// ipcMain.on('initiateLatencyCheck', (event: IpcMainEvent, ...args: any[]) => +// this.whenConnectionEstablished(this.initiateLatencyCheck, event, ...args) +// ); +// ipcMain.on('stateUpdate', (event: IpcMainEvent, ...args: any[]) => this.whenConnectionEstablished(this.sendInputs, event, ...args)); + +// ipcMain.on('ipAddress', this.ipAddressListener); +// } + +// whenConnectionEstablished = (cb: (event: IpcMainEvent, ...args: any[]) => void, event: IpcMainEvent, ...args: any[]) => { +// if (this.socket.pending) { +// return; +// } + +// return cb(event, ...args); +// }; + +// /** +// * Initiates latency check by sending first packet to Runtime +// */ +// initiateLatencyCheck = (_event: IpcMainEvent, data: protos.ITimeStamps) => { +// const message = createPacket(data, MsgType.TIME_STAMPS); +// this.socket.write(message, () => { +// this.logger.log(`Sent timestamp data to runtime: ${JSON.stringify(data)}`); +// }); +// }; + +// /** +// * IPC Connection with ConfigBox.ts' saveChanges() +// * Receives new IP Address to send messages to. +// */ +// ipAddressListener = (_event: IpcMainEvent, ipAddress: string) => { +// if (ipAddress != runtimeIP) { +// console.log(`RuntimeConnection - Switching IP from ${runtimeIP} to ${ipAddress}`); +// if (this.socket.connecting || !this.socket.pending) { +// this.socket.end(); +// } +// runtimeIP = ipAddress; +// } +// }; + +// // TODO: We can possibly combine below methods into single handler. + +// /** +// * IPC Connection with sagas.js' exportRunMode() +// * Receives new run mode to send to Runtime +// */ +// sendRunMode = (_event: IpcMainEvent, runModeData: protos.IRunMode) => { +// const message = createPacket(runModeData, MsgType.RUN_MODE); +// this.socket.write(message, () => { +// this.logger.log(`Run Mode message sent: ${JSON.stringify(runModeData)}`); +// }); +// }; + +// sendDevicePreferences = (_event: IpcMainEvent, deviceData: protos.IDevData) => { +// // TODO: Serialize uid from string -> Long type +// const message = createPacket(deviceData, MsgType.DEVICE_DATA); +// this.socket.write(message, () => { +// this.logger.log(`Device preferences sent: ${deviceData.toString()}`); +// }); +// }; + +// sendRobotStartPos = (_event: IpcMainEvent, startPosData: protos.IStartPos) => { +// // TODO: Get start pos from sagas +// const message = createPacket(startPosData, MsgType.START_POS); +// this.socket.write(message, () => { +// this.logger.log(`Start position sent: ${startPosData.toString()}`); +// }); +// }; + +// sendInputs = (_event: IpcMainEvent, data: protos.Input[], source: protos.Source) => { +// if (data.length === 0) { +// data.push( +// protos.Input.create({ +// connected: false, +// source +// }) +// ); +// } +// const message = createPacket(data, MsgType.INPUTS); +// this.socket.write(message, () => { +// this.logger.log(`Inputs sent: ${JSON.stringify(data)}`); +// }); +// }; + +// close = () => { +// this.socket.end(); +// }; +// } + +// const RuntimeConnections: Array = []; + +// export const Runtime = { +// conns: RuntimeConnections, +// logger: new Logger('RuntimeConnection'), + +// setup() { +// this.conns = [new RuntimeConnection(this.logger)]; +// }, + +// close() { +// this.conns.forEach((conn) => conn.close()); // Logger's fs closes automatically +// } +// }; From c63a8b280cfe07d68ae5a4ed1cae70985b6e9209 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 2 Oct 2021 13:45:34 -0700 Subject: [PATCH 03/10] Add websocket event listeners --- src/App.tsx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/App.tsx b/src/App.tsx index 83b2d12..8124cb3 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -10,15 +10,15 @@ export const App = () => { socket.on('connect', () => console.log('socket connected')); // console.log('ready state', ws.readyState); - // ws.addEventListener('close', (ev: Event) => console.log('Connection closed', ev)); + ws.addEventListener('close', (ev: Event) => console.log('Connection closed', ev)); - // ws.addEventListener('open', (ev: Event) => console.log('web socket open', ev)); + ws.addEventListener('open', (ev: Event) => console.log('web socket open', ev)); - // ws.addEventListener('message', (message: Event) => { - // console.log('received: %s', message); - // }); + ws.addEventListener('message', (message: MessageEvent) => { + console.log('received data: %s', message.data); + }); - // ws.addEventListener('error', (ev: Event) => console.log('error', ev)) + ws.addEventListener('error', (ev: Event) => console.log('error', ev)); return (
From 0d71ef36f6d31c9115f12879be27c7de6b96836d Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 2 Oct 2021 15:48:00 -0700 Subject: [PATCH 04/10] Remove socket.io-client dependency --- package.json | 1 - yarn.lock | 99 +--------------------------------------------------- 2 files changed, 1 insertion(+), 99 deletions(-) diff --git a/package.json b/package.json index 124a061..d751864 100644 --- a/package.json +++ b/package.json @@ -14,7 +14,6 @@ "react": "^17.0.2", "react-dom": "^17.0.2", "react-scripts": "4.0.3", - "socket.io-client": "^4.2.0", "typescript": "^4.1.2", "web-vitals": "^1.0.1", "ws": "^8.2.2" diff --git a/yarn.lock b/yarn.lock index 066b10c..b24d946 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1741,11 +1741,6 @@ dependencies: "@babel/types" "^7.3.0" -"@types/component-emitter@^1.2.10": - version "1.2.10" - resolved "https://registry.yarnpkg.com/@types/component-emitter/-/component-emitter-1.2.10.tgz#ef5b1589b9f16544642e473db5ea5639107ef3ea" - integrity sha512-bsjleuRKWmGqajMerkzox19aGbscQX5rmmvvXl3wlIp5gMG1HgkiwPxsN5p070fBDKTNSPgojVbuY1+HWMbFhg== - "@types/eslint@^7.2.6": version "7.2.6" resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-7.2.6.tgz#5e9aff555a975596c03a98b59ecd103decc70c3c" @@ -2793,21 +2788,11 @@ babylon@^6.18.0: resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3" integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ== -backo2@~1.0.2: - version "1.0.2" - resolved "https://registry.yarnpkg.com/backo2/-/backo2-1.0.2.tgz#31ab1ac8b129363463e35b3ebb69f4dfcfba7947" - integrity sha1-MasayLEpNjRj41s+u2n038+6eUc= - balanced-match@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767" integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c= -base64-arraybuffer@0.1.4: - version "0.1.4" - resolved "https://registry.yarnpkg.com/base64-arraybuffer/-/base64-arraybuffer-0.1.4.tgz#9818c79e059b1355f97e0428a017c838e90ba812" - integrity sha1-mBjHngWbE1X5fgQooBfIOOkLqBI= - base64-js@^1.0.2: version "1.5.1" resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" @@ -3484,7 +3469,7 @@ commondir@^1.0.1: resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b" integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs= -component-emitter@^1.2.1, component-emitter@~1.3.0: +component-emitter@^1.2.1: version "1.3.0" resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0" integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg== @@ -4020,13 +4005,6 @@ debug@^4.0.1, debug@^4.1.0, debug@^4.1.1: dependencies: ms "2.1.2" -debug@~4.3.1, debug@~4.3.2: - version "4.3.2" - resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.2.tgz#f0a49c18ac8779e31d4a0c6029dfb76873c7428b" - integrity sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw== - dependencies: - ms "2.1.2" - decamelize@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" @@ -4403,29 +4381,6 @@ end-of-stream@^1.0.0, end-of-stream@^1.1.0: dependencies: once "^1.4.0" -engine.io-client@~5.2.0: - version "5.2.0" - resolved "https://registry.yarnpkg.com/engine.io-client/-/engine.io-client-5.2.0.tgz#ae38c79a4af16258c0300e6819c0ea8ecc1597cd" - integrity sha512-BcIBXGBkT7wKecwnfrSV79G2X5lSUSgeAGgoo60plXf8UsQEvCQww/KMwXSMhVjb98fFYNq20CC5eo8IOAPqsg== - dependencies: - base64-arraybuffer "0.1.4" - component-emitter "~1.3.0" - debug "~4.3.1" - engine.io-parser "~4.0.1" - has-cors "1.1.0" - parseqs "0.0.6" - parseuri "0.0.6" - ws "~7.4.2" - xmlhttprequest-ssl "~2.0.0" - yeast "0.1.2" - -engine.io-parser@~4.0.1: - version "4.0.3" - resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-4.0.3.tgz#83d3a17acfd4226f19e721bb22a1ee8f7662d2f6" - integrity sha512-xEAAY0msNnESNPc00e19y5heTPX4y/TJ36gr8t1voOaNmTojP9b3oK3BbJLFufW2XFPQaaijpFewm2g2Um3uqA== - dependencies: - base64-arraybuffer "0.1.4" - enhanced-resolve@^4.3.0: version "4.5.0" resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec" @@ -5495,11 +5450,6 @@ harmony-reflect@^1.4.6: resolved "https://registry.yarnpkg.com/harmony-reflect/-/harmony-reflect-1.6.1.tgz#c108d4f2bb451efef7a37861fdbdae72c9bdefa9" integrity sha512-WJTeyp0JzGtHcuMsi7rw2VwtkvLa+JyfEKJCFyfcS0+CDkjQ5lHPu7zEhFZP+PDSRrEgXa5Ah0l1MbgbE41XjA== -has-cors@1.1.0: - version "1.1.0" - resolved "https://registry.yarnpkg.com/has-cors/-/has-cors-1.1.0.tgz#5e474793f7ea9843d1bb99c23eef49ff126fff39" - integrity sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk= - has-flag@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" @@ -8022,16 +7972,6 @@ parse5@5.1.1: resolved "https://registry.yarnpkg.com/parse5/-/parse5-5.1.1.tgz#f68e4e5ba1852ac2cadc00f4555fff6c2abb6178" integrity sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug== -parseqs@0.0.6: - version "0.0.6" - resolved "https://registry.yarnpkg.com/parseqs/-/parseqs-0.0.6.tgz#8e4bb5a19d1cdc844a08ac974d34e273afa670d5" - integrity sha512-jeAGzMDbfSHHA091hr0r31eYfTig+29g3GKKE/PPbEQ65X0lmMwlEoqmhzu0iztID5uJpZsFlUPDP8ThPL7M8w== - -parseuri@0.0.6: - version "0.0.6" - resolved "https://registry.yarnpkg.com/parseuri/-/parseuri-0.0.6.tgz#e1496e829e3ac2ff47f39a4dd044b32823c4a25a" - integrity sha512-AUjen8sAkGgao7UyCX6Ahv0gIK2fABKmYjvP4xmy5JaKvcbTRueIqIPHLAfq30xJddqSE033IOMUSOMCcK3Sow== - parseurl@~1.3.2, parseurl@~1.3.3: version "1.3.3" resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4" @@ -10071,28 +10011,6 @@ snapdragon@^0.8.1: source-map-resolve "^0.5.0" use "^3.1.0" -socket.io-client@^4.2.0: - version "4.2.0" - resolved "https://registry.yarnpkg.com/socket.io-client/-/socket.io-client-4.2.0.tgz#195feed3de40283b1ae3f7d02cf91d3eb2c905c1" - integrity sha512-3GJ2KMh7inJUNAOjgf8NaKJZJa9uRyfryh2LrVJyKyxmzoXlfW9DeDNqylJn0ovOFt4e/kRLNWzMt/YqqEWYSA== - dependencies: - "@types/component-emitter" "^1.2.10" - backo2 "~1.0.2" - component-emitter "~1.3.0" - debug "~4.3.2" - engine.io-client "~5.2.0" - parseuri "0.0.6" - socket.io-parser "~4.0.4" - -socket.io-parser@~4.0.4: - version "4.0.4" - resolved "https://registry.yarnpkg.com/socket.io-parser/-/socket.io-parser-4.0.4.tgz#9ea21b0d61508d18196ef04a2c6b9ab630f4c2b0" - integrity sha512-t+b0SS+IxG7Rxzda2EVvyBZbvFPBCjJoyHuE0P//7OAsN23GItzDRdWa6ALxZI/8R5ygK7jAR6t028/z+7295g== - dependencies: - "@types/component-emitter" "^1.2.10" - component-emitter "~1.3.0" - debug "~4.3.1" - sockjs-client@^1.5.0: version "1.5.0" resolved "https://registry.yarnpkg.com/sockjs-client/-/sockjs-client-1.5.0.tgz#2f8ff5d4b659e0d092f7aba0b7c386bd2aa20add" @@ -11593,11 +11511,6 @@ ws@^8.2.2: resolved "https://registry.yarnpkg.com/ws/-/ws-8.2.2.tgz#ca684330c6dd6076a737250ed81ac1606cb0a63e" integrity sha512-Q6B6H2oc8QY3llc3cB8kVmQ6pnJWVQbP7Q5algTcIxx7YEpc0oU4NBVHlztA7Ekzfhw2r0rPducMUiCGWKQRzw== -ws@~7.4.2: - version "7.4.6" - resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.6.tgz#5654ca8ecdeee47c33a9a4bf6d28e2be2980377c" - integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A== - xml-name-validator@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-3.0.0.tgz#6ae73e06de4d8c6e47f9fb181f78d648ad457c6a" @@ -11608,11 +11521,6 @@ xmlchars@^2.2.0: resolved "https://registry.yarnpkg.com/xmlchars/-/xmlchars-2.2.0.tgz#060fe1bcb7f9c76fe2a17db86a9bc3ab894210cb" integrity sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw== -xmlhttprequest-ssl@~2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/xmlhttprequest-ssl/-/xmlhttprequest-ssl-2.0.0.tgz#91360c86b914e67f44dce769180027c0da618c67" - integrity sha512-QKxVRxiRACQcVuQEYFsI1hhkrMlrXHPegbbd1yn9UHOmRxY+si12nQYzri3vbzt8VdTTRviqcKxcyllFas5z2A== - xtend@^4.0.0, xtend@~4.0.1: version "4.0.2" resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54" @@ -11687,11 +11595,6 @@ yargs@^15.4.1: y18n "^4.0.0" yargs-parser "^18.1.2" -yeast@0.1.2: - version "0.1.2" - resolved "https://registry.yarnpkg.com/yeast/-/yeast-0.1.2.tgz#008e06d8094320c372dbc2f8ed76a0ca6c8ac419" - integrity sha1-AI4G2AlDIMNy28L47XagymyKxBk= - yocto-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" From 6685e0ebf8d6dc75c42bec5c474a2c26eb2c6784 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 2 Oct 2021 15:50:17 -0700 Subject: [PATCH 05/10] Remove ws dependency --- package.json | 3 +-- yarn.lock | 5 ----- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/package.json b/package.json index d751864..ad00ad2 100644 --- a/package.json +++ b/package.json @@ -15,8 +15,7 @@ "react-dom": "^17.0.2", "react-scripts": "4.0.3", "typescript": "^4.1.2", - "web-vitals": "^1.0.1", - "ws": "^8.2.2" + "web-vitals": "^1.0.1" }, "scripts": { "start": "react-scripts start", diff --git a/yarn.lock b/yarn.lock index b24d946..abb6c56 100644 --- a/yarn.lock +++ b/yarn.lock @@ -11506,11 +11506,6 @@ ws@^7.2.3: resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.3.tgz#1f9643de34a543b8edb124bdcbc457ae55a6e5cd" integrity sha512-hr6vCR76GsossIRsr8OLR9acVVm1jyfEWvhbNjtgPOrfvAlKzvyeg/P6r8RuDjRyrcQoPQT7K0DGEPc7Ae6jzA== -ws@^8.2.2: - version "8.2.2" - resolved "https://registry.yarnpkg.com/ws/-/ws-8.2.2.tgz#ca684330c6dd6076a737250ed81ac1606cb0a63e" - integrity sha512-Q6B6H2oc8QY3llc3cB8kVmQ6pnJWVQbP7Q5algTcIxx7YEpc0oU4NBVHlztA7Ekzfhw2r0rPducMUiCGWKQRzw== - xml-name-validator@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-3.0.0.tgz#6ae73e06de4d8c6e47f9fb181f78d648ad457c6a" From 67f170a200126e7e1956afabfa06619d2dac122f Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 9 Oct 2021 13:42:37 -0700 Subject: [PATCH 06/10] Add protos submodule --- .gitmodules | 3 + src/main-protos/protos | 1 + src/main-protos/protos.d.ts | 1111 ++++++++++++++ src/main-protos/protos.js | 2753 +++++++++++++++++++++++++++++++++++ 4 files changed, 3868 insertions(+) create mode 100644 .gitmodules create mode 160000 src/main-protos/protos create mode 100644 src/main-protos/protos.d.ts create mode 100644 src/main-protos/protos.js diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..5cafdc7 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "src/main-protos/protos"] + path = src/main-protos/protos + url = https://github.com/pioneers/protos.git diff --git a/src/main-protos/protos b/src/main-protos/protos new file mode 160000 index 0000000..9e52c0e --- /dev/null +++ b/src/main-protos/protos @@ -0,0 +1 @@ +Subproject commit 9e52c0e5cd7ff7b83811145dfc93dbd5ea168f84 diff --git a/src/main-protos/protos.d.ts b/src/main-protos/protos.d.ts new file mode 100644 index 0000000..66a5cc0 --- /dev/null +++ b/src/main-protos/protos.d.ts @@ -0,0 +1,1111 @@ +import * as $protobuf from "protobufjs"; +/** Properties of a Param. */ +export interface IParam { + + /** Param name */ + name?: (string|null); + + /** Param fval */ + fval?: (number|null); + + /** Param ival */ + ival?: (number|null); + + /** Param bval */ + bval?: (boolean|null); + + /** Param readonly */ + readonly?: (boolean|null); +} + +/** Represents a Param. */ +export class Param implements IParam { + + /** + * Constructs a new Param. + * @param [properties] Properties to set + */ + constructor(properties?: IParam); + + /** Param name. */ + public name: string; + + /** Param fval. */ + public fval: number; + + /** Param ival. */ + public ival: number; + + /** Param bval. */ + public bval: boolean; + + /** Param readonly. */ + public readonly: boolean; + + /** Param val. */ + public val?: ("fval"|"ival"|"bval"); + + /** + * Creates a new Param instance using the specified properties. + * @param [properties] Properties to set + * @returns Param instance + */ + public static create(properties?: IParam): Param; + + /** + * Encodes the specified Param message. Does not implicitly {@link Param.verify|verify} messages. + * @param message Param message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: Param, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Param message, length delimited. Does not implicitly {@link Param.verify|verify} messages. + * @param message Param message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: Param, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Param message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Param; + + /** + * Decodes a Param message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Param; + + /** + * Verifies a Param message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Param message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Param + */ + public static fromObject(object: { [k: string]: any }): Param; + + /** + * Creates a plain object from a Param message. Also converts values to other types if specified. + * @param message Param + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Param, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Param to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a Device. */ +export interface IDevice { + + /** Device name */ + name?: (string|null); + + /** Device uid */ + uid?: (number|Long|null); + + /** Device type */ + type?: (number|null); + + /** Device params */ + params?: (Param[]|null); +} + +/** Represents a Device. */ +export class Device implements IDevice { + + /** + * Constructs a new Device. + * @param [properties] Properties to set + */ + constructor(properties?: IDevice); + + /** Device name. */ + public name: string; + + /** Device uid. */ + public uid: (number|Long); + + /** Device type. */ + public type: number; + + /** Device params. */ + public params: Param[]; + + /** + * Creates a new Device instance using the specified properties. + * @param [properties] Properties to set + * @returns Device instance + */ + public static create(properties?: IDevice): Device; + + /** + * Encodes the specified Device message. Does not implicitly {@link Device.verify|verify} messages. + * @param message Device message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: Device, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Device message, length delimited. Does not implicitly {@link Device.verify|verify} messages. + * @param message Device message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: Device, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Device message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Device; + + /** + * Decodes a Device message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Device; + + /** + * Verifies a Device message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Device message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Device + */ + public static fromObject(object: { [k: string]: any }): Device; + + /** + * Creates a plain object from a Device message. Also converts values to other types if specified. + * @param message Device + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Device, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Device to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a DevData. */ +export interface IDevData { + + /** DevData devices */ + devices?: (Device[]|null); +} + +/** Represents a DevData. */ +export class DevData implements IDevData { + + /** + * Constructs a new DevData. + * @param [properties] Properties to set + */ + constructor(properties?: IDevData); + + /** DevData devices. */ + public devices: Device[]; + + /** + * Creates a new DevData instance using the specified properties. + * @param [properties] Properties to set + * @returns DevData instance + */ + public static create(properties?: IDevData): DevData; + + /** + * Encodes the specified DevData message. Does not implicitly {@link DevData.verify|verify} messages. + * @param message DevData message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: DevData, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified DevData message, length delimited. Does not implicitly {@link DevData.verify|verify} messages. + * @param message DevData message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: DevData, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DevData message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DevData; + + /** + * Decodes a DevData message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DevData; + + /** + * Verifies a DevData message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a DevData message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns DevData + */ + public static fromObject(object: { [k: string]: any }): DevData; + + /** + * Creates a plain object from a DevData message. Also converts values to other types if specified. + * @param message DevData + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: DevData, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this DevData to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** State enum. */ +export enum State { + POISON_IVY = 0, + DEHYDRATION = 1, + HYPOTHERMIA_START = 2, + HYPOTHERMIA_END = 3 +} + +/** Properties of a GameState. */ +export interface IGameState { + + /** GameState state */ + state?: (State|null); +} + +/** Represents a GameState. */ +export class GameState implements IGameState { + + /** + * Constructs a new GameState. + * @param [properties] Properties to set + */ + constructor(properties?: IGameState); + + /** GameState state. */ + public state: State; + + /** + * Creates a new GameState instance using the specified properties. + * @param [properties] Properties to set + * @returns GameState instance + */ + public static create(properties?: IGameState): GameState; + + /** + * Encodes the specified GameState message. Does not implicitly {@link GameState.verify|verify} messages. + * @param message GameState message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: GameState, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified GameState message, length delimited. Does not implicitly {@link GameState.verify|verify} messages. + * @param message GameState message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: GameState, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a GameState message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns GameState + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): GameState; + + /** + * Decodes a GameState message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns GameState + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): GameState; + + /** + * Verifies a GameState message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a GameState message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns GameState + */ + public static fromObject(object: { [k: string]: any }): GameState; + + /** + * Creates a plain object from a GameState message. Also converts values to other types if specified. + * @param message GameState + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: GameState, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this GameState to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Source enum. */ +export enum Source { + GAMEPAD = 0, + KEYBOARD = 1 +} + +/** Properties of an Input. */ +export interface IInput { + + /** Input connected */ + connected?: (boolean|null); + + /** Input buttons */ + buttons?: (number|Long|null); + + /** Input axes */ + axes?: (number[]|null); + + /** Input source */ + source?: (Source|null); +} + +/** Represents an Input. */ +export class Input implements IInput { + + /** + * Constructs a new Input. + * @param [properties] Properties to set + */ + constructor(properties?: IInput); + + /** Input connected. */ + public connected: boolean; + + /** Input buttons. */ + public buttons: (number|Long); + + /** Input axes. */ + public axes: number[]; + + /** Input source. */ + public source: Source; + + /** + * Creates a new Input instance using the specified properties. + * @param [properties] Properties to set + * @returns Input instance + */ + public static create(properties?: IInput): Input; + + /** + * Encodes the specified Input message. Does not implicitly {@link Input.verify|verify} messages. + * @param message Input message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: Input, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Input message, length delimited. Does not implicitly {@link Input.verify|verify} messages. + * @param message Input message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: Input, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an Input message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Input; + + /** + * Decodes an Input message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Input; + + /** + * Verifies an Input message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates an Input message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Input + */ + public static fromObject(object: { [k: string]: any }): Input; + + /** + * Creates a plain object from an Input message. Also converts values to other types if specified. + * @param message Input + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Input, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Input to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a UserInputs. */ +export interface IUserInputs { + + /** UserInputs inputs */ + inputs?: (Input[]|null); +} + +/** Represents a UserInputs. */ +export class UserInputs implements IUserInputs { + + /** + * Constructs a new UserInputs. + * @param [properties] Properties to set + */ + constructor(properties?: IUserInputs); + + /** UserInputs inputs. */ + public inputs: Input[]; + + /** + * Creates a new UserInputs instance using the specified properties. + * @param [properties] Properties to set + * @returns UserInputs instance + */ + public static create(properties?: IUserInputs): UserInputs; + + /** + * Encodes the specified UserInputs message. Does not implicitly {@link UserInputs.verify|verify} messages. + * @param message UserInputs message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: UserInputs, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified UserInputs message, length delimited. Does not implicitly {@link UserInputs.verify|verify} messages. + * @param message UserInputs message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: UserInputs, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a UserInputs message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UserInputs; + + /** + * Decodes a UserInputs message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UserInputs; + + /** + * Verifies a UserInputs message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a UserInputs message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns UserInputs + */ + public static fromObject(object: { [k: string]: any }): UserInputs; + + /** + * Creates a plain object from a UserInputs message. Also converts values to other types if specified. + * @param message UserInputs + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: UserInputs, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this UserInputs to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Mode enum. */ +export enum Mode { + IDLE = 0, + AUTO = 1, + TELEOP = 2, + ESTOP = 3 +} + +/** Properties of a RunMode. */ +export interface IRunMode { + + /** RunMode mode */ + mode?: (Mode|null); +} + +/** Represents a RunMode. */ +export class RunMode implements IRunMode { + + /** + * Constructs a new RunMode. + * @param [properties] Properties to set + */ + constructor(properties?: IRunMode); + + /** RunMode mode. */ + public mode: Mode; + + /** + * Creates a new RunMode instance using the specified properties. + * @param [properties] Properties to set + * @returns RunMode instance + */ + public static create(properties?: IRunMode): RunMode; + + /** + * Encodes the specified RunMode message. Does not implicitly {@link RunMode.verify|verify} messages. + * @param message RunMode message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: RunMode, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified RunMode message, length delimited. Does not implicitly {@link RunMode.verify|verify} messages. + * @param message RunMode message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: RunMode, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a RunMode message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): RunMode; + + /** + * Decodes a RunMode message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): RunMode; + + /** + * Verifies a RunMode message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a RunMode message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns RunMode + */ + public static fromObject(object: { [k: string]: any }): RunMode; + + /** + * Creates a plain object from a RunMode message. Also converts values to other types if specified. + * @param message RunMode + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: RunMode, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this RunMode to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a RuntimeStatus. */ +export interface IRuntimeStatus { + + /** RuntimeStatus shepConnected */ + shepConnected?: (boolean|null); + + /** RuntimeStatus dawnConnected */ + dawnConnected?: (boolean|null); + + /** RuntimeStatus mode */ + mode?: (Mode|null); + + /** RuntimeStatus battery */ + battery?: (number|null); + + /** RuntimeStatus version */ + version?: (string|null); +} + +/** Represents a RuntimeStatus. */ +export class RuntimeStatus implements IRuntimeStatus { + + /** + * Constructs a new RuntimeStatus. + * @param [properties] Properties to set + */ + constructor(properties?: IRuntimeStatus); + + /** RuntimeStatus shepConnected. */ + public shepConnected: boolean; + + /** RuntimeStatus dawnConnected. */ + public dawnConnected: boolean; + + /** RuntimeStatus mode. */ + public mode: Mode; + + /** RuntimeStatus battery. */ + public battery: number; + + /** RuntimeStatus version. */ + public version: string; + + /** + * Creates a new RuntimeStatus instance using the specified properties. + * @param [properties] Properties to set + * @returns RuntimeStatus instance + */ + public static create(properties?: IRuntimeStatus): RuntimeStatus; + + /** + * Encodes the specified RuntimeStatus message. Does not implicitly {@link RuntimeStatus.verify|verify} messages. + * @param message RuntimeStatus message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: RuntimeStatus, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified RuntimeStatus message, length delimited. Does not implicitly {@link RuntimeStatus.verify|verify} messages. + * @param message RuntimeStatus message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: RuntimeStatus, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a RuntimeStatus message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns RuntimeStatus + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): RuntimeStatus; + + /** + * Decodes a RuntimeStatus message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns RuntimeStatus + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): RuntimeStatus; + + /** + * Verifies a RuntimeStatus message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a RuntimeStatus message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns RuntimeStatus + */ + public static fromObject(object: { [k: string]: any }): RuntimeStatus; + + /** + * Creates a plain object from a RuntimeStatus message. Also converts values to other types if specified. + * @param message RuntimeStatus + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: RuntimeStatus, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this RuntimeStatus to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Pos enum. */ +export enum Pos { + LEFT = 0, + RIGHT = 1 +} + +/** Properties of a StartPos. */ +export interface IStartPos { + + /** StartPos pos */ + pos?: (Pos|null); +} + +/** Represents a StartPos. */ +export class StartPos implements IStartPos { + + /** + * Constructs a new StartPos. + * @param [properties] Properties to set + */ + constructor(properties?: IStartPos); + + /** StartPos pos. */ + public pos: Pos; + + /** + * Creates a new StartPos instance using the specified properties. + * @param [properties] Properties to set + * @returns StartPos instance + */ + public static create(properties?: IStartPos): StartPos; + + /** + * Encodes the specified StartPos message. Does not implicitly {@link StartPos.verify|verify} messages. + * @param message StartPos message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: StartPos, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified StartPos message, length delimited. Does not implicitly {@link StartPos.verify|verify} messages. + * @param message StartPos message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: StartPos, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a StartPos message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): StartPos; + + /** + * Decodes a StartPos message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): StartPos; + + /** + * Verifies a StartPos message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a StartPos message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns StartPos + */ + public static fromObject(object: { [k: string]: any }): StartPos; + + /** + * Creates a plain object from a StartPos message. Also converts values to other types if specified. + * @param message StartPos + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: StartPos, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this StartPos to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a Text. */ +export interface IText { + + /** Text payload */ + payload?: (string[]|null); +} + +/** Represents a Text. */ +export class Text implements IText { + + /** + * Constructs a new Text. + * @param [properties] Properties to set + */ + constructor(properties?: IText); + + /** Text payload. */ + public payload: string[]; + + /** + * Creates a new Text instance using the specified properties. + * @param [properties] Properties to set + * @returns Text instance + */ + public static create(properties?: IText): Text; + + /** + * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages. + * @param message Text message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: Text, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages. + * @param message Text message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: Text, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Text message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Text; + + /** + * Decodes a Text message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Text; + + /** + * Verifies a Text message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Text message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Text + */ + public static fromObject(object: { [k: string]: any }): Text; + + /** + * Creates a plain object from a Text message. Also converts values to other types if specified. + * @param message Text + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Text, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Text to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of a TimeStamps. */ +export interface ITimeStamps { + + /** TimeStamps dawnTimestamp */ + dawnTimestamp?: (number|Long|null); + + /** TimeStamps runtimeTimestamp */ + runtimeTimestamp?: (number|Long|null); +} + +/** Represents a TimeStamps. */ +export class TimeStamps implements ITimeStamps { + + /** + * Constructs a new TimeStamps. + * @param [properties] Properties to set + */ + constructor(properties?: ITimeStamps); + + /** TimeStamps dawnTimestamp. */ + public dawnTimestamp: (number|Long); + + /** TimeStamps runtimeTimestamp. */ + public runtimeTimestamp: (number|Long); + + /** + * Creates a new TimeStamps instance using the specified properties. + * @param [properties] Properties to set + * @returns TimeStamps instance + */ + public static create(properties?: ITimeStamps): TimeStamps; + + /** + * Encodes the specified TimeStamps message. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @param message TimeStamps message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: TimeStamps, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified TimeStamps message, length delimited. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @param message TimeStamps message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: TimeStamps, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a TimeStamps message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TimeStamps; + + /** + * Decodes a TimeStamps message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TimeStamps; + + /** + * Verifies a TimeStamps message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a TimeStamps message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns TimeStamps + */ + public static fromObject(object: { [k: string]: any }): TimeStamps; + + /** + * Creates a plain object from a TimeStamps message. Also converts values to other types if specified. + * @param message TimeStamps + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: TimeStamps, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this TimeStamps to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} diff --git a/src/main-protos/protos.js b/src/main-protos/protos.js new file mode 100644 index 0000000..c06167a --- /dev/null +++ b/src/main-protos/protos.js @@ -0,0 +1,2753 @@ +/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ +import * as $protobuf from "protobufjs/minimal"; + +// Common aliases +const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; + +// Exported root namespace +const $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + +export const Param = $root.Param = (() => { + + /** + * Properties of a Param. + * @exports IParam + * @interface IParam + * @property {string|null} [name] Param name + * @property {number|null} [fval] Param fval + * @property {number|null} [ival] Param ival + * @property {boolean|null} [bval] Param bval + * @property {boolean|null} [readonly] Param readonly + */ + + /** + * Constructs a new Param. + * @exports Param + * @classdesc Represents a Param. + * @implements IParam + * @constructor + * @param {IParam=} [properties] Properties to set + */ + function Param(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Param name. + * @member {string} name + * @memberof Param + * @instance + */ + Param.prototype.name = ""; + + /** + * Param fval. + * @member {number} fval + * @memberof Param + * @instance + */ + Param.prototype.fval = 0; + + /** + * Param ival. + * @member {number} ival + * @memberof Param + * @instance + */ + Param.prototype.ival = 0; + + /** + * Param bval. + * @member {boolean} bval + * @memberof Param + * @instance + */ + Param.prototype.bval = false; + + /** + * Param readonly. + * @member {boolean} readonly + * @memberof Param + * @instance + */ + Param.prototype.readonly = false; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * Param val. + * @member {"fval"|"ival"|"bval"|undefined} val + * @memberof Param + * @instance + */ + Object.defineProperty(Param.prototype, "val", { + get: $util.oneOfGetter($oneOfFields = ["fval", "ival", "bval"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Creates a new Param instance using the specified properties. + * @function create + * @memberof Param + * @static + * @param {IParam=} [properties] Properties to set + * @returns {Param} Param instance + */ + Param.create = function create(properties) { + return new Param(properties); + }; + + /** + * Encodes the specified Param message. Does not implicitly {@link Param.verify|verify} messages. + * @function encode + * @memberof Param + * @static + * @param {Param} message Param message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Param.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.name != null && Object.hasOwnProperty.call(message, "name")) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); + if (message.fval != null && Object.hasOwnProperty.call(message, "fval")) + writer.uint32(/* id 2, wireType 5 =*/21).float(message.fval); + if (message.ival != null && Object.hasOwnProperty.call(message, "ival")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.ival); + if (message.bval != null && Object.hasOwnProperty.call(message, "bval")) + writer.uint32(/* id 4, wireType 0 =*/32).bool(message.bval); + if (message.readonly != null && Object.hasOwnProperty.call(message, "readonly")) + writer.uint32(/* id 5, wireType 0 =*/40).bool(message.readonly); + return writer; + }; + + /** + * Encodes the specified Param message, length delimited. Does not implicitly {@link Param.verify|verify} messages. + * @function encodeDelimited + * @memberof Param + * @static + * @param {Param} message Param message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Param.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Param message from the specified reader or buffer. + * @function decode + * @memberof Param + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Param} Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Param.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Param(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.fval = reader.float(); + break; + case 3: + message.ival = reader.int32(); + break; + case 4: + message.bval = reader.bool(); + break; + case 5: + message.readonly = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Param message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Param + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Param} Param + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Param.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Param message. + * @function verify + * @memberof Param + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Param.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + let properties = {}; + if (message.name != null && message.hasOwnProperty("name")) + if (!$util.isString(message.name)) + return "name: string expected"; + if (message.fval != null && message.hasOwnProperty("fval")) { + properties.val = 1; + if (typeof message.fval !== "number") + return "fval: number expected"; + } + if (message.ival != null && message.hasOwnProperty("ival")) { + if (properties.val === 1) + return "val: multiple values"; + properties.val = 1; + if (!$util.isInteger(message.ival)) + return "ival: integer expected"; + } + if (message.bval != null && message.hasOwnProperty("bval")) { + if (properties.val === 1) + return "val: multiple values"; + properties.val = 1; + if (typeof message.bval !== "boolean") + return "bval: boolean expected"; + } + if (message.readonly != null && message.hasOwnProperty("readonly")) + if (typeof message.readonly !== "boolean") + return "readonly: boolean expected"; + return null; + }; + + /** + * Creates a Param message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Param + * @static + * @param {Object.} object Plain object + * @returns {Param} Param + */ + Param.fromObject = function fromObject(object) { + if (object instanceof $root.Param) + return object; + let message = new $root.Param(); + if (object.name != null) + message.name = String(object.name); + if (object.fval != null) + message.fval = Number(object.fval); + if (object.ival != null) + message.ival = object.ival | 0; + if (object.bval != null) + message.bval = Boolean(object.bval); + if (object.readonly != null) + message.readonly = Boolean(object.readonly); + return message; + }; + + /** + * Creates a plain object from a Param message. Also converts values to other types if specified. + * @function toObject + * @memberof Param + * @static + * @param {Param} message Param + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Param.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) { + object.name = ""; + object.readonly = false; + } + if (message.name != null && message.hasOwnProperty("name")) + object.name = message.name; + if (message.fval != null && message.hasOwnProperty("fval")) { + object.fval = options.json && !isFinite(message.fval) ? String(message.fval) : message.fval; + if (options.oneofs) + object.val = "fval"; + } + if (message.ival != null && message.hasOwnProperty("ival")) { + object.ival = message.ival; + if (options.oneofs) + object.val = "ival"; + } + if (message.bval != null && message.hasOwnProperty("bval")) { + object.bval = message.bval; + if (options.oneofs) + object.val = "bval"; + } + if (message.readonly != null && message.hasOwnProperty("readonly")) + object.readonly = message.readonly; + return object; + }; + + /** + * Converts this Param to JSON. + * @function toJSON + * @memberof Param + * @instance + * @returns {Object.} JSON object + */ + Param.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Param; +})(); + +export const Device = $root.Device = (() => { + + /** + * Properties of a Device. + * @exports IDevice + * @interface IDevice + * @property {string|null} [name] Device name + * @property {number|Long|null} [uid] Device uid + * @property {number|null} [type] Device type + * @property {Array.|null} [params] Device params + */ + + /** + * Constructs a new Device. + * @exports Device + * @classdesc Represents a Device. + * @implements IDevice + * @constructor + * @param {IDevice=} [properties] Properties to set + */ + function Device(properties) { + this.params = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Device name. + * @member {string} name + * @memberof Device + * @instance + */ + Device.prototype.name = ""; + + /** + * Device uid. + * @member {number|Long} uid + * @memberof Device + * @instance + */ + Device.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0; + + /** + * Device type. + * @member {number} type + * @memberof Device + * @instance + */ + Device.prototype.type = 0; + + /** + * Device params. + * @member {Array.} params + * @memberof Device + * @instance + */ + Device.prototype.params = $util.emptyArray; + + /** + * Creates a new Device instance using the specified properties. + * @function create + * @memberof Device + * @static + * @param {IDevice=} [properties] Properties to set + * @returns {Device} Device instance + */ + Device.create = function create(properties) { + return new Device(properties); + }; + + /** + * Encodes the specified Device message. Does not implicitly {@link Device.verify|verify} messages. + * @function encode + * @memberof Device + * @static + * @param {Device} message Device message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Device.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.name != null && Object.hasOwnProperty.call(message, "name")) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); + if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) + writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.uid); + if (message.type != null && Object.hasOwnProperty.call(message, "type")) + writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.type); + if (message.params != null && message.params.length) + for (let i = 0; i < message.params.length; ++i) + $root.Param.encode(message.params[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified Device message, length delimited. Does not implicitly {@link Device.verify|verify} messages. + * @function encodeDelimited + * @memberof Device + * @static + * @param {Device} message Device message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Device.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Device message from the specified reader or buffer. + * @function decode + * @memberof Device + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Device} Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Device.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Device(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.uid = reader.uint64(); + break; + case 3: + message.type = reader.uint32(); + break; + case 4: + if (!(message.params && message.params.length)) + message.params = []; + message.params.push($root.Param.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Device message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Device + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Device} Device + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Device.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Device message. + * @function verify + * @memberof Device + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Device.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.name != null && message.hasOwnProperty("name")) + if (!$util.isString(message.name)) + return "name: string expected"; + if (message.uid != null && message.hasOwnProperty("uid")) + if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high))) + return "uid: integer|Long expected"; + if (message.type != null && message.hasOwnProperty("type")) + if (!$util.isInteger(message.type)) + return "type: integer expected"; + if (message.params != null && message.hasOwnProperty("params")) { + if (!Array.isArray(message.params)) + return "params: array expected"; + for (let i = 0; i < message.params.length; ++i) { + let error = $root.Param.verify(message.params[i]); + if (error) + return "params." + error; + } + } + return null; + }; + + /** + * Creates a Device message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Device + * @static + * @param {Object.} object Plain object + * @returns {Device} Device + */ + Device.fromObject = function fromObject(object) { + if (object instanceof $root.Device) + return object; + let message = new $root.Device(); + if (object.name != null) + message.name = String(object.name); + if (object.uid != null) + if ($util.Long) + (message.uid = $util.Long.fromValue(object.uid)).unsigned = true; + else if (typeof object.uid === "string") + message.uid = parseInt(object.uid, 10); + else if (typeof object.uid === "number") + message.uid = object.uid; + else if (typeof object.uid === "object") + message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true); + if (object.type != null) + message.type = object.type >>> 0; + if (object.params) { + if (!Array.isArray(object.params)) + throw TypeError(".Device.params: array expected"); + message.params = []; + for (let i = 0; i < object.params.length; ++i) { + if (typeof object.params[i] !== "object") + throw TypeError(".Device.params: object expected"); + message.params[i] = $root.Param.fromObject(object.params[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a Device message. Also converts values to other types if specified. + * @function toObject + * @memberof Device + * @static + * @param {Device} message Device + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Device.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.params = []; + if (options.defaults) { + object.name = ""; + if ($util.Long) { + let long = new $util.Long(0, 0, true); + object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.uid = options.longs === String ? "0" : 0; + object.type = 0; + } + if (message.name != null && message.hasOwnProperty("name")) + object.name = message.name; + if (message.uid != null && message.hasOwnProperty("uid")) + if (typeof message.uid === "number") + object.uid = options.longs === String ? String(message.uid) : message.uid; + else + object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid; + if (message.type != null && message.hasOwnProperty("type")) + object.type = message.type; + if (message.params && message.params.length) { + object.params = []; + for (let j = 0; j < message.params.length; ++j) + object.params[j] = $root.Param.toObject(message.params[j], options); + } + return object; + }; + + /** + * Converts this Device to JSON. + * @function toJSON + * @memberof Device + * @instance + * @returns {Object.} JSON object + */ + Device.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Device; +})(); + +export const DevData = $root.DevData = (() => { + + /** + * Properties of a DevData. + * @exports IDevData + * @interface IDevData + * @property {Array.|null} [devices] DevData devices + */ + + /** + * Constructs a new DevData. + * @exports DevData + * @classdesc Represents a DevData. + * @implements IDevData + * @constructor + * @param {IDevData=} [properties] Properties to set + */ + function DevData(properties) { + this.devices = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * DevData devices. + * @member {Array.} devices + * @memberof DevData + * @instance + */ + DevData.prototype.devices = $util.emptyArray; + + /** + * Creates a new DevData instance using the specified properties. + * @function create + * @memberof DevData + * @static + * @param {IDevData=} [properties] Properties to set + * @returns {DevData} DevData instance + */ + DevData.create = function create(properties) { + return new DevData(properties); + }; + + /** + * Encodes the specified DevData message. Does not implicitly {@link DevData.verify|verify} messages. + * @function encode + * @memberof DevData + * @static + * @param {DevData} message DevData message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + DevData.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.devices != null && message.devices.length) + for (let i = 0; i < message.devices.length; ++i) + $root.Device.encode(message.devices[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified DevData message, length delimited. Does not implicitly {@link DevData.verify|verify} messages. + * @function encodeDelimited + * @memberof DevData + * @static + * @param {DevData} message DevData message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + DevData.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a DevData message from the specified reader or buffer. + * @function decode + * @memberof DevData + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {DevData} DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + DevData.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DevData(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.devices && message.devices.length)) + message.devices = []; + message.devices.push($root.Device.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a DevData message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof DevData + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {DevData} DevData + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + DevData.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a DevData message. + * @function verify + * @memberof DevData + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + DevData.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.devices != null && message.hasOwnProperty("devices")) { + if (!Array.isArray(message.devices)) + return "devices: array expected"; + for (let i = 0; i < message.devices.length; ++i) { + let error = $root.Device.verify(message.devices[i]); + if (error) + return "devices." + error; + } + } + return null; + }; + + /** + * Creates a DevData message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof DevData + * @static + * @param {Object.} object Plain object + * @returns {DevData} DevData + */ + DevData.fromObject = function fromObject(object) { + if (object instanceof $root.DevData) + return object; + let message = new $root.DevData(); + if (object.devices) { + if (!Array.isArray(object.devices)) + throw TypeError(".DevData.devices: array expected"); + message.devices = []; + for (let i = 0; i < object.devices.length; ++i) { + if (typeof object.devices[i] !== "object") + throw TypeError(".DevData.devices: object expected"); + message.devices[i] = $root.Device.fromObject(object.devices[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a DevData message. Also converts values to other types if specified. + * @function toObject + * @memberof DevData + * @static + * @param {DevData} message DevData + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + DevData.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.devices = []; + if (message.devices && message.devices.length) { + object.devices = []; + for (let j = 0; j < message.devices.length; ++j) + object.devices[j] = $root.Device.toObject(message.devices[j], options); + } + return object; + }; + + /** + * Converts this DevData to JSON. + * @function toJSON + * @memberof DevData + * @instance + * @returns {Object.} JSON object + */ + DevData.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return DevData; +})(); + +/** + * State enum. + * @exports State + * @enum {number} + * @property {number} POISON_IVY=0 POISON_IVY value + * @property {number} DEHYDRATION=1 DEHYDRATION value + * @property {number} HYPOTHERMIA_START=2 HYPOTHERMIA_START value + * @property {number} HYPOTHERMIA_END=3 HYPOTHERMIA_END value + */ +export const State = $root.State = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "POISON_IVY"] = 0; + values[valuesById[1] = "DEHYDRATION"] = 1; + values[valuesById[2] = "HYPOTHERMIA_START"] = 2; + values[valuesById[3] = "HYPOTHERMIA_END"] = 3; + return values; +})(); + +export const GameState = $root.GameState = (() => { + + /** + * Properties of a GameState. + * @exports IGameState + * @interface IGameState + * @property {State|null} [state] GameState state + */ + + /** + * Constructs a new GameState. + * @exports GameState + * @classdesc Represents a GameState. + * @implements IGameState + * @constructor + * @param {IGameState=} [properties] Properties to set + */ + function GameState(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * GameState state. + * @member {State} state + * @memberof GameState + * @instance + */ + GameState.prototype.state = 0; + + /** + * Creates a new GameState instance using the specified properties. + * @function create + * @memberof GameState + * @static + * @param {IGameState=} [properties] Properties to set + * @returns {GameState} GameState instance + */ + GameState.create = function create(properties) { + return new GameState(properties); + }; + + /** + * Encodes the specified GameState message. Does not implicitly {@link GameState.verify|verify} messages. + * @function encode + * @memberof GameState + * @static + * @param {GameState} message GameState message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + GameState.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.state != null && Object.hasOwnProperty.call(message, "state")) + writer.uint32(/* id 1, wireType 0 =*/8).int32(message.state); + return writer; + }; + + /** + * Encodes the specified GameState message, length delimited. Does not implicitly {@link GameState.verify|verify} messages. + * @function encodeDelimited + * @memberof GameState + * @static + * @param {GameState} message GameState message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + GameState.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a GameState message from the specified reader or buffer. + * @function decode + * @memberof GameState + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {GameState} GameState + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + GameState.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.GameState(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.state = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a GameState message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof GameState + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {GameState} GameState + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + GameState.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a GameState message. + * @function verify + * @memberof GameState + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + GameState.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.state != null && message.hasOwnProperty("state")) + switch (message.state) { + default: + return "state: enum value expected"; + case 0: + case 1: + case 2: + case 3: + break; + } + return null; + }; + + /** + * Creates a GameState message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof GameState + * @static + * @param {Object.} object Plain object + * @returns {GameState} GameState + */ + GameState.fromObject = function fromObject(object) { + if (object instanceof $root.GameState) + return object; + let message = new $root.GameState(); + switch (object.state) { + case "POISON_IVY": + case 0: + message.state = 0; + break; + case "DEHYDRATION": + case 1: + message.state = 1; + break; + case "HYPOTHERMIA_START": + case 2: + message.state = 2; + break; + case "HYPOTHERMIA_END": + case 3: + message.state = 3; + break; + } + return message; + }; + + /** + * Creates a plain object from a GameState message. Also converts values to other types if specified. + * @function toObject + * @memberof GameState + * @static + * @param {GameState} message GameState + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + GameState.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) + object.state = options.enums === String ? "POISON_IVY" : 0; + if (message.state != null && message.hasOwnProperty("state")) + object.state = options.enums === String ? $root.State[message.state] : message.state; + return object; + }; + + /** + * Converts this GameState to JSON. + * @function toJSON + * @memberof GameState + * @instance + * @returns {Object.} JSON object + */ + GameState.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return GameState; +})(); + +/** + * Source enum. + * @exports Source + * @enum {number} + * @property {number} GAMEPAD=0 GAMEPAD value + * @property {number} KEYBOARD=1 KEYBOARD value + */ +export const Source = $root.Source = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "GAMEPAD"] = 0; + values[valuesById[1] = "KEYBOARD"] = 1; + return values; +})(); + +export const Input = $root.Input = (() => { + + /** + * Properties of an Input. + * @exports IInput + * @interface IInput + * @property {boolean|null} [connected] Input connected + * @property {number|Long|null} [buttons] Input buttons + * @property {Array.|null} [axes] Input axes + * @property {Source|null} [source] Input source + */ + + /** + * Constructs a new Input. + * @exports Input + * @classdesc Represents an Input. + * @implements IInput + * @constructor + * @param {IInput=} [properties] Properties to set + */ + function Input(properties) { + this.axes = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Input connected. + * @member {boolean} connected + * @memberof Input + * @instance + */ + Input.prototype.connected = false; + + /** + * Input buttons. + * @member {number|Long} buttons + * @memberof Input + * @instance + */ + Input.prototype.buttons = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * Input axes. + * @member {Array.} axes + * @memberof Input + * @instance + */ + Input.prototype.axes = $util.emptyArray; + + /** + * Input source. + * @member {Source} source + * @memberof Input + * @instance + */ + Input.prototype.source = 0; + + /** + * Creates a new Input instance using the specified properties. + * @function create + * @memberof Input + * @static + * @param {IInput=} [properties] Properties to set + * @returns {Input} Input instance + */ + Input.create = function create(properties) { + return new Input(properties); + }; + + /** + * Encodes the specified Input message. Does not implicitly {@link Input.verify|verify} messages. + * @function encode + * @memberof Input + * @static + * @param {Input} message Input message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Input.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.connected != null && Object.hasOwnProperty.call(message, "connected")) + writer.uint32(/* id 1, wireType 0 =*/8).bool(message.connected); + if (message.buttons != null && Object.hasOwnProperty.call(message, "buttons")) + writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.buttons); + if (message.axes != null && message.axes.length) { + writer.uint32(/* id 3, wireType 2 =*/26).fork(); + for (let i = 0; i < message.axes.length; ++i) + writer.float(message.axes[i]); + writer.ldelim(); + } + if (message.source != null && Object.hasOwnProperty.call(message, "source")) + writer.uint32(/* id 4, wireType 0 =*/32).int32(message.source); + return writer; + }; + + /** + * Encodes the specified Input message, length delimited. Does not implicitly {@link Input.verify|verify} messages. + * @function encodeDelimited + * @memberof Input + * @static + * @param {Input} message Input message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Input.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes an Input message from the specified reader or buffer. + * @function decode + * @memberof Input + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Input} Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Input.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Input(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.connected = reader.bool(); + break; + case 2: + message.buttons = reader.fixed64(); + break; + case 3: + if (!(message.axes && message.axes.length)) + message.axes = []; + if ((tag & 7) === 2) { + let end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.axes.push(reader.float()); + } else + message.axes.push(reader.float()); + break; + case 4: + message.source = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes an Input message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Input + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Input} Input + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Input.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies an Input message. + * @function verify + * @memberof Input + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Input.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.connected != null && message.hasOwnProperty("connected")) + if (typeof message.connected !== "boolean") + return "connected: boolean expected"; + if (message.buttons != null && message.hasOwnProperty("buttons")) + if (!$util.isInteger(message.buttons) && !(message.buttons && $util.isInteger(message.buttons.low) && $util.isInteger(message.buttons.high))) + return "buttons: integer|Long expected"; + if (message.axes != null && message.hasOwnProperty("axes")) { + if (!Array.isArray(message.axes)) + return "axes: array expected"; + for (let i = 0; i < message.axes.length; ++i) + if (typeof message.axes[i] !== "number") + return "axes: number[] expected"; + } + if (message.source != null && message.hasOwnProperty("source")) + switch (message.source) { + default: + return "source: enum value expected"; + case 0: + case 1: + break; + } + return null; + }; + + /** + * Creates an Input message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Input + * @static + * @param {Object.} object Plain object + * @returns {Input} Input + */ + Input.fromObject = function fromObject(object) { + if (object instanceof $root.Input) + return object; + let message = new $root.Input(); + if (object.connected != null) + message.connected = Boolean(object.connected); + if (object.buttons != null) + if ($util.Long) + (message.buttons = $util.Long.fromValue(object.buttons)).unsigned = false; + else if (typeof object.buttons === "string") + message.buttons = parseInt(object.buttons, 10); + else if (typeof object.buttons === "number") + message.buttons = object.buttons; + else if (typeof object.buttons === "object") + message.buttons = new $util.LongBits(object.buttons.low >>> 0, object.buttons.high >>> 0).toNumber(); + if (object.axes) { + if (!Array.isArray(object.axes)) + throw TypeError(".Input.axes: array expected"); + message.axes = []; + for (let i = 0; i < object.axes.length; ++i) + message.axes[i] = Number(object.axes[i]); + } + switch (object.source) { + case "GAMEPAD": + case 0: + message.source = 0; + break; + case "KEYBOARD": + case 1: + message.source = 1; + break; + } + return message; + }; + + /** + * Creates a plain object from an Input message. Also converts values to other types if specified. + * @function toObject + * @memberof Input + * @static + * @param {Input} message Input + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Input.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.axes = []; + if (options.defaults) { + object.connected = false; + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.buttons = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.buttons = options.longs === String ? "0" : 0; + object.source = options.enums === String ? "GAMEPAD" : 0; + } + if (message.connected != null && message.hasOwnProperty("connected")) + object.connected = message.connected; + if (message.buttons != null && message.hasOwnProperty("buttons")) + if (typeof message.buttons === "number") + object.buttons = options.longs === String ? String(message.buttons) : message.buttons; + else + object.buttons = options.longs === String ? $util.Long.prototype.toString.call(message.buttons) : options.longs === Number ? new $util.LongBits(message.buttons.low >>> 0, message.buttons.high >>> 0).toNumber() : message.buttons; + if (message.axes && message.axes.length) { + object.axes = []; + for (let j = 0; j < message.axes.length; ++j) + object.axes[j] = options.json && !isFinite(message.axes[j]) ? String(message.axes[j]) : message.axes[j]; + } + if (message.source != null && message.hasOwnProperty("source")) + object.source = options.enums === String ? $root.Source[message.source] : message.source; + return object; + }; + + /** + * Converts this Input to JSON. + * @function toJSON + * @memberof Input + * @instance + * @returns {Object.} JSON object + */ + Input.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Input; +})(); + +export const UserInputs = $root.UserInputs = (() => { + + /** + * Properties of a UserInputs. + * @exports IUserInputs + * @interface IUserInputs + * @property {Array.|null} [inputs] UserInputs inputs + */ + + /** + * Constructs a new UserInputs. + * @exports UserInputs + * @classdesc Represents a UserInputs. + * @implements IUserInputs + * @constructor + * @param {IUserInputs=} [properties] Properties to set + */ + function UserInputs(properties) { + this.inputs = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * UserInputs inputs. + * @member {Array.} inputs + * @memberof UserInputs + * @instance + */ + UserInputs.prototype.inputs = $util.emptyArray; + + /** + * Creates a new UserInputs instance using the specified properties. + * @function create + * @memberof UserInputs + * @static + * @param {IUserInputs=} [properties] Properties to set + * @returns {UserInputs} UserInputs instance + */ + UserInputs.create = function create(properties) { + return new UserInputs(properties); + }; + + /** + * Encodes the specified UserInputs message. Does not implicitly {@link UserInputs.verify|verify} messages. + * @function encode + * @memberof UserInputs + * @static + * @param {UserInputs} message UserInputs message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + UserInputs.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.inputs != null && message.inputs.length) + for (let i = 0; i < message.inputs.length; ++i) + $root.Input.encode(message.inputs[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified UserInputs message, length delimited. Does not implicitly {@link UserInputs.verify|verify} messages. + * @function encodeDelimited + * @memberof UserInputs + * @static + * @param {UserInputs} message UserInputs message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + UserInputs.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a UserInputs message from the specified reader or buffer. + * @function decode + * @memberof UserInputs + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {UserInputs} UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + UserInputs.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.UserInputs(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.inputs && message.inputs.length)) + message.inputs = []; + message.inputs.push($root.Input.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a UserInputs message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof UserInputs + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {UserInputs} UserInputs + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + UserInputs.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a UserInputs message. + * @function verify + * @memberof UserInputs + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + UserInputs.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.inputs != null && message.hasOwnProperty("inputs")) { + if (!Array.isArray(message.inputs)) + return "inputs: array expected"; + for (let i = 0; i < message.inputs.length; ++i) { + let error = $root.Input.verify(message.inputs[i]); + if (error) + return "inputs." + error; + } + } + return null; + }; + + /** + * Creates a UserInputs message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof UserInputs + * @static + * @param {Object.} object Plain object + * @returns {UserInputs} UserInputs + */ + UserInputs.fromObject = function fromObject(object) { + if (object instanceof $root.UserInputs) + return object; + let message = new $root.UserInputs(); + if (object.inputs) { + if (!Array.isArray(object.inputs)) + throw TypeError(".UserInputs.inputs: array expected"); + message.inputs = []; + for (let i = 0; i < object.inputs.length; ++i) { + if (typeof object.inputs[i] !== "object") + throw TypeError(".UserInputs.inputs: object expected"); + message.inputs[i] = $root.Input.fromObject(object.inputs[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a UserInputs message. Also converts values to other types if specified. + * @function toObject + * @memberof UserInputs + * @static + * @param {UserInputs} message UserInputs + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + UserInputs.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.inputs = []; + if (message.inputs && message.inputs.length) { + object.inputs = []; + for (let j = 0; j < message.inputs.length; ++j) + object.inputs[j] = $root.Input.toObject(message.inputs[j], options); + } + return object; + }; + + /** + * Converts this UserInputs to JSON. + * @function toJSON + * @memberof UserInputs + * @instance + * @returns {Object.} JSON object + */ + UserInputs.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return UserInputs; +})(); + +/** + * Mode enum. + * @exports Mode + * @enum {number} + * @property {number} IDLE=0 IDLE value + * @property {number} AUTO=1 AUTO value + * @property {number} TELEOP=2 TELEOP value + * @property {number} ESTOP=3 ESTOP value + */ +export const Mode = $root.Mode = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "IDLE"] = 0; + values[valuesById[1] = "AUTO"] = 1; + values[valuesById[2] = "TELEOP"] = 2; + values[valuesById[3] = "ESTOP"] = 3; + return values; +})(); + +export const RunMode = $root.RunMode = (() => { + + /** + * Properties of a RunMode. + * @exports IRunMode + * @interface IRunMode + * @property {Mode|null} [mode] RunMode mode + */ + + /** + * Constructs a new RunMode. + * @exports RunMode + * @classdesc Represents a RunMode. + * @implements IRunMode + * @constructor + * @param {IRunMode=} [properties] Properties to set + */ + function RunMode(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * RunMode mode. + * @member {Mode} mode + * @memberof RunMode + * @instance + */ + RunMode.prototype.mode = 0; + + /** + * Creates a new RunMode instance using the specified properties. + * @function create + * @memberof RunMode + * @static + * @param {IRunMode=} [properties] Properties to set + * @returns {RunMode} RunMode instance + */ + RunMode.create = function create(properties) { + return new RunMode(properties); + }; + + /** + * Encodes the specified RunMode message. Does not implicitly {@link RunMode.verify|verify} messages. + * @function encode + * @memberof RunMode + * @static + * @param {RunMode} message RunMode message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RunMode.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.mode != null && Object.hasOwnProperty.call(message, "mode")) + writer.uint32(/* id 1, wireType 0 =*/8).int32(message.mode); + return writer; + }; + + /** + * Encodes the specified RunMode message, length delimited. Does not implicitly {@link RunMode.verify|verify} messages. + * @function encodeDelimited + * @memberof RunMode + * @static + * @param {RunMode} message RunMode message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RunMode.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a RunMode message from the specified reader or buffer. + * @function decode + * @memberof RunMode + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {RunMode} RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RunMode.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.RunMode(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.mode = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a RunMode message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof RunMode + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {RunMode} RunMode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RunMode.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a RunMode message. + * @function verify + * @memberof RunMode + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + RunMode.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.mode != null && message.hasOwnProperty("mode")) + switch (message.mode) { + default: + return "mode: enum value expected"; + case 0: + case 1: + case 2: + case 3: + break; + } + return null; + }; + + /** + * Creates a RunMode message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof RunMode + * @static + * @param {Object.} object Plain object + * @returns {RunMode} RunMode + */ + RunMode.fromObject = function fromObject(object) { + if (object instanceof $root.RunMode) + return object; + let message = new $root.RunMode(); + switch (object.mode) { + case "IDLE": + case 0: + message.mode = 0; + break; + case "AUTO": + case 1: + message.mode = 1; + break; + case "TELEOP": + case 2: + message.mode = 2; + break; + case "ESTOP": + case 3: + message.mode = 3; + break; + } + return message; + }; + + /** + * Creates a plain object from a RunMode message. Also converts values to other types if specified. + * @function toObject + * @memberof RunMode + * @static + * @param {RunMode} message RunMode + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + RunMode.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) + object.mode = options.enums === String ? "IDLE" : 0; + if (message.mode != null && message.hasOwnProperty("mode")) + object.mode = options.enums === String ? $root.Mode[message.mode] : message.mode; + return object; + }; + + /** + * Converts this RunMode to JSON. + * @function toJSON + * @memberof RunMode + * @instance + * @returns {Object.} JSON object + */ + RunMode.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return RunMode; +})(); + +export const RuntimeStatus = $root.RuntimeStatus = (() => { + + /** + * Properties of a RuntimeStatus. + * @exports IRuntimeStatus + * @interface IRuntimeStatus + * @property {boolean|null} [shepConnected] RuntimeStatus shepConnected + * @property {boolean|null} [dawnConnected] RuntimeStatus dawnConnected + * @property {Mode|null} [mode] RuntimeStatus mode + * @property {number|null} [battery] RuntimeStatus battery + * @property {string|null} [version] RuntimeStatus version + */ + + /** + * Constructs a new RuntimeStatus. + * @exports RuntimeStatus + * @classdesc Represents a RuntimeStatus. + * @implements IRuntimeStatus + * @constructor + * @param {IRuntimeStatus=} [properties] Properties to set + */ + function RuntimeStatus(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * RuntimeStatus shepConnected. + * @member {boolean} shepConnected + * @memberof RuntimeStatus + * @instance + */ + RuntimeStatus.prototype.shepConnected = false; + + /** + * RuntimeStatus dawnConnected. + * @member {boolean} dawnConnected + * @memberof RuntimeStatus + * @instance + */ + RuntimeStatus.prototype.dawnConnected = false; + + /** + * RuntimeStatus mode. + * @member {Mode} mode + * @memberof RuntimeStatus + * @instance + */ + RuntimeStatus.prototype.mode = 0; + + /** + * RuntimeStatus battery. + * @member {number} battery + * @memberof RuntimeStatus + * @instance + */ + RuntimeStatus.prototype.battery = 0; + + /** + * RuntimeStatus version. + * @member {string} version + * @memberof RuntimeStatus + * @instance + */ + RuntimeStatus.prototype.version = ""; + + /** + * Creates a new RuntimeStatus instance using the specified properties. + * @function create + * @memberof RuntimeStatus + * @static + * @param {IRuntimeStatus=} [properties] Properties to set + * @returns {RuntimeStatus} RuntimeStatus instance + */ + RuntimeStatus.create = function create(properties) { + return new RuntimeStatus(properties); + }; + + /** + * Encodes the specified RuntimeStatus message. Does not implicitly {@link RuntimeStatus.verify|verify} messages. + * @function encode + * @memberof RuntimeStatus + * @static + * @param {RuntimeStatus} message RuntimeStatus message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RuntimeStatus.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.shepConnected != null && Object.hasOwnProperty.call(message, "shepConnected")) + writer.uint32(/* id 1, wireType 0 =*/8).bool(message.shepConnected); + if (message.dawnConnected != null && Object.hasOwnProperty.call(message, "dawnConnected")) + writer.uint32(/* id 2, wireType 0 =*/16).bool(message.dawnConnected); + if (message.mode != null && Object.hasOwnProperty.call(message, "mode")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.mode); + if (message.battery != null && Object.hasOwnProperty.call(message, "battery")) + writer.uint32(/* id 4, wireType 5 =*/37).float(message.battery); + if (message.version != null && Object.hasOwnProperty.call(message, "version")) + writer.uint32(/* id 5, wireType 2 =*/42).string(message.version); + return writer; + }; + + /** + * Encodes the specified RuntimeStatus message, length delimited. Does not implicitly {@link RuntimeStatus.verify|verify} messages. + * @function encodeDelimited + * @memberof RuntimeStatus + * @static + * @param {RuntimeStatus} message RuntimeStatus message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + RuntimeStatus.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a RuntimeStatus message from the specified reader or buffer. + * @function decode + * @memberof RuntimeStatus + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {RuntimeStatus} RuntimeStatus + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RuntimeStatus.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.RuntimeStatus(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.shepConnected = reader.bool(); + break; + case 2: + message.dawnConnected = reader.bool(); + break; + case 3: + message.mode = reader.int32(); + break; + case 4: + message.battery = reader.float(); + break; + case 5: + message.version = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a RuntimeStatus message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof RuntimeStatus + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {RuntimeStatus} RuntimeStatus + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + RuntimeStatus.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a RuntimeStatus message. + * @function verify + * @memberof RuntimeStatus + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + RuntimeStatus.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.shepConnected != null && message.hasOwnProperty("shepConnected")) + if (typeof message.shepConnected !== "boolean") + return "shepConnected: boolean expected"; + if (message.dawnConnected != null && message.hasOwnProperty("dawnConnected")) + if (typeof message.dawnConnected !== "boolean") + return "dawnConnected: boolean expected"; + if (message.mode != null && message.hasOwnProperty("mode")) + switch (message.mode) { + default: + return "mode: enum value expected"; + case 0: + case 1: + case 2: + case 3: + break; + } + if (message.battery != null && message.hasOwnProperty("battery")) + if (typeof message.battery !== "number") + return "battery: number expected"; + if (message.version != null && message.hasOwnProperty("version")) + if (!$util.isString(message.version)) + return "version: string expected"; + return null; + }; + + /** + * Creates a RuntimeStatus message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof RuntimeStatus + * @static + * @param {Object.} object Plain object + * @returns {RuntimeStatus} RuntimeStatus + */ + RuntimeStatus.fromObject = function fromObject(object) { + if (object instanceof $root.RuntimeStatus) + return object; + let message = new $root.RuntimeStatus(); + if (object.shepConnected != null) + message.shepConnected = Boolean(object.shepConnected); + if (object.dawnConnected != null) + message.dawnConnected = Boolean(object.dawnConnected); + switch (object.mode) { + case "IDLE": + case 0: + message.mode = 0; + break; + case "AUTO": + case 1: + message.mode = 1; + break; + case "TELEOP": + case 2: + message.mode = 2; + break; + case "ESTOP": + case 3: + message.mode = 3; + break; + } + if (object.battery != null) + message.battery = Number(object.battery); + if (object.version != null) + message.version = String(object.version); + return message; + }; + + /** + * Creates a plain object from a RuntimeStatus message. Also converts values to other types if specified. + * @function toObject + * @memberof RuntimeStatus + * @static + * @param {RuntimeStatus} message RuntimeStatus + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + RuntimeStatus.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) { + object.shepConnected = false; + object.dawnConnected = false; + object.mode = options.enums === String ? "IDLE" : 0; + object.battery = 0; + object.version = ""; + } + if (message.shepConnected != null && message.hasOwnProperty("shepConnected")) + object.shepConnected = message.shepConnected; + if (message.dawnConnected != null && message.hasOwnProperty("dawnConnected")) + object.dawnConnected = message.dawnConnected; + if (message.mode != null && message.hasOwnProperty("mode")) + object.mode = options.enums === String ? $root.Mode[message.mode] : message.mode; + if (message.battery != null && message.hasOwnProperty("battery")) + object.battery = options.json && !isFinite(message.battery) ? String(message.battery) : message.battery; + if (message.version != null && message.hasOwnProperty("version")) + object.version = message.version; + return object; + }; + + /** + * Converts this RuntimeStatus to JSON. + * @function toJSON + * @memberof RuntimeStatus + * @instance + * @returns {Object.} JSON object + */ + RuntimeStatus.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return RuntimeStatus; +})(); + +/** + * Pos enum. + * @exports Pos + * @enum {number} + * @property {number} LEFT=0 LEFT value + * @property {number} RIGHT=1 RIGHT value + */ +export const Pos = $root.Pos = (() => { + const valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "LEFT"] = 0; + values[valuesById[1] = "RIGHT"] = 1; + return values; +})(); + +export const StartPos = $root.StartPos = (() => { + + /** + * Properties of a StartPos. + * @exports IStartPos + * @interface IStartPos + * @property {Pos|null} [pos] StartPos pos + */ + + /** + * Constructs a new StartPos. + * @exports StartPos + * @classdesc Represents a StartPos. + * @implements IStartPos + * @constructor + * @param {IStartPos=} [properties] Properties to set + */ + function StartPos(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * StartPos pos. + * @member {Pos} pos + * @memberof StartPos + * @instance + */ + StartPos.prototype.pos = 0; + + /** + * Creates a new StartPos instance using the specified properties. + * @function create + * @memberof StartPos + * @static + * @param {IStartPos=} [properties] Properties to set + * @returns {StartPos} StartPos instance + */ + StartPos.create = function create(properties) { + return new StartPos(properties); + }; + + /** + * Encodes the specified StartPos message. Does not implicitly {@link StartPos.verify|verify} messages. + * @function encode + * @memberof StartPos + * @static + * @param {StartPos} message StartPos message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + StartPos.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.pos != null && Object.hasOwnProperty.call(message, "pos")) + writer.uint32(/* id 1, wireType 0 =*/8).int32(message.pos); + return writer; + }; + + /** + * Encodes the specified StartPos message, length delimited. Does not implicitly {@link StartPos.verify|verify} messages. + * @function encodeDelimited + * @memberof StartPos + * @static + * @param {StartPos} message StartPos message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + StartPos.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a StartPos message from the specified reader or buffer. + * @function decode + * @memberof StartPos + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {StartPos} StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + StartPos.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.StartPos(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pos = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a StartPos message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof StartPos + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {StartPos} StartPos + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + StartPos.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a StartPos message. + * @function verify + * @memberof StartPos + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + StartPos.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.pos != null && message.hasOwnProperty("pos")) + switch (message.pos) { + default: + return "pos: enum value expected"; + case 0: + case 1: + break; + } + return null; + }; + + /** + * Creates a StartPos message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof StartPos + * @static + * @param {Object.} object Plain object + * @returns {StartPos} StartPos + */ + StartPos.fromObject = function fromObject(object) { + if (object instanceof $root.StartPos) + return object; + let message = new $root.StartPos(); + switch (object.pos) { + case "LEFT": + case 0: + message.pos = 0; + break; + case "RIGHT": + case 1: + message.pos = 1; + break; + } + return message; + }; + + /** + * Creates a plain object from a StartPos message. Also converts values to other types if specified. + * @function toObject + * @memberof StartPos + * @static + * @param {StartPos} message StartPos + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + StartPos.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) + object.pos = options.enums === String ? "LEFT" : 0; + if (message.pos != null && message.hasOwnProperty("pos")) + object.pos = options.enums === String ? $root.Pos[message.pos] : message.pos; + return object; + }; + + /** + * Converts this StartPos to JSON. + * @function toJSON + * @memberof StartPos + * @instance + * @returns {Object.} JSON object + */ + StartPos.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return StartPos; +})(); + +export const Text = $root.Text = (() => { + + /** + * Properties of a Text. + * @exports IText + * @interface IText + * @property {Array.|null} [payload] Text payload + */ + + /** + * Constructs a new Text. + * @exports Text + * @classdesc Represents a Text. + * @implements IText + * @constructor + * @param {IText=} [properties] Properties to set + */ + function Text(properties) { + this.payload = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Text payload. + * @member {Array.} payload + * @memberof Text + * @instance + */ + Text.prototype.payload = $util.emptyArray; + + /** + * Creates a new Text instance using the specified properties. + * @function create + * @memberof Text + * @static + * @param {IText=} [properties] Properties to set + * @returns {Text} Text instance + */ + Text.create = function create(properties) { + return new Text(properties); + }; + + /** + * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages. + * @function encode + * @memberof Text + * @static + * @param {Text} message Text message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Text.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.payload != null && message.payload.length) + for (let i = 0; i < message.payload.length; ++i) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.payload[i]); + return writer; + }; + + /** + * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages. + * @function encodeDelimited + * @memberof Text + * @static + * @param {Text} message Text message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Text.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Text message from the specified reader or buffer. + * @function decode + * @memberof Text + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Text} Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Text.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Text(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.payload && message.payload.length)) + message.payload = []; + message.payload.push(reader.string()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Text message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Text + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Text} Text + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Text.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Text message. + * @function verify + * @memberof Text + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Text.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.payload != null && message.hasOwnProperty("payload")) { + if (!Array.isArray(message.payload)) + return "payload: array expected"; + for (let i = 0; i < message.payload.length; ++i) + if (!$util.isString(message.payload[i])) + return "payload: string[] expected"; + } + return null; + }; + + /** + * Creates a Text message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Text + * @static + * @param {Object.} object Plain object + * @returns {Text} Text + */ + Text.fromObject = function fromObject(object) { + if (object instanceof $root.Text) + return object; + let message = new $root.Text(); + if (object.payload) { + if (!Array.isArray(object.payload)) + throw TypeError(".Text.payload: array expected"); + message.payload = []; + for (let i = 0; i < object.payload.length; ++i) + message.payload[i] = String(object.payload[i]); + } + return message; + }; + + /** + * Creates a plain object from a Text message. Also converts values to other types if specified. + * @function toObject + * @memberof Text + * @static + * @param {Text} message Text + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Text.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.payload = []; + if (message.payload && message.payload.length) { + object.payload = []; + for (let j = 0; j < message.payload.length; ++j) + object.payload[j] = message.payload[j]; + } + return object; + }; + + /** + * Converts this Text to JSON. + * @function toJSON + * @memberof Text + * @instance + * @returns {Object.} JSON object + */ + Text.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Text; +})(); + +export const TimeStamps = $root.TimeStamps = (() => { + + /** + * Properties of a TimeStamps. + * @exports ITimeStamps + * @interface ITimeStamps + * @property {number|Long|null} [dawnTimestamp] TimeStamps dawnTimestamp + * @property {number|Long|null} [runtimeTimestamp] TimeStamps runtimeTimestamp + */ + + /** + * Constructs a new TimeStamps. + * @exports TimeStamps + * @classdesc Represents a TimeStamps. + * @implements ITimeStamps + * @constructor + * @param {ITimeStamps=} [properties] Properties to set + */ + function TimeStamps(properties) { + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * TimeStamps dawnTimestamp. + * @member {number|Long} dawnTimestamp + * @memberof TimeStamps + * @instance + */ + TimeStamps.prototype.dawnTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * TimeStamps runtimeTimestamp. + * @member {number|Long} runtimeTimestamp + * @memberof TimeStamps + * @instance + */ + TimeStamps.prototype.runtimeTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * Creates a new TimeStamps instance using the specified properties. + * @function create + * @memberof TimeStamps + * @static + * @param {ITimeStamps=} [properties] Properties to set + * @returns {TimeStamps} TimeStamps instance + */ + TimeStamps.create = function create(properties) { + return new TimeStamps(properties); + }; + + /** + * Encodes the specified TimeStamps message. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @function encode + * @memberof TimeStamps + * @static + * @param {TimeStamps} message TimeStamps message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + TimeStamps.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.dawnTimestamp != null && Object.hasOwnProperty.call(message, "dawnTimestamp")) + writer.uint32(/* id 1, wireType 1 =*/9).fixed64(message.dawnTimestamp); + if (message.runtimeTimestamp != null && Object.hasOwnProperty.call(message, "runtimeTimestamp")) + writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.runtimeTimestamp); + return writer; + }; + + /** + * Encodes the specified TimeStamps message, length delimited. Does not implicitly {@link TimeStamps.verify|verify} messages. + * @function encodeDelimited + * @memberof TimeStamps + * @static + * @param {TimeStamps} message TimeStamps message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + TimeStamps.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a TimeStamps message from the specified reader or buffer. + * @function decode + * @memberof TimeStamps + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {TimeStamps} TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + TimeStamps.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TimeStamps(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.dawnTimestamp = reader.fixed64(); + break; + case 2: + message.runtimeTimestamp = reader.fixed64(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a TimeStamps message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof TimeStamps + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {TimeStamps} TimeStamps + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + TimeStamps.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a TimeStamps message. + * @function verify + * @memberof TimeStamps + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + TimeStamps.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.dawnTimestamp != null && message.hasOwnProperty("dawnTimestamp")) + if (!$util.isInteger(message.dawnTimestamp) && !(message.dawnTimestamp && $util.isInteger(message.dawnTimestamp.low) && $util.isInteger(message.dawnTimestamp.high))) + return "dawnTimestamp: integer|Long expected"; + if (message.runtimeTimestamp != null && message.hasOwnProperty("runtimeTimestamp")) + if (!$util.isInteger(message.runtimeTimestamp) && !(message.runtimeTimestamp && $util.isInteger(message.runtimeTimestamp.low) && $util.isInteger(message.runtimeTimestamp.high))) + return "runtimeTimestamp: integer|Long expected"; + return null; + }; + + /** + * Creates a TimeStamps message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof TimeStamps + * @static + * @param {Object.} object Plain object + * @returns {TimeStamps} TimeStamps + */ + TimeStamps.fromObject = function fromObject(object) { + if (object instanceof $root.TimeStamps) + return object; + let message = new $root.TimeStamps(); + if (object.dawnTimestamp != null) + if ($util.Long) + (message.dawnTimestamp = $util.Long.fromValue(object.dawnTimestamp)).unsigned = false; + else if (typeof object.dawnTimestamp === "string") + message.dawnTimestamp = parseInt(object.dawnTimestamp, 10); + else if (typeof object.dawnTimestamp === "number") + message.dawnTimestamp = object.dawnTimestamp; + else if (typeof object.dawnTimestamp === "object") + message.dawnTimestamp = new $util.LongBits(object.dawnTimestamp.low >>> 0, object.dawnTimestamp.high >>> 0).toNumber(); + if (object.runtimeTimestamp != null) + if ($util.Long) + (message.runtimeTimestamp = $util.Long.fromValue(object.runtimeTimestamp)).unsigned = false; + else if (typeof object.runtimeTimestamp === "string") + message.runtimeTimestamp = parseInt(object.runtimeTimestamp, 10); + else if (typeof object.runtimeTimestamp === "number") + message.runtimeTimestamp = object.runtimeTimestamp; + else if (typeof object.runtimeTimestamp === "object") + message.runtimeTimestamp = new $util.LongBits(object.runtimeTimestamp.low >>> 0, object.runtimeTimestamp.high >>> 0).toNumber(); + return message; + }; + + /** + * Creates a plain object from a TimeStamps message. Also converts values to other types if specified. + * @function toObject + * @memberof TimeStamps + * @static + * @param {TimeStamps} message TimeStamps + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + TimeStamps.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.defaults) { + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.dawnTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.dawnTimestamp = options.longs === String ? "0" : 0; + if ($util.Long) { + let long = new $util.Long(0, 0, false); + object.runtimeTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.runtimeTimestamp = options.longs === String ? "0" : 0; + } + if (message.dawnTimestamp != null && message.hasOwnProperty("dawnTimestamp")) + if (typeof message.dawnTimestamp === "number") + object.dawnTimestamp = options.longs === String ? String(message.dawnTimestamp) : message.dawnTimestamp; + else + object.dawnTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.dawnTimestamp) : options.longs === Number ? new $util.LongBits(message.dawnTimestamp.low >>> 0, message.dawnTimestamp.high >>> 0).toNumber() : message.dawnTimestamp; + if (message.runtimeTimestamp != null && message.hasOwnProperty("runtimeTimestamp")) + if (typeof message.runtimeTimestamp === "number") + object.runtimeTimestamp = options.longs === String ? String(message.runtimeTimestamp) : message.runtimeTimestamp; + else + object.runtimeTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.runtimeTimestamp) : options.longs === Number ? new $util.LongBits(message.runtimeTimestamp.low >>> 0, message.runtimeTimestamp.high >>> 0).toNumber() : message.runtimeTimestamp; + return object; + }; + + /** + * Converts this TimeStamps to JSON. + * @function toJSON + * @memberof TimeStamps + * @instance + * @returns {Object.} JSON object + */ + TimeStamps.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return TimeStamps; +})(); + +export { $root as default }; From c690b0596f5d084b53fa8d9386fdcb1bcba40391 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 9 Oct 2021 21:28:18 -0700 Subject: [PATCH 07/10] Add buffer dependency --- package.json | 1 + yarn.lock | 12 ++++++++++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index ad00ad2..edf977a 100644 --- a/package.json +++ b/package.json @@ -10,6 +10,7 @@ "@types/node": "^12.0.0", "@types/react": "^17.0.0", "@types/react-dom": "^17.0.0", + "buffer": "^6.0.3", "protobufjs": "^6.11.2", "react": "^17.0.2", "react-dom": "^17.0.2", diff --git a/yarn.lock b/yarn.lock index abb6c56..24974af 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2793,7 +2793,7 @@ balanced-match@^1.0.0: resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767" integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c= -base64-js@^1.0.2: +base64-js@^1.0.2, base64-js@^1.3.1: version "1.5.1" resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== @@ -3057,6 +3057,14 @@ buffer@^4.3.0: ieee754 "^1.1.4" isarray "^1.0.0" +buffer@^6.0.3: + version "6.0.3" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6" + integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.2.1" + builtin-modules@^3.1.0: version "3.2.0" resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887" @@ -5732,7 +5740,7 @@ identity-obj-proxy@3.0.0: dependencies: harmony-reflect "^1.4.6" -ieee754@^1.1.4: +ieee754@^1.1.4, ieee754@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== From 0ba4ae42b3b8a7fd58e9c0695434d93a4e1cfb19 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 9 Oct 2021 21:28:42 -0700 Subject: [PATCH 08/10] Reorganize protos folder --- src/protos/input.proto | 26 - src/protos/protos.d.ts | 894 ---------------- src/protos/protos.js | 2210 ---------------------------------------- 3 files changed, 3130 deletions(-) delete mode 100644 src/protos/input.proto delete mode 100644 src/protos/protos.d.ts delete mode 100644 src/protos/protos.js diff --git a/src/protos/input.proto b/src/protos/input.proto deleted file mode 100644 index 50834c5..0000000 --- a/src/protos/input.proto +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Defines a message for communicating user inputs - */ - -syntax = "proto3"; - -option optimize_for = LITE_RUNTIME; - -// Message for the current state of an input -message Input { - bool connected = 1; - fixed64 buttons = 2; - repeated float axes = 3; - Source source = 4; -} - -// An array of all inputs from all sources -message UserInputs { - repeated Input inputs = 1; -} - -// Enum specifying which input source the data is from -enum Source { - GAMEPAD = 0; - KEYBOARD = 1; -} \ No newline at end of file diff --git a/src/protos/protos.d.ts b/src/protos/protos.d.ts deleted file mode 100644 index 4c88a21..0000000 --- a/src/protos/protos.d.ts +++ /dev/null @@ -1,894 +0,0 @@ -import * as $protobuf from "protobufjs"; -/** Properties of a Param. */ -export interface IParam { - - /** Param name */ - name?: (string|null); - - /** Param fval */ - fval?: (number|null); - - /** Param ival */ - ival?: (number|null); - - /** Param bval */ - bval?: (boolean|null); -} - -/** Represents a Param. */ -export class Param implements IParam { - - /** - * Constructs a new Param. - * @param [properties] Properties to set - */ - constructor(properties?: IParam); - - /** Param name. */ - public name: string; - - /** Param fval. */ - public fval: number; - - /** Param ival. */ - public ival: number; - - /** Param bval. */ - public bval: boolean; - - /** Param val. */ - public val?: ("fval"|"ival"|"bval"); - - /** - * Creates a new Param instance using the specified properties. - * @param [properties] Properties to set - * @returns Param instance - */ - public static create(properties?: IParam): Param; - - /** - * Encodes the specified Param message. Does not implicitly {@link Param.verify|verify} messages. - * @param message Param message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IParam, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified Param message, length delimited. Does not implicitly {@link Param.verify|verify} messages. - * @param message Param message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IParam, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a Param message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns Param - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Param; - - /** - * Decodes a Param message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns Param - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Param; - - /** - * Verifies a Param message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a Param message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns Param - */ - public static fromObject(object: { [k: string]: any }): Param; - - /** - * Creates a plain object from a Param message. Also converts values to other types if specified. - * @param message Param - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: Param, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this Param to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Properties of a Device. */ -export interface IDevice { - - /** Device name */ - name?: (string|null); - - /** Device uid */ - uid?: (number|Long|null); - - /** Device type */ - type?: (number|null); - - /** Device params */ - params?: (IParam[]|null); -} - -/** Represents a Device. */ -export class Device implements IDevice { - - /** - * Constructs a new Device. - * @param [properties] Properties to set - */ - constructor(properties?: IDevice); - - /** Device name. */ - public name: string; - - /** Device uid. */ - public uid: (number|Long); - - /** Device type. */ - public type: number; - - /** Device params. */ - public params: Param[]; - - /** - * Creates a new Device instance using the specified properties. - * @param [properties] Properties to set - * @returns Device instance - */ - public static create(properties?: IDevice): Device; - - /** - * Encodes the specified Device message. Does not implicitly {@link Device.verify|verify} messages. - * @param message Device message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IDevice, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified Device message, length delimited. Does not implicitly {@link Device.verify|verify} messages. - * @param message Device message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IDevice, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a Device message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns Device - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Device; - - /** - * Decodes a Device message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns Device - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Device; - - /** - * Verifies a Device message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a Device message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns Device - */ - public static fromObject(object: { [k: string]: any }): Device; - - /** - * Creates a plain object from a Device message. Also converts values to other types if specified. - * @param message Device - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: Device, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this Device to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Properties of a DevData. */ -export interface IDevData { - - /** DevData devices */ - devices?: (IDevice[]|null); -} - -/** Represents a DevData. */ -export class DevData implements IDevData { - - /** - * Constructs a new DevData. - * @param [properties] Properties to set - */ - constructor(properties?: IDevData); - - /** DevData devices. */ - public devices: Device[]; - - /** - * Creates a new DevData instance using the specified properties. - * @param [properties] Properties to set - * @returns DevData instance - */ - public static create(properties?: IDevData): DevData; - - /** - * Encodes the specified DevData message. Does not implicitly {@link DevData.verify|verify} messages. - * @param message DevData message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IDevData, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified DevData message, length delimited. Does not implicitly {@link DevData.verify|verify} messages. - * @param message DevData message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IDevData, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a DevData message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns DevData - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DevData; - - /** - * Decodes a DevData message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns DevData - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DevData; - - /** - * Verifies a DevData message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a DevData message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns DevData - */ - public static fromObject(object: { [k: string]: any }): DevData; - - /** - * Creates a plain object from a DevData message. Also converts values to other types if specified. - * @param message DevData - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: DevData, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this DevData to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Properties of an Input. */ -export interface IInput { - - /** Input connected */ - connected?: (boolean|null); - - /** Input buttons */ - buttons?: (number|Long|null); - - /** Input axes */ - axes?: (number[]|null); - - /** Input source */ - source?: (Source|null); -} - -/** Represents an Input. */ -export class Input implements IInput { - - /** - * Constructs a new Input. - * @param [properties] Properties to set - */ - constructor(properties?: IInput); - - /** Input connected. */ - public connected: boolean; - - /** Input buttons. */ - public buttons: (number|Long); - - /** Input axes. */ - public axes: number[]; - - /** Input source. */ - public source: Source; - - /** - * Creates a new Input instance using the specified properties. - * @param [properties] Properties to set - * @returns Input instance - */ - public static create(properties?: IInput): Input; - - /** - * Encodes the specified Input message. Does not implicitly {@link Input.verify|verify} messages. - * @param message Input message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IInput, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified Input message, length delimited. Does not implicitly {@link Input.verify|verify} messages. - * @param message Input message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IInput, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes an Input message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns Input - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Input; - - /** - * Decodes an Input message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns Input - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Input; - - /** - * Verifies an Input message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates an Input message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns Input - */ - public static fromObject(object: { [k: string]: any }): Input; - - /** - * Creates a plain object from an Input message. Also converts values to other types if specified. - * @param message Input - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: Input, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this Input to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Properties of a UserInputs. */ -export interface IUserInputs { - - /** UserInputs inputs */ - inputs?: (IInput[]|null); -} - -/** Represents a UserInputs. */ -export class UserInputs implements IUserInputs { - - /** - * Constructs a new UserInputs. - * @param [properties] Properties to set - */ - constructor(properties?: IUserInputs); - - /** UserInputs inputs. */ - public inputs: Input[]; - - /** - * Creates a new UserInputs instance using the specified properties. - * @param [properties] Properties to set - * @returns UserInputs instance - */ - public static create(properties?: IUserInputs): UserInputs; - - /** - * Encodes the specified UserInputs message. Does not implicitly {@link UserInputs.verify|verify} messages. - * @param message UserInputs message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IUserInputs, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified UserInputs message, length delimited. Does not implicitly {@link UserInputs.verify|verify} messages. - * @param message UserInputs message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IUserInputs, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a UserInputs message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns UserInputs - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UserInputs; - - /** - * Decodes a UserInputs message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns UserInputs - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UserInputs; - - /** - * Verifies a UserInputs message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a UserInputs message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns UserInputs - */ - public static fromObject(object: { [k: string]: any }): UserInputs; - - /** - * Creates a plain object from a UserInputs message. Also converts values to other types if specified. - * @param message UserInputs - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: UserInputs, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this UserInputs to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Source enum. */ -export enum Source { - GAMEPAD = 0, - KEYBOARD = 1 -} - -/** Mode enum. */ -export enum Mode { - IDLE = 0, - AUTO = 1, - TELEOP = 2, - ESTOP = 3, - CHALLENGE = 4 -} - -/** Properties of a RunMode. */ -export interface IRunMode { - - /** RunMode mode */ - mode?: (Mode|null); -} - -/** Represents a RunMode. */ -export class RunMode implements IRunMode { - - /** - * Constructs a new RunMode. - * @param [properties] Properties to set - */ - constructor(properties?: IRunMode); - - /** RunMode mode. */ - public mode: Mode; - - /** - * Creates a new RunMode instance using the specified properties. - * @param [properties] Properties to set - * @returns RunMode instance - */ - public static create(properties?: IRunMode): RunMode; - - /** - * Encodes the specified RunMode message. Does not implicitly {@link RunMode.verify|verify} messages. - * @param message RunMode message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IRunMode, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified RunMode message, length delimited. Does not implicitly {@link RunMode.verify|verify} messages. - * @param message RunMode message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IRunMode, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a RunMode message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns RunMode - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): RunMode; - - /** - * Decodes a RunMode message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns RunMode - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): RunMode; - - /** - * Verifies a RunMode message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a RunMode message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns RunMode - */ - public static fromObject(object: { [k: string]: any }): RunMode; - - /** - * Creates a plain object from a RunMode message. Also converts values to other types if specified. - * @param message RunMode - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: RunMode, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this RunMode to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Pos enum. */ -export enum Pos { - LEFT = 0, - RIGHT = 1 -} - -/** Properties of a StartPos. */ -export interface IStartPos { - - /** StartPos pos */ - pos?: (Pos|null); -} - -/** Represents a StartPos. */ -export class StartPos implements IStartPos { - - /** - * Constructs a new StartPos. - * @param [properties] Properties to set - */ - constructor(properties?: IStartPos); - - /** StartPos pos. */ - public pos: Pos; - - /** - * Creates a new StartPos instance using the specified properties. - * @param [properties] Properties to set - * @returns StartPos instance - */ - public static create(properties?: IStartPos): StartPos; - - /** - * Encodes the specified StartPos message. Does not implicitly {@link StartPos.verify|verify} messages. - * @param message StartPos message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IStartPos, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified StartPos message, length delimited. Does not implicitly {@link StartPos.verify|verify} messages. - * @param message StartPos message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IStartPos, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a StartPos message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns StartPos - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): StartPos; - - /** - * Decodes a StartPos message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns StartPos - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): StartPos; - - /** - * Verifies a StartPos message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a StartPos message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns StartPos - */ - public static fromObject(object: { [k: string]: any }): StartPos; - - /** - * Creates a plain object from a StartPos message. Also converts values to other types if specified. - * @param message StartPos - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: StartPos, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this StartPos to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Properties of a Text. */ -export interface IText { - - /** Text payload */ - payload?: (string[]|null); -} - -/** Represents a Text. */ -export class Text implements IText { - - /** - * Constructs a new Text. - * @param [properties] Properties to set - */ - constructor(properties?: IText); - - /** Text payload. */ - public payload: string[]; - - /** - * Creates a new Text instance using the specified properties. - * @param [properties] Properties to set - * @returns Text instance - */ - public static create(properties?: IText): Text; - - /** - * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages. - * @param message Text message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: IText, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages. - * @param message Text message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: IText, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a Text message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns Text - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Text; - - /** - * Decodes a Text message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns Text - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Text; - - /** - * Verifies a Text message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a Text message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns Text - */ - public static fromObject(object: { [k: string]: any }): Text; - - /** - * Creates a plain object from a Text message. Also converts values to other types if specified. - * @param message Text - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: Text, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this Text to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} - -/** Properties of a TimeStamps. */ -export interface ITimeStamps { - - /** TimeStamps dawnTimestamp */ - dawnTimestamp?: (number|Long|null); - - /** TimeStamps runtimeTimestamp */ - runtimeTimestamp?: (number|Long|null); -} - -/** Represents a TimeStamps. */ -export class TimeStamps implements ITimeStamps { - - /** - * Constructs a new TimeStamps. - * @param [properties] Properties to set - */ - constructor(properties?: ITimeStamps); - - /** TimeStamps dawnTimestamp. */ - public dawnTimestamp: (number|Long); - - /** TimeStamps runtimeTimestamp. */ - public runtimeTimestamp: (number|Long); - - /** - * Creates a new TimeStamps instance using the specified properties. - * @param [properties] Properties to set - * @returns TimeStamps instance - */ - public static create(properties?: ITimeStamps): TimeStamps; - - /** - * Encodes the specified TimeStamps message. Does not implicitly {@link TimeStamps.verify|verify} messages. - * @param message TimeStamps message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encode(message: ITimeStamps, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Encodes the specified TimeStamps message, length delimited. Does not implicitly {@link TimeStamps.verify|verify} messages. - * @param message TimeStamps message or plain object to encode - * @param [writer] Writer to encode to - * @returns Writer - */ - public static encodeDelimited(message: ITimeStamps, writer?: $protobuf.Writer): $protobuf.Writer; - - /** - * Decodes a TimeStamps message from the specified reader or buffer. - * @param reader Reader or buffer to decode from - * @param [length] Message length if known beforehand - * @returns TimeStamps - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TimeStamps; - - /** - * Decodes a TimeStamps message from the specified reader or buffer, length delimited. - * @param reader Reader or buffer to decode from - * @returns TimeStamps - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TimeStamps; - - /** - * Verifies a TimeStamps message. - * @param message Plain object to verify - * @returns `null` if valid, otherwise the reason why it is not - */ - public static verify(message: { [k: string]: any }): (string|null); - - /** - * Creates a TimeStamps message from a plain object. Also converts values to their respective internal types. - * @param object Plain object - * @returns TimeStamps - */ - public static fromObject(object: { [k: string]: any }): TimeStamps; - - /** - * Creates a plain object from a TimeStamps message. Also converts values to other types if specified. - * @param message TimeStamps - * @param [options] Conversion options - * @returns Plain object - */ - public static toObject(message: TimeStamps, options?: $protobuf.IConversionOptions): { [k: string]: any }; - - /** - * Converts this TimeStamps to JSON. - * @returns JSON object - */ - public toJSON(): { [k: string]: any }; -} diff --git a/src/protos/protos.js b/src/protos/protos.js deleted file mode 100644 index 7d09715..0000000 --- a/src/protos/protos.js +++ /dev/null @@ -1,2210 +0,0 @@ -/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ -import * as $protobuf from "protobufjs/minimal"; - -// Common aliases -const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; - -// Exported root namespace -const $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); - -export const Param = $root.Param = (() => { - - /** - * Properties of a Param. - * @exports IParam - * @interface IParam - * @property {string|null} [name] Param name - * @property {number|null} [fval] Param fval - * @property {number|null} [ival] Param ival - * @property {boolean|null} [bval] Param bval - */ - - /** - * Constructs a new Param. - * @exports Param - * @classdesc Represents a Param. - * @implements IParam - * @constructor - * @param {IParam=} [properties] Properties to set - */ - function Param(properties) { - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * Param name. - * @member {string} name - * @memberof Param - * @instance - */ - Param.prototype.name = ""; - - /** - * Param fval. - * @member {number} fval - * @memberof Param - * @instance - */ - Param.prototype.fval = 0; - - /** - * Param ival. - * @member {number} ival - * @memberof Param - * @instance - */ - Param.prototype.ival = 0; - - /** - * Param bval. - * @member {boolean} bval - * @memberof Param - * @instance - */ - Param.prototype.bval = false; - - // OneOf field names bound to virtual getters and setters - let $oneOfFields; - - /** - * Param val. - * @member {"fval"|"ival"|"bval"|undefined} val - * @memberof Param - * @instance - */ - Object.defineProperty(Param.prototype, "val", { - get: $util.oneOfGetter($oneOfFields = ["fval", "ival", "bval"]), - set: $util.oneOfSetter($oneOfFields) - }); - - /** - * Creates a new Param instance using the specified properties. - * @function create - * @memberof Param - * @static - * @param {IParam=} [properties] Properties to set - * @returns {Param} Param instance - */ - Param.create = function create(properties) { - return new Param(properties); - }; - - /** - * Encodes the specified Param message. Does not implicitly {@link Param.verify|verify} messages. - * @function encode - * @memberof Param - * @static - * @param {IParam} message Param message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Param.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.name != null && Object.hasOwnProperty.call(message, "name")) - writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); - if (message.fval != null && Object.hasOwnProperty.call(message, "fval")) - writer.uint32(/* id 2, wireType 5 =*/21).float(message.fval); - if (message.ival != null && Object.hasOwnProperty.call(message, "ival")) - writer.uint32(/* id 3, wireType 0 =*/24).int32(message.ival); - if (message.bval != null && Object.hasOwnProperty.call(message, "bval")) - writer.uint32(/* id 4, wireType 0 =*/32).bool(message.bval); - return writer; - }; - - /** - * Encodes the specified Param message, length delimited. Does not implicitly {@link Param.verify|verify} messages. - * @function encodeDelimited - * @memberof Param - * @static - * @param {IParam} message Param message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Param.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a Param message from the specified reader or buffer. - * @function decode - * @memberof Param - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {Param} Param - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Param.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Param(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.name = reader.string(); - break; - case 2: - message.fval = reader.float(); - break; - case 3: - message.ival = reader.int32(); - break; - case 4: - message.bval = reader.bool(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a Param message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof Param - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {Param} Param - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Param.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a Param message. - * @function verify - * @memberof Param - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - Param.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - let properties = {}; - if (message.name != null && message.hasOwnProperty("name")) - if (!$util.isString(message.name)) - return "name: string expected"; - if (message.fval != null && message.hasOwnProperty("fval")) { - properties.val = 1; - if (typeof message.fval !== "number") - return "fval: number expected"; - } - if (message.ival != null && message.hasOwnProperty("ival")) { - if (properties.val === 1) - return "val: multiple values"; - properties.val = 1; - if (!$util.isInteger(message.ival)) - return "ival: integer expected"; - } - if (message.bval != null && message.hasOwnProperty("bval")) { - if (properties.val === 1) - return "val: multiple values"; - properties.val = 1; - if (typeof message.bval !== "boolean") - return "bval: boolean expected"; - } - return null; - }; - - /** - * Creates a Param message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof Param - * @static - * @param {Object.} object Plain object - * @returns {Param} Param - */ - Param.fromObject = function fromObject(object) { - if (object instanceof $root.Param) - return object; - let message = new $root.Param(); - if (object.name != null) - message.name = String(object.name); - if (object.fval != null) - message.fval = Number(object.fval); - if (object.ival != null) - message.ival = object.ival | 0; - if (object.bval != null) - message.bval = Boolean(object.bval); - return message; - }; - - /** - * Creates a plain object from a Param message. Also converts values to other types if specified. - * @function toObject - * @memberof Param - * @static - * @param {Param} message Param - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - Param.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.defaults) - object.name = ""; - if (message.name != null && message.hasOwnProperty("name")) - object.name = message.name; - if (message.fval != null && message.hasOwnProperty("fval")) { - object.fval = options.json && !isFinite(message.fval) ? String(message.fval) : message.fval; - if (options.oneofs) - object.val = "fval"; - } - if (message.ival != null && message.hasOwnProperty("ival")) { - object.ival = message.ival; - if (options.oneofs) - object.val = "ival"; - } - if (message.bval != null && message.hasOwnProperty("bval")) { - object.bval = message.bval; - if (options.oneofs) - object.val = "bval"; - } - return object; - }; - - /** - * Converts this Param to JSON. - * @function toJSON - * @memberof Param - * @instance - * @returns {Object.} JSON object - */ - Param.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return Param; -})(); - -export const Device = $root.Device = (() => { - - /** - * Properties of a Device. - * @exports IDevice - * @interface IDevice - * @property {string|null} [name] Device name - * @property {number|Long|null} [uid] Device uid - * @property {number|null} [type] Device type - * @property {Array.|null} [params] Device params - */ - - /** - * Constructs a new Device. - * @exports Device - * @classdesc Represents a Device. - * @implements IDevice - * @constructor - * @param {IDevice=} [properties] Properties to set - */ - function Device(properties) { - this.params = []; - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * Device name. - * @member {string} name - * @memberof Device - * @instance - */ - Device.prototype.name = ""; - - /** - * Device uid. - * @member {number|Long} uid - * @memberof Device - * @instance - */ - Device.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0; - - /** - * Device type. - * @member {number} type - * @memberof Device - * @instance - */ - Device.prototype.type = 0; - - /** - * Device params. - * @member {Array.} params - * @memberof Device - * @instance - */ - Device.prototype.params = $util.emptyArray; - - /** - * Creates a new Device instance using the specified properties. - * @function create - * @memberof Device - * @static - * @param {IDevice=} [properties] Properties to set - * @returns {Device} Device instance - */ - Device.create = function create(properties) { - return new Device(properties); - }; - - /** - * Encodes the specified Device message. Does not implicitly {@link Device.verify|verify} messages. - * @function encode - * @memberof Device - * @static - * @param {IDevice} message Device message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Device.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.name != null && Object.hasOwnProperty.call(message, "name")) - writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); - if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) - writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.uid); - if (message.type != null && Object.hasOwnProperty.call(message, "type")) - writer.uint32(/* id 3, wireType 0 =*/24).int32(message.type); - if (message.params != null && message.params.length) - for (let i = 0; i < message.params.length; ++i) - $root.Param.encode(message.params[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); - return writer; - }; - - /** - * Encodes the specified Device message, length delimited. Does not implicitly {@link Device.verify|verify} messages. - * @function encodeDelimited - * @memberof Device - * @static - * @param {IDevice} message Device message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Device.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a Device message from the specified reader or buffer. - * @function decode - * @memberof Device - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {Device} Device - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Device.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Device(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.name = reader.string(); - break; - case 2: - message.uid = reader.uint64(); - break; - case 3: - message.type = reader.int32(); - break; - case 4: - if (!(message.params && message.params.length)) - message.params = []; - message.params.push($root.Param.decode(reader, reader.uint32())); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a Device message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof Device - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {Device} Device - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Device.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a Device message. - * @function verify - * @memberof Device - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - Device.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) - if (!$util.isString(message.name)) - return "name: string expected"; - if (message.uid != null && message.hasOwnProperty("uid")) - if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high))) - return "uid: integer|Long expected"; - if (message.type != null && message.hasOwnProperty("type")) - if (!$util.isInteger(message.type)) - return "type: integer expected"; - if (message.params != null && message.hasOwnProperty("params")) { - if (!Array.isArray(message.params)) - return "params: array expected"; - for (let i = 0; i < message.params.length; ++i) { - let error = $root.Param.verify(message.params[i]); - if (error) - return "params." + error; - } - } - return null; - }; - - /** - * Creates a Device message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof Device - * @static - * @param {Object.} object Plain object - * @returns {Device} Device - */ - Device.fromObject = function fromObject(object) { - if (object instanceof $root.Device) - return object; - let message = new $root.Device(); - if (object.name != null) - message.name = String(object.name); - if (object.uid != null) - if ($util.Long) - (message.uid = $util.Long.fromValue(object.uid)).unsigned = true; - else if (typeof object.uid === "string") - message.uid = parseInt(object.uid, 10); - else if (typeof object.uid === "number") - message.uid = object.uid; - else if (typeof object.uid === "object") - message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true); - if (object.type != null) - message.type = object.type | 0; - if (object.params) { - if (!Array.isArray(object.params)) - throw TypeError(".Device.params: array expected"); - message.params = []; - for (let i = 0; i < object.params.length; ++i) { - if (typeof object.params[i] !== "object") - throw TypeError(".Device.params: object expected"); - message.params[i] = $root.Param.fromObject(object.params[i]); - } - } - return message; - }; - - /** - * Creates a plain object from a Device message. Also converts values to other types if specified. - * @function toObject - * @memberof Device - * @static - * @param {Device} message Device - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - Device.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.arrays || options.defaults) - object.params = []; - if (options.defaults) { - object.name = ""; - if ($util.Long) { - let long = new $util.Long(0, 0, true); - object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; - } else - object.uid = options.longs === String ? "0" : 0; - object.type = 0; - } - if (message.name != null && message.hasOwnProperty("name")) - object.name = message.name; - if (message.uid != null && message.hasOwnProperty("uid")) - if (typeof message.uid === "number") - object.uid = options.longs === String ? String(message.uid) : message.uid; - else - object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid; - if (message.type != null && message.hasOwnProperty("type")) - object.type = message.type; - if (message.params && message.params.length) { - object.params = []; - for (let j = 0; j < message.params.length; ++j) - object.params[j] = $root.Param.toObject(message.params[j], options); - } - return object; - }; - - /** - * Converts this Device to JSON. - * @function toJSON - * @memberof Device - * @instance - * @returns {Object.} JSON object - */ - Device.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return Device; -})(); - -export const DevData = $root.DevData = (() => { - - /** - * Properties of a DevData. - * @exports IDevData - * @interface IDevData - * @property {Array.|null} [devices] DevData devices - */ - - /** - * Constructs a new DevData. - * @exports DevData - * @classdesc Represents a DevData. - * @implements IDevData - * @constructor - * @param {IDevData=} [properties] Properties to set - */ - function DevData(properties) { - this.devices = []; - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * DevData devices. - * @member {Array.} devices - * @memberof DevData - * @instance - */ - DevData.prototype.devices = $util.emptyArray; - - /** - * Creates a new DevData instance using the specified properties. - * @function create - * @memberof DevData - * @static - * @param {IDevData=} [properties] Properties to set - * @returns {DevData} DevData instance - */ - DevData.create = function create(properties) { - return new DevData(properties); - }; - - /** - * Encodes the specified DevData message. Does not implicitly {@link DevData.verify|verify} messages. - * @function encode - * @memberof DevData - * @static - * @param {IDevData} message DevData message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - DevData.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.devices != null && message.devices.length) - for (let i = 0; i < message.devices.length; ++i) - $root.Device.encode(message.devices[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); - return writer; - }; - - /** - * Encodes the specified DevData message, length delimited. Does not implicitly {@link DevData.verify|verify} messages. - * @function encodeDelimited - * @memberof DevData - * @static - * @param {IDevData} message DevData message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - DevData.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a DevData message from the specified reader or buffer. - * @function decode - * @memberof DevData - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {DevData} DevData - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - DevData.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DevData(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - if (!(message.devices && message.devices.length)) - message.devices = []; - message.devices.push($root.Device.decode(reader, reader.uint32())); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a DevData message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof DevData - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {DevData} DevData - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - DevData.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a DevData message. - * @function verify - * @memberof DevData - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - DevData.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.devices != null && message.hasOwnProperty("devices")) { - if (!Array.isArray(message.devices)) - return "devices: array expected"; - for (let i = 0; i < message.devices.length; ++i) { - let error = $root.Device.verify(message.devices[i]); - if (error) - return "devices." + error; - } - } - return null; - }; - - /** - * Creates a DevData message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof DevData - * @static - * @param {Object.} object Plain object - * @returns {DevData} DevData - */ - DevData.fromObject = function fromObject(object) { - if (object instanceof $root.DevData) - return object; - let message = new $root.DevData(); - if (object.devices) { - if (!Array.isArray(object.devices)) - throw TypeError(".DevData.devices: array expected"); - message.devices = []; - for (let i = 0; i < object.devices.length; ++i) { - if (typeof object.devices[i] !== "object") - throw TypeError(".DevData.devices: object expected"); - message.devices[i] = $root.Device.fromObject(object.devices[i]); - } - } - return message; - }; - - /** - * Creates a plain object from a DevData message. Also converts values to other types if specified. - * @function toObject - * @memberof DevData - * @static - * @param {DevData} message DevData - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - DevData.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.arrays || options.defaults) - object.devices = []; - if (message.devices && message.devices.length) { - object.devices = []; - for (let j = 0; j < message.devices.length; ++j) - object.devices[j] = $root.Device.toObject(message.devices[j], options); - } - return object; - }; - - /** - * Converts this DevData to JSON. - * @function toJSON - * @memberof DevData - * @instance - * @returns {Object.} JSON object - */ - DevData.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return DevData; -})(); - -export const Input = $root.Input = (() => { - - /** - * Properties of an Input. - * @exports IInput - * @interface IInput - * @property {boolean|null} [connected] Input connected - * @property {number|Long|null} [buttons] Input buttons - * @property {Array.|null} [axes] Input axes - * @property {Source|null} [source] Input source - */ - - /** - * Constructs a new Input. - * @exports Input - * @classdesc Represents an Input. - * @implements IInput - * @constructor - * @param {IInput=} [properties] Properties to set - */ - function Input(properties) { - this.axes = []; - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * Input connected. - * @member {boolean} connected - * @memberof Input - * @instance - */ - Input.prototype.connected = false; - - /** - * Input buttons. - * @member {number|Long} buttons - * @memberof Input - * @instance - */ - Input.prototype.buttons = $util.Long ? $util.Long.fromBits(0,0,false) : 0; - - /** - * Input axes. - * @member {Array.} axes - * @memberof Input - * @instance - */ - Input.prototype.axes = $util.emptyArray; - - /** - * Input source. - * @member {Source} source - * @memberof Input - * @instance - */ - Input.prototype.source = 0; - - /** - * Creates a new Input instance using the specified properties. - * @function create - * @memberof Input - * @static - * @param {IInput=} [properties] Properties to set - * @returns {Input} Input instance - */ - Input.create = function create(properties) { - return new Input(properties); - }; - - /** - * Encodes the specified Input message. Does not implicitly {@link Input.verify|verify} messages. - * @function encode - * @memberof Input - * @static - * @param {IInput} message Input message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Input.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.connected != null && Object.hasOwnProperty.call(message, "connected")) - writer.uint32(/* id 1, wireType 0 =*/8).bool(message.connected); - if (message.buttons != null && Object.hasOwnProperty.call(message, "buttons")) - writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.buttons); - if (message.axes != null && message.axes.length) { - writer.uint32(/* id 3, wireType 2 =*/26).fork(); - for (let i = 0; i < message.axes.length; ++i) - writer.float(message.axes[i]); - writer.ldelim(); - } - if (message.source != null && Object.hasOwnProperty.call(message, "source")) - writer.uint32(/* id 4, wireType 0 =*/32).int32(message.source); - return writer; - }; - - /** - * Encodes the specified Input message, length delimited. Does not implicitly {@link Input.verify|verify} messages. - * @function encodeDelimited - * @memberof Input - * @static - * @param {IInput} message Input message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Input.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes an Input message from the specified reader or buffer. - * @function decode - * @memberof Input - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {Input} Input - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Input.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Input(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.connected = reader.bool(); - break; - case 2: - message.buttons = reader.fixed64(); - break; - case 3: - if (!(message.axes && message.axes.length)) - message.axes = []; - if ((tag & 7) === 2) { - let end2 = reader.uint32() + reader.pos; - while (reader.pos < end2) - message.axes.push(reader.float()); - } else - message.axes.push(reader.float()); - break; - case 4: - message.source = reader.int32(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes an Input message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof Input - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {Input} Input - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Input.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies an Input message. - * @function verify - * @memberof Input - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - Input.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.connected != null && message.hasOwnProperty("connected")) - if (typeof message.connected !== "boolean") - return "connected: boolean expected"; - if (message.buttons != null && message.hasOwnProperty("buttons")) - if (!$util.isInteger(message.buttons) && !(message.buttons && $util.isInteger(message.buttons.low) && $util.isInteger(message.buttons.high))) - return "buttons: integer|Long expected"; - if (message.axes != null && message.hasOwnProperty("axes")) { - if (!Array.isArray(message.axes)) - return "axes: array expected"; - for (let i = 0; i < message.axes.length; ++i) - if (typeof message.axes[i] !== "number") - return "axes: number[] expected"; - } - if (message.source != null && message.hasOwnProperty("source")) - switch (message.source) { - default: - return "source: enum value expected"; - case 0: - case 1: - break; - } - return null; - }; - - /** - * Creates an Input message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof Input - * @static - * @param {Object.} object Plain object - * @returns {Input} Input - */ - Input.fromObject = function fromObject(object) { - if (object instanceof $root.Input) - return object; - let message = new $root.Input(); - if (object.connected != null) - message.connected = Boolean(object.connected); - if (object.buttons != null) - if ($util.Long) - (message.buttons = $util.Long.fromValue(object.buttons)).unsigned = false; - else if (typeof object.buttons === "string") - message.buttons = parseInt(object.buttons, 10); - else if (typeof object.buttons === "number") - message.buttons = object.buttons; - else if (typeof object.buttons === "object") - message.buttons = new $util.LongBits(object.buttons.low >>> 0, object.buttons.high >>> 0).toNumber(); - if (object.axes) { - if (!Array.isArray(object.axes)) - throw TypeError(".Input.axes: array expected"); - message.axes = []; - for (let i = 0; i < object.axes.length; ++i) - message.axes[i] = Number(object.axes[i]); - } - switch (object.source) { - case "GAMEPAD": - case 0: - message.source = 0; - break; - case "KEYBOARD": - case 1: - message.source = 1; - break; - } - return message; - }; - - /** - * Creates a plain object from an Input message. Also converts values to other types if specified. - * @function toObject - * @memberof Input - * @static - * @param {Input} message Input - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - Input.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.arrays || options.defaults) - object.axes = []; - if (options.defaults) { - object.connected = false; - if ($util.Long) { - let long = new $util.Long(0, 0, false); - object.buttons = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; - } else - object.buttons = options.longs === String ? "0" : 0; - object.source = options.enums === String ? "GAMEPAD" : 0; - } - if (message.connected != null && message.hasOwnProperty("connected")) - object.connected = message.connected; - if (message.buttons != null && message.hasOwnProperty("buttons")) - if (typeof message.buttons === "number") - object.buttons = options.longs === String ? String(message.buttons) : message.buttons; - else - object.buttons = options.longs === String ? $util.Long.prototype.toString.call(message.buttons) : options.longs === Number ? new $util.LongBits(message.buttons.low >>> 0, message.buttons.high >>> 0).toNumber() : message.buttons; - if (message.axes && message.axes.length) { - object.axes = []; - for (let j = 0; j < message.axes.length; ++j) - object.axes[j] = options.json && !isFinite(message.axes[j]) ? String(message.axes[j]) : message.axes[j]; - } - if (message.source != null && message.hasOwnProperty("source")) - object.source = options.enums === String ? $root.Source[message.source] : message.source; - return object; - }; - - /** - * Converts this Input to JSON. - * @function toJSON - * @memberof Input - * @instance - * @returns {Object.} JSON object - */ - Input.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return Input; -})(); - -export const UserInputs = $root.UserInputs = (() => { - - /** - * Properties of a UserInputs. - * @exports IUserInputs - * @interface IUserInputs - * @property {Array.|null} [inputs] UserInputs inputs - */ - - /** - * Constructs a new UserInputs. - * @exports UserInputs - * @classdesc Represents a UserInputs. - * @implements IUserInputs - * @constructor - * @param {IUserInputs=} [properties] Properties to set - */ - function UserInputs(properties) { - this.inputs = []; - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * UserInputs inputs. - * @member {Array.} inputs - * @memberof UserInputs - * @instance - */ - UserInputs.prototype.inputs = $util.emptyArray; - - /** - * Creates a new UserInputs instance using the specified properties. - * @function create - * @memberof UserInputs - * @static - * @param {IUserInputs=} [properties] Properties to set - * @returns {UserInputs} UserInputs instance - */ - UserInputs.create = function create(properties) { - return new UserInputs(properties); - }; - - /** - * Encodes the specified UserInputs message. Does not implicitly {@link UserInputs.verify|verify} messages. - * @function encode - * @memberof UserInputs - * @static - * @param {IUserInputs} message UserInputs message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - UserInputs.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.inputs != null && message.inputs.length) - for (let i = 0; i < message.inputs.length; ++i) - $root.Input.encode(message.inputs[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); - return writer; - }; - - /** - * Encodes the specified UserInputs message, length delimited. Does not implicitly {@link UserInputs.verify|verify} messages. - * @function encodeDelimited - * @memberof UserInputs - * @static - * @param {IUserInputs} message UserInputs message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - UserInputs.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a UserInputs message from the specified reader or buffer. - * @function decode - * @memberof UserInputs - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {UserInputs} UserInputs - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - UserInputs.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.UserInputs(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - if (!(message.inputs && message.inputs.length)) - message.inputs = []; - message.inputs.push($root.Input.decode(reader, reader.uint32())); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a UserInputs message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof UserInputs - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {UserInputs} UserInputs - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - UserInputs.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a UserInputs message. - * @function verify - * @memberof UserInputs - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - UserInputs.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.inputs != null && message.hasOwnProperty("inputs")) { - if (!Array.isArray(message.inputs)) - return "inputs: array expected"; - for (let i = 0; i < message.inputs.length; ++i) { - let error = $root.Input.verify(message.inputs[i]); - if (error) - return "inputs." + error; - } - } - return null; - }; - - /** - * Creates a UserInputs message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof UserInputs - * @static - * @param {Object.} object Plain object - * @returns {UserInputs} UserInputs - */ - UserInputs.fromObject = function fromObject(object) { - if (object instanceof $root.UserInputs) - return object; - let message = new $root.UserInputs(); - if (object.inputs) { - if (!Array.isArray(object.inputs)) - throw TypeError(".UserInputs.inputs: array expected"); - message.inputs = []; - for (let i = 0; i < object.inputs.length; ++i) { - if (typeof object.inputs[i] !== "object") - throw TypeError(".UserInputs.inputs: object expected"); - message.inputs[i] = $root.Input.fromObject(object.inputs[i]); - } - } - return message; - }; - - /** - * Creates a plain object from a UserInputs message. Also converts values to other types if specified. - * @function toObject - * @memberof UserInputs - * @static - * @param {UserInputs} message UserInputs - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - UserInputs.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.arrays || options.defaults) - object.inputs = []; - if (message.inputs && message.inputs.length) { - object.inputs = []; - for (let j = 0; j < message.inputs.length; ++j) - object.inputs[j] = $root.Input.toObject(message.inputs[j], options); - } - return object; - }; - - /** - * Converts this UserInputs to JSON. - * @function toJSON - * @memberof UserInputs - * @instance - * @returns {Object.} JSON object - */ - UserInputs.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return UserInputs; -})(); - -/** - * Source enum. - * @exports Source - * @enum {number} - * @property {number} GAMEPAD=0 GAMEPAD value - * @property {number} KEYBOARD=1 KEYBOARD value - */ -export const Source = $root.Source = (() => { - const valuesById = {}, values = Object.create(valuesById); - values[valuesById[0] = "GAMEPAD"] = 0; - values[valuesById[1] = "KEYBOARD"] = 1; - return values; -})(); - -/** - * Mode enum. - * @exports Mode - * @enum {number} - * @property {number} IDLE=0 IDLE value - * @property {number} AUTO=1 AUTO value - * @property {number} TELEOP=2 TELEOP value - * @property {number} ESTOP=3 ESTOP value - * @property {number} CHALLENGE=4 CHALLENGE value - */ -export const Mode = $root.Mode = (() => { - const valuesById = {}, values = Object.create(valuesById); - values[valuesById[0] = "IDLE"] = 0; - values[valuesById[1] = "AUTO"] = 1; - values[valuesById[2] = "TELEOP"] = 2; - values[valuesById[3] = "ESTOP"] = 3; - values[valuesById[4] = "CHALLENGE"] = 4; - return values; -})(); - -export const RunMode = $root.RunMode = (() => { - - /** - * Properties of a RunMode. - * @exports IRunMode - * @interface IRunMode - * @property {Mode|null} [mode] RunMode mode - */ - - /** - * Constructs a new RunMode. - * @exports RunMode - * @classdesc Represents a RunMode. - * @implements IRunMode - * @constructor - * @param {IRunMode=} [properties] Properties to set - */ - function RunMode(properties) { - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * RunMode mode. - * @member {Mode} mode - * @memberof RunMode - * @instance - */ - RunMode.prototype.mode = 0; - - /** - * Creates a new RunMode instance using the specified properties. - * @function create - * @memberof RunMode - * @static - * @param {IRunMode=} [properties] Properties to set - * @returns {RunMode} RunMode instance - */ - RunMode.create = function create(properties) { - return new RunMode(properties); - }; - - /** - * Encodes the specified RunMode message. Does not implicitly {@link RunMode.verify|verify} messages. - * @function encode - * @memberof RunMode - * @static - * @param {IRunMode} message RunMode message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - RunMode.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.mode != null && Object.hasOwnProperty.call(message, "mode")) - writer.uint32(/* id 1, wireType 0 =*/8).int32(message.mode); - return writer; - }; - - /** - * Encodes the specified RunMode message, length delimited. Does not implicitly {@link RunMode.verify|verify} messages. - * @function encodeDelimited - * @memberof RunMode - * @static - * @param {IRunMode} message RunMode message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - RunMode.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a RunMode message from the specified reader or buffer. - * @function decode - * @memberof RunMode - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {RunMode} RunMode - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - RunMode.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.RunMode(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.mode = reader.int32(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a RunMode message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof RunMode - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {RunMode} RunMode - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - RunMode.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a RunMode message. - * @function verify - * @memberof RunMode - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - RunMode.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.mode != null && message.hasOwnProperty("mode")) - switch (message.mode) { - default: - return "mode: enum value expected"; - case 0: - case 1: - case 2: - case 3: - case 4: - break; - } - return null; - }; - - /** - * Creates a RunMode message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof RunMode - * @static - * @param {Object.} object Plain object - * @returns {RunMode} RunMode - */ - RunMode.fromObject = function fromObject(object) { - if (object instanceof $root.RunMode) - return object; - let message = new $root.RunMode(); - switch (object.mode) { - case "IDLE": - case 0: - message.mode = 0; - break; - case "AUTO": - case 1: - message.mode = 1; - break; - case "TELEOP": - case 2: - message.mode = 2; - break; - case "ESTOP": - case 3: - message.mode = 3; - break; - case "CHALLENGE": - case 4: - message.mode = 4; - break; - } - return message; - }; - - /** - * Creates a plain object from a RunMode message. Also converts values to other types if specified. - * @function toObject - * @memberof RunMode - * @static - * @param {RunMode} message RunMode - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - RunMode.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.defaults) - object.mode = options.enums === String ? "IDLE" : 0; - if (message.mode != null && message.hasOwnProperty("mode")) - object.mode = options.enums === String ? $root.Mode[message.mode] : message.mode; - return object; - }; - - /** - * Converts this RunMode to JSON. - * @function toJSON - * @memberof RunMode - * @instance - * @returns {Object.} JSON object - */ - RunMode.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return RunMode; -})(); - -/** - * Pos enum. - * @exports Pos - * @enum {number} - * @property {number} LEFT=0 LEFT value - * @property {number} RIGHT=1 RIGHT value - */ -export const Pos = $root.Pos = (() => { - const valuesById = {}, values = Object.create(valuesById); - values[valuesById[0] = "LEFT"] = 0; - values[valuesById[1] = "RIGHT"] = 1; - return values; -})(); - -export const StartPos = $root.StartPos = (() => { - - /** - * Properties of a StartPos. - * @exports IStartPos - * @interface IStartPos - * @property {Pos|null} [pos] StartPos pos - */ - - /** - * Constructs a new StartPos. - * @exports StartPos - * @classdesc Represents a StartPos. - * @implements IStartPos - * @constructor - * @param {IStartPos=} [properties] Properties to set - */ - function StartPos(properties) { - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * StartPos pos. - * @member {Pos} pos - * @memberof StartPos - * @instance - */ - StartPos.prototype.pos = 0; - - /** - * Creates a new StartPos instance using the specified properties. - * @function create - * @memberof StartPos - * @static - * @param {IStartPos=} [properties] Properties to set - * @returns {StartPos} StartPos instance - */ - StartPos.create = function create(properties) { - return new StartPos(properties); - }; - - /** - * Encodes the specified StartPos message. Does not implicitly {@link StartPos.verify|verify} messages. - * @function encode - * @memberof StartPos - * @static - * @param {IStartPos} message StartPos message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - StartPos.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.pos != null && Object.hasOwnProperty.call(message, "pos")) - writer.uint32(/* id 1, wireType 0 =*/8).int32(message.pos); - return writer; - }; - - /** - * Encodes the specified StartPos message, length delimited. Does not implicitly {@link StartPos.verify|verify} messages. - * @function encodeDelimited - * @memberof StartPos - * @static - * @param {IStartPos} message StartPos message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - StartPos.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a StartPos message from the specified reader or buffer. - * @function decode - * @memberof StartPos - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {StartPos} StartPos - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - StartPos.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.StartPos(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.pos = reader.int32(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a StartPos message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof StartPos - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {StartPos} StartPos - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - StartPos.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a StartPos message. - * @function verify - * @memberof StartPos - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - StartPos.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.pos != null && message.hasOwnProperty("pos")) - switch (message.pos) { - default: - return "pos: enum value expected"; - case 0: - case 1: - break; - } - return null; - }; - - /** - * Creates a StartPos message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof StartPos - * @static - * @param {Object.} object Plain object - * @returns {StartPos} StartPos - */ - StartPos.fromObject = function fromObject(object) { - if (object instanceof $root.StartPos) - return object; - let message = new $root.StartPos(); - switch (object.pos) { - case "LEFT": - case 0: - message.pos = 0; - break; - case "RIGHT": - case 1: - message.pos = 1; - break; - } - return message; - }; - - /** - * Creates a plain object from a StartPos message. Also converts values to other types if specified. - * @function toObject - * @memberof StartPos - * @static - * @param {StartPos} message StartPos - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - StartPos.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.defaults) - object.pos = options.enums === String ? "LEFT" : 0; - if (message.pos != null && message.hasOwnProperty("pos")) - object.pos = options.enums === String ? $root.Pos[message.pos] : message.pos; - return object; - }; - - /** - * Converts this StartPos to JSON. - * @function toJSON - * @memberof StartPos - * @instance - * @returns {Object.} JSON object - */ - StartPos.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return StartPos; -})(); - -export const Text = $root.Text = (() => { - - /** - * Properties of a Text. - * @exports IText - * @interface IText - * @property {Array.|null} [payload] Text payload - */ - - /** - * Constructs a new Text. - * @exports Text - * @classdesc Represents a Text. - * @implements IText - * @constructor - * @param {IText=} [properties] Properties to set - */ - function Text(properties) { - this.payload = []; - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * Text payload. - * @member {Array.} payload - * @memberof Text - * @instance - */ - Text.prototype.payload = $util.emptyArray; - - /** - * Creates a new Text instance using the specified properties. - * @function create - * @memberof Text - * @static - * @param {IText=} [properties] Properties to set - * @returns {Text} Text instance - */ - Text.create = function create(properties) { - return new Text(properties); - }; - - /** - * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages. - * @function encode - * @memberof Text - * @static - * @param {IText} message Text message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Text.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.payload != null && message.payload.length) - for (let i = 0; i < message.payload.length; ++i) - writer.uint32(/* id 1, wireType 2 =*/10).string(message.payload[i]); - return writer; - }; - - /** - * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages. - * @function encodeDelimited - * @memberof Text - * @static - * @param {IText} message Text message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - Text.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a Text message from the specified reader or buffer. - * @function decode - * @memberof Text - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {Text} Text - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Text.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Text(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - if (!(message.payload && message.payload.length)) - message.payload = []; - message.payload.push(reader.string()); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a Text message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof Text - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {Text} Text - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - Text.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a Text message. - * @function verify - * @memberof Text - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - Text.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.payload != null && message.hasOwnProperty("payload")) { - if (!Array.isArray(message.payload)) - return "payload: array expected"; - for (let i = 0; i < message.payload.length; ++i) - if (!$util.isString(message.payload[i])) - return "payload: string[] expected"; - } - return null; - }; - - /** - * Creates a Text message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof Text - * @static - * @param {Object.} object Plain object - * @returns {Text} Text - */ - Text.fromObject = function fromObject(object) { - if (object instanceof $root.Text) - return object; - let message = new $root.Text(); - if (object.payload) { - if (!Array.isArray(object.payload)) - throw TypeError(".Text.payload: array expected"); - message.payload = []; - for (let i = 0; i < object.payload.length; ++i) - message.payload[i] = String(object.payload[i]); - } - return message; - }; - - /** - * Creates a plain object from a Text message. Also converts values to other types if specified. - * @function toObject - * @memberof Text - * @static - * @param {Text} message Text - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - Text.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.arrays || options.defaults) - object.payload = []; - if (message.payload && message.payload.length) { - object.payload = []; - for (let j = 0; j < message.payload.length; ++j) - object.payload[j] = message.payload[j]; - } - return object; - }; - - /** - * Converts this Text to JSON. - * @function toJSON - * @memberof Text - * @instance - * @returns {Object.} JSON object - */ - Text.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return Text; -})(); - -export const TimeStamps = $root.TimeStamps = (() => { - - /** - * Properties of a TimeStamps. - * @exports ITimeStamps - * @interface ITimeStamps - * @property {number|Long|null} [dawnTimestamp] TimeStamps dawnTimestamp - * @property {number|Long|null} [runtimeTimestamp] TimeStamps runtimeTimestamp - */ - - /** - * Constructs a new TimeStamps. - * @exports TimeStamps - * @classdesc Represents a TimeStamps. - * @implements ITimeStamps - * @constructor - * @param {ITimeStamps=} [properties] Properties to set - */ - function TimeStamps(properties) { - if (properties) - for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) - this[keys[i]] = properties[keys[i]]; - } - - /** - * TimeStamps dawnTimestamp. - * @member {number|Long} dawnTimestamp - * @memberof TimeStamps - * @instance - */ - TimeStamps.prototype.dawnTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0; - - /** - * TimeStamps runtimeTimestamp. - * @member {number|Long} runtimeTimestamp - * @memberof TimeStamps - * @instance - */ - TimeStamps.prototype.runtimeTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0; - - /** - * Creates a new TimeStamps instance using the specified properties. - * @function create - * @memberof TimeStamps - * @static - * @param {ITimeStamps=} [properties] Properties to set - * @returns {TimeStamps} TimeStamps instance - */ - TimeStamps.create = function create(properties) { - return new TimeStamps(properties); - }; - - /** - * Encodes the specified TimeStamps message. Does not implicitly {@link TimeStamps.verify|verify} messages. - * @function encode - * @memberof TimeStamps - * @static - * @param {ITimeStamps} message TimeStamps message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - TimeStamps.encode = function encode(message, writer) { - if (!writer) - writer = $Writer.create(); - if (message.dawnTimestamp != null && Object.hasOwnProperty.call(message, "dawnTimestamp")) - writer.uint32(/* id 1, wireType 1 =*/9).fixed64(message.dawnTimestamp); - if (message.runtimeTimestamp != null && Object.hasOwnProperty.call(message, "runtimeTimestamp")) - writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.runtimeTimestamp); - return writer; - }; - - /** - * Encodes the specified TimeStamps message, length delimited. Does not implicitly {@link TimeStamps.verify|verify} messages. - * @function encodeDelimited - * @memberof TimeStamps - * @static - * @param {ITimeStamps} message TimeStamps message or plain object to encode - * @param {$protobuf.Writer} [writer] Writer to encode to - * @returns {$protobuf.Writer} Writer - */ - TimeStamps.encodeDelimited = function encodeDelimited(message, writer) { - return this.encode(message, writer).ldelim(); - }; - - /** - * Decodes a TimeStamps message from the specified reader or buffer. - * @function decode - * @memberof TimeStamps - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @param {number} [length] Message length if known beforehand - * @returns {TimeStamps} TimeStamps - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - TimeStamps.decode = function decode(reader, length) { - if (!(reader instanceof $Reader)) - reader = $Reader.create(reader); - let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TimeStamps(); - while (reader.pos < end) { - let tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.dawnTimestamp = reader.fixed64(); - break; - case 2: - message.runtimeTimestamp = reader.fixed64(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }; - - /** - * Decodes a TimeStamps message from the specified reader or buffer, length delimited. - * @function decodeDelimited - * @memberof TimeStamps - * @static - * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from - * @returns {TimeStamps} TimeStamps - * @throws {Error} If the payload is not a reader or valid buffer - * @throws {$protobuf.util.ProtocolError} If required fields are missing - */ - TimeStamps.decodeDelimited = function decodeDelimited(reader) { - if (!(reader instanceof $Reader)) - reader = new $Reader(reader); - return this.decode(reader, reader.uint32()); - }; - - /** - * Verifies a TimeStamps message. - * @function verify - * @memberof TimeStamps - * @static - * @param {Object.} message Plain object to verify - * @returns {string|null} `null` if valid, otherwise the reason why it is not - */ - TimeStamps.verify = function verify(message) { - if (typeof message !== "object" || message === null) - return "object expected"; - if (message.dawnTimestamp != null && message.hasOwnProperty("dawnTimestamp")) - if (!$util.isInteger(message.dawnTimestamp) && !(message.dawnTimestamp && $util.isInteger(message.dawnTimestamp.low) && $util.isInteger(message.dawnTimestamp.high))) - return "dawnTimestamp: integer|Long expected"; - if (message.runtimeTimestamp != null && message.hasOwnProperty("runtimeTimestamp")) - if (!$util.isInteger(message.runtimeTimestamp) && !(message.runtimeTimestamp && $util.isInteger(message.runtimeTimestamp.low) && $util.isInteger(message.runtimeTimestamp.high))) - return "runtimeTimestamp: integer|Long expected"; - return null; - }; - - /** - * Creates a TimeStamps message from a plain object. Also converts values to their respective internal types. - * @function fromObject - * @memberof TimeStamps - * @static - * @param {Object.} object Plain object - * @returns {TimeStamps} TimeStamps - */ - TimeStamps.fromObject = function fromObject(object) { - if (object instanceof $root.TimeStamps) - return object; - let message = new $root.TimeStamps(); - if (object.dawnTimestamp != null) - if ($util.Long) - (message.dawnTimestamp = $util.Long.fromValue(object.dawnTimestamp)).unsigned = false; - else if (typeof object.dawnTimestamp === "string") - message.dawnTimestamp = parseInt(object.dawnTimestamp, 10); - else if (typeof object.dawnTimestamp === "number") - message.dawnTimestamp = object.dawnTimestamp; - else if (typeof object.dawnTimestamp === "object") - message.dawnTimestamp = new $util.LongBits(object.dawnTimestamp.low >>> 0, object.dawnTimestamp.high >>> 0).toNumber(); - if (object.runtimeTimestamp != null) - if ($util.Long) - (message.runtimeTimestamp = $util.Long.fromValue(object.runtimeTimestamp)).unsigned = false; - else if (typeof object.runtimeTimestamp === "string") - message.runtimeTimestamp = parseInt(object.runtimeTimestamp, 10); - else if (typeof object.runtimeTimestamp === "number") - message.runtimeTimestamp = object.runtimeTimestamp; - else if (typeof object.runtimeTimestamp === "object") - message.runtimeTimestamp = new $util.LongBits(object.runtimeTimestamp.low >>> 0, object.runtimeTimestamp.high >>> 0).toNumber(); - return message; - }; - - /** - * Creates a plain object from a TimeStamps message. Also converts values to other types if specified. - * @function toObject - * @memberof TimeStamps - * @static - * @param {TimeStamps} message TimeStamps - * @param {$protobuf.IConversionOptions} [options] Conversion options - * @returns {Object.} Plain object - */ - TimeStamps.toObject = function toObject(message, options) { - if (!options) - options = {}; - let object = {}; - if (options.defaults) { - if ($util.Long) { - let long = new $util.Long(0, 0, false); - object.dawnTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; - } else - object.dawnTimestamp = options.longs === String ? "0" : 0; - if ($util.Long) { - let long = new $util.Long(0, 0, false); - object.runtimeTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; - } else - object.runtimeTimestamp = options.longs === String ? "0" : 0; - } - if (message.dawnTimestamp != null && message.hasOwnProperty("dawnTimestamp")) - if (typeof message.dawnTimestamp === "number") - object.dawnTimestamp = options.longs === String ? String(message.dawnTimestamp) : message.dawnTimestamp; - else - object.dawnTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.dawnTimestamp) : options.longs === Number ? new $util.LongBits(message.dawnTimestamp.low >>> 0, message.dawnTimestamp.high >>> 0).toNumber() : message.dawnTimestamp; - if (message.runtimeTimestamp != null && message.hasOwnProperty("runtimeTimestamp")) - if (typeof message.runtimeTimestamp === "number") - object.runtimeTimestamp = options.longs === String ? String(message.runtimeTimestamp) : message.runtimeTimestamp; - else - object.runtimeTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.runtimeTimestamp) : options.longs === Number ? new $util.LongBits(message.runtimeTimestamp.low >>> 0, message.runtimeTimestamp.high >>> 0).toNumber() : message.runtimeTimestamp; - return object; - }; - - /** - * Converts this TimeStamps to JSON. - * @function toJSON - * @memberof TimeStamps - * @instance - * @returns {Object.} JSON object - */ - TimeStamps.prototype.toJSON = function toJSON() { - return this.constructor.toObject(this, $protobuf.util.toJSONOptions); - }; - - return TimeStamps; -})(); - -export { $root as default }; From 2b7679286b4dbc5760bbff296d7d651168eb769c Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 9 Oct 2021 21:29:21 -0700 Subject: [PATCH 09/10] Add RuntimeConnection class - still need to fix being able to cancel default websocket connection --- src/connections/RuntimeConnection.ts | 607 ++++++++++++--------------- src/connections/index.ts | 1 + 2 files changed, 281 insertions(+), 327 deletions(-) create mode 100644 src/connections/index.ts diff --git a/src/connections/RuntimeConnection.ts b/src/connections/RuntimeConnection.ts index 5c745d1..fca2350 100644 --- a/src/connections/RuntimeConnection.ts +++ b/src/connections/RuntimeConnection.ts @@ -1,327 +1,280 @@ -export {}; -// import { Logger } from '../utils'; - -// /** -// * Define port constants, which must match with Runtime -// */ -// const DEFAULT_CONNECTION_PORT = 5000; - -// /** -// * Runtime IP Address used for TCP and UDP connections -// */ -// let runtimeIP = '192.168.0.0'; - -// /** -// * Define message ID constants, which must match with Runtime -// */ -// enum MsgType { -// RUN_MODE = 0, -// START_POS = 1, -// LOG = 2, -// DEVICE_DATA = 3, -// // 4 reserved for some Shepherd msg type -// INPUTS = 5, -// TIME_STAMPS = 6 -// } - -// interface TCPPacket { -// type: MsgType; -// length: number; -// payload: Buffer; -// } - -// /** Given a data buffer, read as many TCP Packets as possible. -// * If there are leftover bytes, return them so that they can be used in the next cycle of data. -// */ -// function readPackets(data: Buffer, previousLeftoverBytes?: Buffer): { leftoverBytes?: Buffer; processedTCPPackets: TCPPacket[] } { -// const HEADER_NUM_BYTES = 3; - -// const bytesToRead = Buffer.concat([previousLeftoverBytes ?? new Uint8Array(), data]); -// const processedTCPPackets: TCPPacket[] = []; - -// let leftoverBytes; -// let currentPos = 0; - -// while (currentPos < bytesToRead.length) { -// let header: Buffer; -// let msgType: number; -// let msgLength: number; -// let payload: Buffer; - -// if (currentPos + HEADER_NUM_BYTES <= bytesToRead.length) { -// // Have enough bytes to read in 3 byte header -// header = bytesToRead.slice(currentPos, currentPos + HEADER_NUM_BYTES); -// msgType = header[0]; -// msgLength = (header[2] << 8) | header[1]; -// } else { -// // Don't have enough bytes to read 3 byte header so we save the bytes for the next data cycle -// leftoverBytes = bytesToRead.slice(currentPos); - -// return { -// leftoverBytes, -// processedTCPPackets -// }; -// } - -// currentPos += HEADER_NUM_BYTES; - -// if (currentPos + msgLength <= bytesToRead.length) { -// // Have enough bytes to read entire payload from 1 TCP packet -// payload = bytesToRead.slice(currentPos, currentPos + msgLength); -// } else { -// // Don't have enough bytes to read entire payload -// leftoverBytes = bytesToRead.slice(currentPos); - -// return { -// // Note: Need to save header so we know how many bytes to read for this packet in the next data cycle -// leftoverBytes: Buffer.concat([header, leftoverBytes]), -// processedTCPPackets -// }; -// } - -// const newTCPPacket = { type: msgType, length: msgLength, payload }; -// processedTCPPackets.push(newTCPPacket); - -// currentPos += msgLength; -// } - -// return { -// leftoverBytes, -// processedTCPPackets -// }; -// } - -// /** -// * Create TCP packet header and prepend to -// * payload to send to Runtime. -// */ -// function createPacket(payload: unknown, messageType: MsgType): Buffer { -// let encodedPayload: Uint8Array; - -// switch (messageType) { -// case MsgType.DEVICE_DATA: -// encodedPayload = protos.DevData.encode(payload as protos.IDevData).finish(); -// break; -// case MsgType.RUN_MODE: -// encodedPayload = protos.RunMode.encode(payload as protos.IRunMode).finish(); -// break; -// case MsgType.START_POS: -// encodedPayload = protos.StartPos.encode(payload as protos.IStartPos).finish(); -// break; -// case MsgType.TIME_STAMPS: -// encodedPayload = protos.TimeStamps.encode(payload as protos.ITimeStamps).finish(); -// break; -// case MsgType.INPUTS: -// // Special case for 2021 competition where Input data is sent over tunneled TCP connection -// encodedPayload = protos.UserInputs.encode({ inputs: payload as protos.Input[] }).finish(); -// break; -// default: -// console.log('ERROR: trying to create TCP Packet with unknown message type'); -// encodedPayload = new Uint8Array(); -// break; -// } - -// const msgLength = Buffer.byteLength(encodedPayload); -// const msgLengthArr = new Uint8Array([msgLength & 0x00ff, msgLength & 0xff00]); // Assuming little-endian byte order, since runs on x64 -// const msgTypeArr = new Uint8Array([messageType]); - -// return Buffer.concat([msgTypeArr, msgLengthArr, encodedPayload], msgLength + 3); -// } - -// class RuntimeConnection { -// logger: Logger; -// socket: WebSocket; -// leftoverBytes: Buffer | undefined; - -// constructor(logger: Logger) { -// this.logger = logger; -// this.socket = new TCPSocket(); - -// // Connect to most recent IP -// setInterval(() => { -// if (!this.socket.connecting && this.socket.pending) { -// if (runtimeIP !== defaults.IPADDRESS) { -// let port = DEFAULT_TCP_PORT; -// let ip = runtimeIP; -// if (runtimeIP.includes(':')) { -// const split = runtimeIP.split(':'); -// ip = split[0]; -// port = Number(split[1]); -// } -// console.log(`RuntimeConnection: Trying to TCP connect to ${ip}:${port}`); -// this.socket.connect(port, ip); -// } -// } -// }, 1000); - -// this.socket.on('connect', () => { -// this.logger.log('Runtime connected'); -// this.socket.write(new Uint8Array([1])); // Runtime needs first byte to be 1 to recognize client as Dawn (instead of Shepherd) -// }); - -// this.socket.on('end', () => { -// // RendererBridge.reduxDispatch(runtimeDisconnect()); -// this.logger.log('Runtime disconnected'); -// }); - -// this.socket.on('error', (err: string) => { -// this.logger.log(err); -// }); - -// /** -// * Runtime TCP Message Handler. -// * TODO: Distinguish between challenge outputs and console logs -// * when using payload to update console -// */ -// this.socket.on('data', (data) => { -// const { leftoverBytes, processedTCPPackets } = readPackets(data, this.leftoverBytes); - -// for (const packet of processedTCPPackets) { -// let decoded; - -// switch (packet.type) { -// case MsgType.LOG: -// decoded = protos.Text.decode(packet.payload); -// RendererBridge.reduxDispatch(updateConsole(decoded.payload)); -// break; - -// case MsgType.TIME_STAMPS: -// decoded = protos.TimeStamps.decode(packet.payload); -// const oneWayLatency = (Date.now() - Number(decoded.dawnTimestamp)) / 2; - -// // TODO: we can probably do an average of n timestamps so the display doesn't change too frequently -// RendererBridge.reduxDispatch(setLatencyValue(oneWayLatency)); -// break; - -// case MsgType.DEVICE_DATA: -// try { -// RendererBridge.reduxDispatch(infoPerMessage()); -// const sensorData: protos.Device[] = protos.DevData.decode(packet.payload).devices; -// const peripherals: Peripheral[] = []; -// sensorData.forEach((device) => { -// if (device.type.toString() === '0') { -// device.type = 0; -// } -// peripherals.push({ ...device, uid: device.uid.toString() }); -// }); -// RendererBridge.reduxDispatch(updatePeripherals(peripherals)); -// } catch (err) { -// this.logger.log(err); -// } -// break; - -// default: -// this.logger.log(`Unsupported received message type: ${packet.type}`) -// } -// } - -// this.leftoverBytes = leftoverBytes; -// }); - -// /** -// * TCP Socket IPC Connections -// */ -// ipcMain.on('runModeUpdate', (event: IpcMainEvent, ...args: any[]) => this.whenConnectionEstablished(this.sendRunMode, event, ...args)); -// ipcMain.on('initiateLatencyCheck', (event: IpcMainEvent, ...args: any[]) => -// this.whenConnectionEstablished(this.initiateLatencyCheck, event, ...args) -// ); -// ipcMain.on('stateUpdate', (event: IpcMainEvent, ...args: any[]) => this.whenConnectionEstablished(this.sendInputs, event, ...args)); - -// ipcMain.on('ipAddress', this.ipAddressListener); -// } - -// whenConnectionEstablished = (cb: (event: IpcMainEvent, ...args: any[]) => void, event: IpcMainEvent, ...args: any[]) => { -// if (this.socket.pending) { -// return; -// } - -// return cb(event, ...args); -// }; - -// /** -// * Initiates latency check by sending first packet to Runtime -// */ -// initiateLatencyCheck = (_event: IpcMainEvent, data: protos.ITimeStamps) => { -// const message = createPacket(data, MsgType.TIME_STAMPS); -// this.socket.write(message, () => { -// this.logger.log(`Sent timestamp data to runtime: ${JSON.stringify(data)}`); -// }); -// }; - -// /** -// * IPC Connection with ConfigBox.ts' saveChanges() -// * Receives new IP Address to send messages to. -// */ -// ipAddressListener = (_event: IpcMainEvent, ipAddress: string) => { -// if (ipAddress != runtimeIP) { -// console.log(`RuntimeConnection - Switching IP from ${runtimeIP} to ${ipAddress}`); -// if (this.socket.connecting || !this.socket.pending) { -// this.socket.end(); -// } -// runtimeIP = ipAddress; -// } -// }; - -// // TODO: We can possibly combine below methods into single handler. - -// /** -// * IPC Connection with sagas.js' exportRunMode() -// * Receives new run mode to send to Runtime -// */ -// sendRunMode = (_event: IpcMainEvent, runModeData: protos.IRunMode) => { -// const message = createPacket(runModeData, MsgType.RUN_MODE); -// this.socket.write(message, () => { -// this.logger.log(`Run Mode message sent: ${JSON.stringify(runModeData)}`); -// }); -// }; - -// sendDevicePreferences = (_event: IpcMainEvent, deviceData: protos.IDevData) => { -// // TODO: Serialize uid from string -> Long type -// const message = createPacket(deviceData, MsgType.DEVICE_DATA); -// this.socket.write(message, () => { -// this.logger.log(`Device preferences sent: ${deviceData.toString()}`); -// }); -// }; - -// sendRobotStartPos = (_event: IpcMainEvent, startPosData: protos.IStartPos) => { -// // TODO: Get start pos from sagas -// const message = createPacket(startPosData, MsgType.START_POS); -// this.socket.write(message, () => { -// this.logger.log(`Start position sent: ${startPosData.toString()}`); -// }); -// }; - -// sendInputs = (_event: IpcMainEvent, data: protos.Input[], source: protos.Source) => { -// if (data.length === 0) { -// data.push( -// protos.Input.create({ -// connected: false, -// source -// }) -// ); -// } -// const message = createPacket(data, MsgType.INPUTS); -// this.socket.write(message, () => { -// this.logger.log(`Inputs sent: ${JSON.stringify(data)}`); -// }); -// }; - -// close = () => { -// this.socket.end(); -// }; -// } - -// const RuntimeConnections: Array = []; - -// export const Runtime = { -// conns: RuntimeConnections, -// logger: new Logger('RuntimeConnection'), - -// setup() { -// this.conns = [new RuntimeConnection(this.logger)]; -// }, - -// close() { -// this.conns.forEach((conn) => conn.close()); // Logger's fs closes automatically -// } -// }; +import { Logger } from '../utils'; +import * as protos from '../main-protos/protos'; +import { Buffer } from 'buffer'; + +/** + * Define port constants, which must match with Runtime + */ +const DEFAULT_CONNECTION_PORT = 5000; + +/** + * Runtime IP Address used for TCP and UDP connections + */ +const DEFAULT_CONNECTION_IP = '192.168.0.0'; + +/** + * Define message ID constants, which must match with Runtime + */ +enum MsgType { + RUN_MODE = 0, + START_POS = 1, + LOG = 2, + DEVICE_DATA = 3, + // 4 reserved for some Shepherd msg type + INPUTS = 5, + TIME_STAMPS = 6 +} + +interface Packet { + type: MsgType; + length: number; + payload: Buffer; +} + +/** Given a data buffer, read as many TCP Packets as possible. + * If there are leftover bytes, return them so that they can be used in the next cycle of data. + */ +function readPackets(data: Buffer, previousLeftoverBytes?: Buffer): { leftoverBytes?: Buffer; processedTCPPackets: Packet[] } { + const HEADER_NUM_BYTES = 3; + + const bytesToRead = Buffer.concat([previousLeftoverBytes ?? new Uint8Array(), data]); + const processedTCPPackets: Packet[] = []; + + let leftoverBytes; + let currentPos = 0; + + while (currentPos < bytesToRead.length) { + let header: Buffer; + let msgType: number; + let msgLength: number; + let payload: Buffer; + + if (currentPos + HEADER_NUM_BYTES <= bytesToRead.length) { + // Have enough bytes to read in 3 byte header + header = bytesToRead.slice(currentPos, currentPos + HEADER_NUM_BYTES); + msgType = header[0]; + msgLength = (header[2] << 8) | header[1]; + } else { + // Don't have enough bytes to read 3 byte header so we save the bytes for the next data cycle + leftoverBytes = bytesToRead.slice(currentPos); + + return { + leftoverBytes, + processedTCPPackets + }; + } + + currentPos += HEADER_NUM_BYTES; + + if (currentPos + msgLength <= bytesToRead.length) { + // Have enough bytes to read entire payload from 1 TCP packet + payload = bytesToRead.slice(currentPos, currentPos + msgLength); + } else { + // Don't have enough bytes to read entire payload + leftoverBytes = bytesToRead.slice(currentPos); + + return { + // Note: Need to save header so we know how many bytes to read for this packet in the next data cycle + leftoverBytes: Buffer.concat([header, leftoverBytes]), + processedTCPPackets + }; + } + + const newTCPPacket = { type: msgType, length: msgLength, payload }; + processedTCPPackets.push(newTCPPacket); + + currentPos += msgLength; + } + + return { + leftoverBytes, + processedTCPPackets + }; +} + +/** + * Create TCP packet header and prepend to + * payload to send to Runtime. + */ +function createPacket(payload: unknown, messageType: MsgType): Buffer { + let encodedPayload: Uint8Array; + + switch (messageType) { + case MsgType.DEVICE_DATA: + encodedPayload = protos.DevData.encode(protos.DevData.create(payload as protos.IDevData)).finish(); + break; + case MsgType.RUN_MODE: + encodedPayload = protos.RunMode.encode(protos.RunMode.create(payload as protos.IRunMode)).finish(); + break; + case MsgType.START_POS: + encodedPayload = protos.StartPos.encode(protos.StartPos.create(payload as protos.IStartPos)).finish(); + break; + case MsgType.TIME_STAMPS: + encodedPayload = protos.TimeStamps.encode(protos.TimeStamps.create(payload as protos.ITimeStamps)).finish(); + break; + case MsgType.INPUTS: + encodedPayload = protos.UserInputs.encode( + protos.UserInputs.create({ inputs: payload as protos.Input[] } as protos.IUserInputs) + ).finish(); + break; + default: + console.log('ERROR: trying to create TCP Packet with unknown message type'); + encodedPayload = new Uint8Array(); + break; + } + + const msgLength = Buffer.byteLength(encodedPayload); + const msgLengthArr = new Uint8Array([msgLength & 0x00ff, msgLength & 0xff00]); // Assuming little-endian byte order, since runs on x64 + const msgTypeArr = new Uint8Array([messageType]); + + return Buffer.concat([Buffer.from(msgTypeArr.buffer), Buffer.from(msgLengthArr.buffer), Buffer.from(encodedPayload.buffer)], msgLength + 3); +} + +export class RuntimeConnection { + currentIp: string = DEFAULT_CONNECTION_IP; + loggerName: string = 'RuntimeConnection'; + logger: Logger = new Logger(this.loggerName); + socket: WebSocket | undefined; + leftoverBytes: Buffer | undefined; + isConnecting: boolean = false; + socketReady: boolean = false; + + constructor() { + this.tick(); + } + + private openNewConnection() { + this.isConnecting = true; + + const ip = this.currentIp; + + if (ip.includes(':')) { + // ip most likely already includes port, so no need to use `DEFAULT_CONNECTION_PORT` + this.socket = new WebSocket(`ws://${ip}`); + } else { + this.socket = new WebSocket(`ws://${ip}:${DEFAULT_CONNECTION_PORT}`); + } + + this.socket.addEventListener('open', () => { + this.logger.log('connected'); + this.socketReady = true; + this.socket!.send(new Uint8Array([1])); // Runtime needs first byte to be 1 to recognize client as Dawn (instead of Shepherd) + }); + + this.socket.addEventListener('end', () => { + this.logger.log('Runtime disconnected'); + }); + + this.socket.addEventListener('error', (ev: Event) => { + this.logger.log(`Encountered error -- ${ev}`); + }); + + /** + * Runtime TCP Message Handler. + * TODO: Distinguish between challenge outputs and console logs + * when using payload to update console + */ + this.socket.addEventListener('message', async (message: MessageEvent) => { + // this.logger.log('Received message'); + const dataArrayBuffer = await message.data.arrayBuffer(); + const { leftoverBytes, processedTCPPackets } = readPackets(Buffer.from(dataArrayBuffer), this.leftoverBytes); + + for (const packet of processedTCPPackets) { + let decoded; + + switch (packet.type) { + case MsgType.TIME_STAMPS: + decoded = protos.TimeStamps.decode(packet.payload); + const oneWayLatency = (Date.now() - Number(decoded.dawnTimestamp)) / 2; + this.logger.log(`${this.loggerName}: oneWayLatency -- ${oneWayLatency} msec`); + + // TODO: use `oneWayLatency` in UI + break; + + case MsgType.DEVICE_DATA: + try { + const sensorData: protos.Device[] = protos.DevData.decode(packet.payload).devices; + this.logger.log(`sensorData -- ${JSON.stringify(sensorData)}`) + } catch (err) { + this.logger.log(err); + } + break; + + default: + this.logger.log(`Unsupported received message type: ${packet.type}`) + } + } + + this.leftoverBytes = leftoverBytes; + }); + + this.isConnecting = false; + } + + private tick = () => { + console.log('socket connected', this.socketReady); + console.log('socket is connecting', this.isConnecting); + console.log('current ip', this.currentIp); + console.log('\n'); + + if (this.socket === undefined && !this.isConnecting) { + this.openNewConnection(); + } + + setTimeout(this.tick, 5000); + } + + public connect = (newIp: string) => { + if (newIp === this.currentIp) { + // Same ip, no need to reconnect + return; + } + + if (this.socketReady) { + this.logger.log(`Closed existing connection to connect to new ip: ${newIp}`); + // Close existing connected socket to open new connection with new ip + this.socket?.close(); + this.socket = undefined; + } + + this.currentIp = newIp; + this.openNewConnection(); + } + + /** + * Initiates latency check by sending first packet to Runtime + */ + public initiateLatencyCheck = (data: protos.ITimeStamps) => { + const message = createPacket(data, MsgType.TIME_STAMPS); + this.socket?.send(message); + }; + + public sendRunMode = (runModeData: protos.IRunMode) => { + if (!this.socketReady) { + return; + } + + const message = createPacket(runModeData, MsgType.RUN_MODE); + this.socket?.send(message); + this.logger.log(`Sent run mode data -- ${JSON.stringify(runModeData)}\n`); + }; + + public sendInputs = (data: protos.Input[], source: protos.Source) => { + if (data.length === 0) { + data.push( + protos.Input.create({ + connected: false, + source + }) + ); + } + const message = createPacket(data, MsgType.INPUTS); + this.socket?.send(message); + }; + + close = () => { + this.logger.log('Closed socket connection'); + this.socket?.close(); + this.socketReady = false; + }; +} diff --git a/src/connections/index.ts b/src/connections/index.ts new file mode 100644 index 0000000..77cc36b --- /dev/null +++ b/src/connections/index.ts @@ -0,0 +1 @@ +export { RuntimeConnection } from './RuntimeConnection'; From 2ac613961754d98f025cbf24173ab9ccdffde9c0 Mon Sep 17 00:00:00 2001 From: ewc340 Date: Sat, 9 Oct 2021 21:29:38 -0700 Subject: [PATCH 10/10] Add useRuntimeConnection hook and use in App --- src/App.tsx | 32 ++++++++++++++++++------------- src/hooks/index.ts | 1 + src/hooks/useRuntimeConnection.ts | 20 +++++++++++++++++++ src/utils/index.ts | 1 + src/utils/logger.ts | 11 +++++++++++ 5 files changed, 52 insertions(+), 13 deletions(-) create mode 100644 src/hooks/index.ts create mode 100644 src/hooks/useRuntimeConnection.ts create mode 100644 src/utils/index.ts create mode 100644 src/utils/logger.ts diff --git a/src/App.tsx b/src/App.tsx index 8124cb3..1323663 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -1,24 +1,30 @@ -import React from 'react'; -import logo from './logo.svg'; -import { io } from "socket.io-client"; +import React, { useEffect } from 'react'; // import {VideoFeed} from './video-feed/VideoFeed'; +import { useRuntimeConnection } from './hooks'; import './App.css'; export const App = () => { - const ws = new WebSocket('wss://127.0.0.1:8080'); - const socket = io('wss://127.0.0.1:8080'); //'http://localhost:8080'); - socket.on('connect', () => console.log('socket connected')); - // console.log('ready state', ws.readyState); + const runtimeConnection = useRuntimeConnection(); - ws.addEventListener('close', (ev: Event) => console.log('Connection closed', ev)); + useEffect(() => { + runtimeConnection.connect('127.0.0.1') + }, [runtimeConnection]); - ws.addEventListener('open', (ev: Event) => console.log('web socket open', ev)); + // const ws = new WebSocket('ws://127.0.0.1:5000'); - ws.addEventListener('message', (message: MessageEvent) => { - console.log('received data: %s', message.data); - }); + // ws.addEventListener('close', (ev: Event) => console.log('Connection closed', ev)); - ws.addEventListener('error', (ev: Event) => console.log('error', ev)); + // ws.onopen = ((ev: Event) => { + // console.log('web socket open', ev); + // ws.send(Buffer.from([1])); + // setInterval(() => ws.send('testing'), 1000); + // }); + + // ws.addEventListener('message', (message: MessageEvent) => { + // console.log('received data: %s', message.data.toString()); + // }); + + // ws.addEventListener('error', (ev: Event) => console.log('error', ev)); return (
diff --git a/src/hooks/index.ts b/src/hooks/index.ts new file mode 100644 index 0000000..85c5f63 --- /dev/null +++ b/src/hooks/index.ts @@ -0,0 +1 @@ +export { useRuntimeConnection } from './useRuntimeConnection'; diff --git a/src/hooks/useRuntimeConnection.ts b/src/hooks/useRuntimeConnection.ts new file mode 100644 index 0000000..e8833af --- /dev/null +++ b/src/hooks/useRuntimeConnection.ts @@ -0,0 +1,20 @@ +import { RuntimeConnection } from '../connections'; +import { useEffect, useState } from 'react'; + +export const useRuntimeConnection = () => { + const [runtimeConnection, _setRuntimeConnection] = useState(new RuntimeConnection()); + + useEffect(() => { + setInterval(() => runtimeConnection.sendRunMode({ mode: 2 }), 5000); + + return () => { + runtimeConnection.close(); + } + }, [runtimeConnection]); + + const connect = (newIp: string) => { + runtimeConnection.connect(newIp); + } + + return { connect }; +} \ No newline at end of file diff --git a/src/utils/index.ts b/src/utils/index.ts new file mode 100644 index 0000000..a1332e9 --- /dev/null +++ b/src/utils/index.ts @@ -0,0 +1 @@ +export { Logger } from './logger'; diff --git a/src/utils/logger.ts b/src/utils/logger.ts new file mode 100644 index 0000000..f5823c7 --- /dev/null +++ b/src/utils/logger.ts @@ -0,0 +1,11 @@ +export class Logger { + loggerName: string; + + constructor(loggerName: string) { + this.loggerName = loggerName; + } + + log = (message?: any, ...optionalParams: any[]) => { + console.log(`${this.loggerName}: ${message}`, ...optionalParams); + } +} \ No newline at end of file