mirror of
https://github.com/priyanshujain/sanderling.git
synced 2026-10-02 11:07:10 +00:00
* feat(trace): extend Step/Action/Meta schema for inspect UI
Add Step.Hierarchy, Step.Residuals, Action.Selector/ResolvedBounds/TapPoint,
Meta.EndedAt and JSON tags on hierarchy.Element/Bounds/Tree so trace.jsonl
can drive the upcoming uatu inspect web UI.
* test(trace): cover EndedAt + new step fields round-trip
* feat(ltl): MarshalJSON for Formula AST + Evaluator.Residual()
Each Formula concrete type now serializes to a closed-set residual node
(true/false/not/and/or/implies/always/now/next/eventually/predicate/error)
that mirrors the TS spec API surface. Evaluator.Residual() folds pending
obligations into a single Formula so the runner can stamp one residual
per property per step into trace.jsonl.
* feat(runner): stamp residuals, hierarchy, selector targets, ended_at
Each Step now carries the captured hierarchy, per-property residual ASTs,
and (for Tap/InputText) the selector + resolved bounds + tap point. The
test_run command writes meta.ended_at on graceful shutdown so the inspect
UI can distinguish completed runs from in-progress ones.
* feat(inspect): scaffold embed dist for SPA assets
Stage 2 stub for the inspect server. Real web bundle gets wired in
Stage 4 (Makefile copies web/dist into internal/inspect/dist).
* chore(web): ignore web/ build output in root .gitignore
* chore(web): add bun + vite + vitest scaffold config
* feat(web): monochrome design tokens, typography, app shell CSS
* chore(web): placeholder for self-hosted JetBrains Mono fonts
* feat(web): index.html entry with style links and root mount
* feat(web): typescript types mirroring run/step trace schema
* feat(web): typed fetchers for runs/steps/screenshots
* feat(web): App shell with router and run/step routes
* feat(inspect): runs scan, lazy step parse, mtime-aware cache
* feat(web): RunList route with table, loading, and error states
* feat(web): RunDetail route shell with three placeholder panels
* feat(inspect): fsnotify-backed runs watcher with debounce
* fix(web): use jest-dom/vitest entry so matchers register
* test(web): cover listRuns happy path and error response
* test(web): render RunList with mocked fetch and assert row
* chore(web): commit bun lockfile
* feat(inspect): http handlers for runs/steps/screenshots/SSE
* test(inspect): cover handlers, screenshot whitelist, SSE, dev proxy
* feat(cmd): add 'uatu inspect' subcommand
* fix(web): align TS types with snake_case wire format
Go inspect server serializes RunSummary, StepSummary, Step, Meta with
snake_case JSON tags (matching the on-disk trace.jsonl/meta.json). Update
the TS types and consumers to match so API responses parse without
runtime undefined fields. Action keeps resolvedBounds/tapPoint as camelCase
because those keys were defined that way in the trace schema.
* feat(web): add ActionList panel for run-detail step navigation
* feat(web): add SnapshotTable panel with diff highlighting
Renders snapshots dictionary as a flat sorted dotted-path tree.
Changed leaves get data-changed plus a hover title with the previous value.
* test(web): cover SnapshotTable rendering and diff behavior
Eight cases: empty state, sort order, dotted-path expansion,
changed/unchanged/missing-previous flagging, and inline-vs-expanded arrays.
* feat(web): add Screenshot panel with bounds and tap overlays
Center column of run-detail page. Renders the device screenshot
scaled to fit, with an SVG overlay drawing resolvedBounds as a
violation-colored rect, tapPoint as a contrast ring, and swipes
as an arrow. Falls back to a placeholder when src is missing or
the image fails to load.
* fix(web): guard scrollIntoView call for jsdom compatibility
* test(web): cover Screenshot panel rendering and overlays
* test(web): cover ActionList rendering, selection, keyboard, and markers
* feat(web): add ExceptionsPanel component
* test(web): add ExceptionsPanel tests
* feat(web): add Timeline panel with property swimlanes
Renders SVG swimlanes per property with violated/pending/holds cells,
action-marker dots, click-to-seek, and a selected-step highlight bar.
* test(web): cover Timeline empty state, cells, status, click, highlight
* feat(web): add ResidualNode recursive AST renderer
* test(web): cover ResidualNode operators, predicate, and error chip
* feat(web): add ViolationsPanel with status badges and jump button
* test(web): cover ViolationsPanel rows, status grouping, and jump button
* test(web): register testing-library cleanup globally
All six panel test files added local afterEach(cleanup); centralize it in
the shared setup so future tests inherit DOM isolation by default.
* feat(web): hooks for url/keyboard/theme/sse
* feat(web): wire all panels into run-detail with phone-dominant grid
ActionList left, Screenshot center, Snapshots/Properties/Exceptions
stacked right, Timeline bottom. URL-synced step index (useStep), keyboard
shortcuts (j/k/arrows/g/G/.), light+dark theme toggle stored in
localStorage, SSE auto-refresh on the run index.
* test(web): add three reference run fixtures (clean, violation, exception)
* build: web targets in Makefile + bun in CI; docs(inspect)
- Makefile: web-build/web-dev/inspect-dev/test-web targets; uatu and
install now depend on web-build so the binary embeds the latest SPA.
- ci.yml: setup-bun + cache; existing make test now runs web typecheck +
vitest as part of the full suite.
- docs/manual/inspect.md: panel reference, keyboard shortcuts, URLs.
- docs/manual/cli.md: document uatu inspect.
- README: link to inspect docs.
* feat(runner): capture a screenshot per step
The driver already exposes Screenshot(ctx), but the runner never called
it. Each step now writes <run>/screenshots/step-NNNNN.png right after
the trace line, using the same failure-is-a-warning posture as other
best-effort observability hooks. Makes the inspect UI's center panel
actually useful.
* feat(inspect): include action_label in StepSummary
Tap/InputText/Swipe/PressKey/Wait each get a short human-readable
label (selector, quoted text, swipe direction, key name, duration) so
the action list panel can render readable rows instead of just 'Tap'
with no target.
* test(inspect): accept either #app or #root in SPA shell fallback
* feat(web): render action_label and screen in ActionList rows
Step rows now show 'Tap id:save', 'InputText "alice"', 'Swipe up',
'PressKey back', etc. Steps with no action fall back to
'observe @ <screen>' so the list reads as a flow instead of a wall
of '--' placeholders.
* feat(sidecar): implement screencap for android driver backend
Was stubbed to return an empty byte array, which made the runner's
per-step screenshot capture a no-op. Shell out to 'adb exec-out
screencap -p' and stream the PNG bytes back. Width/height stay zero
because the PNG header carries them; the Go side can parse if needed.
* feat(proto): add Metrics RPC for per-step CPU and memory capture
* feat(driver): Metrics(bundleID) returns cpu_percent + heap/total bytes
* feat(sidecar): implement Metrics RPC via adb top + /proc/<pid>/status
* feat(runner): capture metrics + before/after screenshots per step
Each step now writes step-NNNNN.png (before applyAction) and
step-NNNNN-after.png (after the action + wait-for-idle). The runner
samples Driver.Metrics(bundleID) before writing the trace line and
stamps Step.Metrics with cpu_percent, heap_bytes, total_memory_bytes
so the inspect UI can chart CPU and heap over the run.
* fix(runner,sidecar): measure CPU across step via /proc stat delta
'top -d 0.3 -n 2' measures CPU in a 300ms window that coincides with
the SDK-paused app, always reporting 0%. Switch to reading
/proc/<pid>/stat utime+stime and computing the delta between successive
calls; the natural step cadence gives a 2-5s measurement window that
captures the action response and render cycle. Also moved the sample
to before snapshotStep so the delta starts before the SDK pause.
* feat(web): add Metrics type for per-step cpu and memory
* refactor(web): replace --accent-change with --accent-positive token
* refactor(web): recolor chip-progress as neutral outlined chip
* refactor(web): use neutral border for changed snapshot rows
* feat(web): add MetricsChart panel with HEAP and CPU lanes
SVG-based time-series chart rendering heap bytes and CPU percent per
step across two stacked lanes, with a shared step axis below. Lines are
monochrome; a vertical highlight marks the selected step; per-step hit
rects make any click seek to that step.
* feat(web): revamp ActionList with tag targets, elapsed time, and expandable rows
Render selector-based Tap actions as <tag/> markup, show zero-padded MM:SS.mmm
elapsed time per row, and expand the active row with Position/Content sub-rows
when a full Step is available. Adds formatActionRow/formatElapsed helpers and
covers both with unit tests.
* fix(runner): stop copying Tap selector into action.text
The 'Content' inspect row should show the user-supplied text for
InputText actions and stay empty for Taps. Previously the runner copied
action.On into traceAction.Text for both, so the inspect UI showed the
selector as the tap's 'Content'.
* fix(web): use text-muted for swipe arrow after accent-change removal
* fix(web): snapshot values truncate with ellipsis + title tooltip
Long JSON values were breaking one character per line due to
overflow-wrap:anywhere in a narrow column. Switch to single-line ellipsis
with the full value exposed via the title attribute on hover.
* feat(web): state-before/after columns + metrics chart at bottom
RunDetail now renders a four-column grid:
actions | state-before | state-after | side (exceptions + timeline)
with MetricsChart spanning the bottom row. Each state column shows its
own screenshot (step-NNNNN.png vs step-NNNNN-after.png), snapshot table,
and violations panel. ActionList now receives runStartMillis and the
selected Step so the active row can expand Position/Content sub-rows.
* fix(web): skip zero-value ticks + add exception markers to metrics
HEAP '0B' and CPU '100%' labels overlapped at the lane boundary. Drop
the bottom-of-range tick on both lanes (baseline is implied) and widen
LANE_GAP so the remaining labels have breathing room. Accept an
exceptionStepIndices prop and draw a dashed red vertical line at each
to surface exception spikes directly on the CPU/heap chart.
* fix(web): let action body column shrink below its content
Required minmax(0, 1fr) so the row grid honours the column's min-size of
0 instead of the implicit 'auto', preventing the action-list from
overflowing its parent when the target string is long.
* feat(web): bigger state screenshots + single properties row
Collapse snapshots into a summary chip ('SNAPSHOTS · N violations') so
the screenshot fills its state card. Deduplicate ViolationsPanel —
show it once in a new full-width 'properties' row between the state
cards and the timeline. Drop the right sidebar; exceptions now surface
as dashed markers on the metrics chart with the ExceptionsPanel only
rendering when there are actual exceptions to report.
* feat(web): add minimal Tabs component
Monochrome tab strip with underline-on-active. Used by state-before
and state-after cards to swap between Screenshot, Snapshots, Properties.
Pane scrolls internally so the outer grid stays fixed-height.
* feat(web): fold timeline into MetricsChart as STEPS lane
Adds a thin per-step status row above HEAP showing violated (red),
pending (dim gray) or holds (green-tinted). Extends highlight +
exception markers to span the status lane. Frees a whole row in the
detail grid so the page can fit in 100vh.
* refactor(web): tabbed state cards, drop standalone Timeline panel
State-before/after now use Tabs (Screenshot / Snapshots / Properties,
default Screenshot). Removes the dedicated timeline row; status lane
lives on the metrics chart. Banner is gone from the shell.
* feat(web): lock app shell to 100vh with no page scroll
html/body/#root fill the viewport, body gets overflow:hidden, and the
detail grid uses minmax(0, 1fr) rows so inner panels own their scroll.
Tightens toolbar + panel padding for a denser feel.
* feat(web): arrow-key nav + badges on Tabs (WAI-ARIA tablist)
Roving tabindex, ArrowLeft/Right/Up/Down/Home/End navigation, explicit
aria-selected/aria-controls/id wiring, and support for an optional
badge inside each tab (used for violation counts).
* feat(web): ViolationsPanel supports violationsOnly filter
* feat(web): ActionList arrow-key nav + listbox semantics + smaller font
Promote the list to role=listbox with role=option rows; roving tabindex
lets ArrowUp/Down (and Home/End) seek between steps with focus. Font
size dropped to 11px and padding tightened so long selector-tag labels
fit in the 340px actions column.
* fix(web): useKeyboardNav yields arrow keys to tablist/listbox targets
Previously pressing ArrowRight on a focused tab switched tabs AND
advanced the step. Skip arrow handling when the event target is inside
an element with an arrow-owning ARIA role.
* feat(web): fourth 'Violations' tab + wider actions + shorter metrics
Adds a Violations tab to each state card showing only violated properties
(with count badge on the tab label when > 0). Actions column widened
from 280px to 340px, bottom metrics strip trimmed from 220px to 140px
with tighter lane heights, so the whole page still fits in 100vh with
no scrollbar.
* feat(web): compact RunDetail layout using 1px borders instead of panel padding
* refactor(inspect): simplify MetricsChart to HEAP+CPU with time axis
Drop the STEPS status lane and per-sample circle markers, switch the
x-axis from step indices to mm:ss clock time, trim y-axis ticks to
min/max with compact units, rotate lane labels into the left gutter,
and replace the thin playhead line with a wider dotted red band.
Traces stay grayscale; red appears only on the playhead pattern.
* fix(web): RunList rows no longer stretch to fill viewport height
Tables inherited flex: 1 1 auto from .app-main > * and distributed extra
vertical space across rows. Override with flex: 0 0 auto + align-self.
* misc changes
* fix(web): hoist useState above early return in MetricsChart
Calling useState after an unconditional early return violates React's
Rules of Hooks: the empty-samples branch renders 0 hooks while the
populated branch calls 1. On the initial null->loaded transition of
history the hook count changes and React throws.
* fix(web): subscribe to named SSE event instead of 'message'
Server emits 'event: runs.changed' frames; the WHATWG EventSource spec
dispatches those as events of type 'runs.changed', not 'message'. The
listener registered on 'message' was never fired, so RunList never
auto-refreshed on run create/finish/delete.
* fix(inspect): unsubscribe SSE clients on disconnect
Watcher.Subscribe appended to a slice with no matching removal path,
so every closed EventSource connection leaked its channel. Over a
long-running server the slice grew unbounded and every fs event paid
O(N) iterating dead channels. Add Unsubscribe + defer it in
handleEvents.
Unsubscribe does not close the channel: broadcast snapshots the
slice without holding the mutex, so a concurrent close would race
with its non-blocking send.
* fix(trace): rename resolvedBounds/tapPoint to snake_case
Every other json tag in the trace schema (from_x, duration_millis,
bundle_sha256, etc.) uses snake_case. The two new Action fields
introduced with the inspect UI broke that pattern. Rename them
before the format ships to external consumers.
* chore(web): drop vitest and remove UI tests from CI
No UI tests wanted in web. Removes vitest, jsdom, testing-library
devDeps and the vitest.setup.ts + vite.config.ts test block.
Makefile test-web becomes web-typecheck (typecheck only).
Fixes CI failure where `vitest run` exits 1 with no test files.
* chore(make): dedupe sidecar embed and drop recursive make
Make $(SIDECAR_JAR) the real recipe and $(SIDECAR_EMBED) a file
target, so uatu/install/inspect-dev share one copy step and
sidecar/release-cli just depend on the jar instead of re-invoking make.
1013 lines
30 KiB
Go
1013 lines
30 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.11
|
|
// protoc (unknown)
|
|
// source: driverpb/driver.proto
|
|
|
|
package driverpb
|
|
|
|
import (
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
reflect "reflect"
|
|
sync "sync"
|
|
unsafe "unsafe"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
type Empty struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Empty) Reset() {
|
|
*x = Empty{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Empty) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Empty) ProtoMessage() {}
|
|
|
|
func (x *Empty) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
|
|
func (*Empty) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
type LaunchRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
BundleId string `protobuf:"bytes,1,opt,name=bundle_id,json=bundleId,proto3" json:"bundle_id,omitempty"`
|
|
ClearState bool `protobuf:"varint,2,opt,name=clear_state,json=clearState,proto3" json:"clear_state,omitempty"`
|
|
// Optional "<pkg>/<activity>" component to pass to `am start -n`. Needed
|
|
// when an app declares multiple MAIN+LAUNCHER activities where the first
|
|
// one reported by `pm dump` is an alias whose target class is disabled.
|
|
LauncherActivity string `protobuf:"bytes,3,opt,name=launcher_activity,json=launcherActivity,proto3" json:"launcher_activity,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LaunchRequest) Reset() {
|
|
*x = LaunchRequest{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LaunchRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LaunchRequest) ProtoMessage() {}
|
|
|
|
func (x *LaunchRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LaunchRequest.ProtoReflect.Descriptor instead.
|
|
func (*LaunchRequest) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *LaunchRequest) GetBundleId() string {
|
|
if x != nil {
|
|
return x.BundleId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LaunchRequest) GetClearState() bool {
|
|
if x != nil {
|
|
return x.ClearState
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *LaunchRequest) GetLauncherActivity() string {
|
|
if x != nil {
|
|
return x.LauncherActivity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Point struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
|
|
Y int32 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Point) Reset() {
|
|
*x = Point{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Point) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Point) ProtoMessage() {}
|
|
|
|
func (x *Point) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Point.ProtoReflect.Descriptor instead.
|
|
func (*Point) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
func (x *Point) GetX() int32 {
|
|
if x != nil {
|
|
return x.X
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Point) GetY() int32 {
|
|
if x != nil {
|
|
return x.Y
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Text struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Text) Reset() {
|
|
*x = Text{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Text) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Text) ProtoMessage() {}
|
|
|
|
func (x *Text) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Text.ProtoReflect.Descriptor instead.
|
|
func (*Text) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *Text) GetValue() string {
|
|
if x != nil {
|
|
return x.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Selector struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Selector) Reset() {
|
|
*x = Selector{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Selector) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Selector) ProtoMessage() {}
|
|
|
|
func (x *Selector) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Selector.ProtoReflect.Descriptor instead.
|
|
func (*Selector) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{4}
|
|
}
|
|
|
|
func (x *Selector) GetValue() string {
|
|
if x != nil {
|
|
return x.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Image struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Png []byte `protobuf:"bytes,1,opt,name=png,proto3" json:"png,omitempty"`
|
|
Width int32 `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"`
|
|
Height int32 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Image) Reset() {
|
|
*x = Image{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[5]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Image) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Image) ProtoMessage() {}
|
|
|
|
func (x *Image) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[5]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Image.ProtoReflect.Descriptor instead.
|
|
func (*Image) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{5}
|
|
}
|
|
|
|
func (x *Image) GetPng() []byte {
|
|
if x != nil {
|
|
return x.Png
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Image) GetWidth() int32 {
|
|
if x != nil {
|
|
return x.Width
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Image) GetHeight() int32 {
|
|
if x != nil {
|
|
return x.Height
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type HierarchyJSON struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Json string `protobuf:"bytes,1,opt,name=json,proto3" json:"json,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *HierarchyJSON) Reset() {
|
|
*x = HierarchyJSON{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[6]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *HierarchyJSON) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*HierarchyJSON) ProtoMessage() {}
|
|
|
|
func (x *HierarchyJSON) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[6]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use HierarchyJSON.ProtoReflect.Descriptor instead.
|
|
func (*HierarchyJSON) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{6}
|
|
}
|
|
|
|
func (x *HierarchyJSON) GetJson() string {
|
|
if x != nil {
|
|
return x.Json
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Duration struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Millis int64 `protobuf:"varint,1,opt,name=millis,proto3" json:"millis,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Duration) Reset() {
|
|
*x = Duration{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[7]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Duration) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Duration) ProtoMessage() {}
|
|
|
|
func (x *Duration) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[7]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Duration.ProtoReflect.Descriptor instead.
|
|
func (*Duration) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{7}
|
|
}
|
|
|
|
func (x *Duration) GetMillis() int64 {
|
|
if x != nil {
|
|
return x.Millis
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type HealthStatus struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Ready bool `protobuf:"varint,1,opt,name=ready,proto3" json:"ready,omitempty"`
|
|
Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
|
|
Platform string `protobuf:"bytes,3,opt,name=platform,proto3" json:"platform,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *HealthStatus) Reset() {
|
|
*x = HealthStatus{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[8]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *HealthStatus) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*HealthStatus) ProtoMessage() {}
|
|
|
|
func (x *HealthStatus) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[8]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use HealthStatus.ProtoReflect.Descriptor instead.
|
|
func (*HealthStatus) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{8}
|
|
}
|
|
|
|
func (x *HealthStatus) GetReady() bool {
|
|
if x != nil {
|
|
return x.Ready
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *HealthStatus) GetVersion() string {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *HealthStatus) GetPlatform() string {
|
|
if x != nil {
|
|
return x.Platform
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type SwipeRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
From *Point `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
|
|
To *Point `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
|
|
DurationMillis int64 `protobuf:"varint,3,opt,name=duration_millis,json=durationMillis,proto3" json:"duration_millis,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *SwipeRequest) Reset() {
|
|
*x = SwipeRequest{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[9]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *SwipeRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*SwipeRequest) ProtoMessage() {}
|
|
|
|
func (x *SwipeRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[9]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use SwipeRequest.ProtoReflect.Descriptor instead.
|
|
func (*SwipeRequest) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{9}
|
|
}
|
|
|
|
func (x *SwipeRequest) GetFrom() *Point {
|
|
if x != nil {
|
|
return x.From
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *SwipeRequest) GetTo() *Point {
|
|
if x != nil {
|
|
return x.To
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *SwipeRequest) GetDurationMillis() int64 {
|
|
if x != nil {
|
|
return x.DurationMillis
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type PressKeyRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Logical key name. Supported: "back", "home", "enter", "tab", "up",
|
|
// "down", "left", "right".
|
|
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PressKeyRequest) Reset() {
|
|
*x = PressKeyRequest{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[10]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PressKeyRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PressKeyRequest) ProtoMessage() {}
|
|
|
|
func (x *PressKeyRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[10]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PressKeyRequest.ProtoReflect.Descriptor instead.
|
|
func (*PressKeyRequest) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{10}
|
|
}
|
|
|
|
func (x *PressKeyRequest) GetKey() string {
|
|
if x != nil {
|
|
return x.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type RecentLogsRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Lower bound as unix-epoch milliseconds; entries at or after this are
|
|
// returned.
|
|
SinceUnixMillis int64 `protobuf:"varint,1,opt,name=since_unix_millis,json=sinceUnixMillis,proto3" json:"since_unix_millis,omitempty"`
|
|
// Minimum level: "E", "W", or "I". Empty defaults to "E".
|
|
LevelAtLeast string `protobuf:"bytes,2,opt,name=level_at_least,json=levelAtLeast,proto3" json:"level_at_least,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RecentLogsRequest) Reset() {
|
|
*x = RecentLogsRequest{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[11]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RecentLogsRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RecentLogsRequest) ProtoMessage() {}
|
|
|
|
func (x *RecentLogsRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[11]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RecentLogsRequest.ProtoReflect.Descriptor instead.
|
|
func (*RecentLogsRequest) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{11}
|
|
}
|
|
|
|
func (x *RecentLogsRequest) GetSinceUnixMillis() int64 {
|
|
if x != nil {
|
|
return x.SinceUnixMillis
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecentLogsRequest) GetLevelAtLeast() string {
|
|
if x != nil {
|
|
return x.LevelAtLeast
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type LogEntries struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Entries []*LogEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LogEntries) Reset() {
|
|
*x = LogEntries{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[12]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LogEntries) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LogEntries) ProtoMessage() {}
|
|
|
|
func (x *LogEntries) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[12]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LogEntries.ProtoReflect.Descriptor instead.
|
|
func (*LogEntries) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{12}
|
|
}
|
|
|
|
func (x *LogEntries) GetEntries() []*LogEntry {
|
|
if x != nil {
|
|
return x.Entries
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type LogEntry struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
UnixMillis int64 `protobuf:"varint,1,opt,name=unix_millis,json=unixMillis,proto3" json:"unix_millis,omitempty"`
|
|
Level string `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"`
|
|
Tag string `protobuf:"bytes,3,opt,name=tag,proto3" json:"tag,omitempty"`
|
|
Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LogEntry) Reset() {
|
|
*x = LogEntry{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[13]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LogEntry) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LogEntry) ProtoMessage() {}
|
|
|
|
func (x *LogEntry) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[13]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LogEntry.ProtoReflect.Descriptor instead.
|
|
func (*LogEntry) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{13}
|
|
}
|
|
|
|
func (x *LogEntry) GetUnixMillis() int64 {
|
|
if x != nil {
|
|
return x.UnixMillis
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LogEntry) GetLevel() string {
|
|
if x != nil {
|
|
return x.Level
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LogEntry) GetTag() string {
|
|
if x != nil {
|
|
return x.Tag
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LogEntry) GetMessage() string {
|
|
if x != nil {
|
|
return x.Message
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type MetricsRequest struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
BundleId string `protobuf:"bytes,1,opt,name=bundle_id,json=bundleId,proto3" json:"bundle_id,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MetricsRequest) Reset() {
|
|
*x = MetricsRequest{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[14]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MetricsRequest) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MetricsRequest) ProtoMessage() {}
|
|
|
|
func (x *MetricsRequest) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[14]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MetricsRequest.ProtoReflect.Descriptor instead.
|
|
func (*MetricsRequest) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{14}
|
|
}
|
|
|
|
func (x *MetricsRequest) GetBundleId() string {
|
|
if x != nil {
|
|
return x.BundleId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type MetricsResponse struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
CpuPercent float64 `protobuf:"fixed64,1,opt,name=cpu_percent,json=cpuPercent,proto3" json:"cpu_percent,omitempty"`
|
|
HeapBytes int64 `protobuf:"varint,2,opt,name=heap_bytes,json=heapBytes,proto3" json:"heap_bytes,omitempty"`
|
|
TotalMemoryBytes int64 `protobuf:"varint,3,opt,name=total_memory_bytes,json=totalMemoryBytes,proto3" json:"total_memory_bytes,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MetricsResponse) Reset() {
|
|
*x = MetricsResponse{}
|
|
mi := &file_driverpb_driver_proto_msgTypes[15]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MetricsResponse) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MetricsResponse) ProtoMessage() {}
|
|
|
|
func (x *MetricsResponse) ProtoReflect() protoreflect.Message {
|
|
mi := &file_driverpb_driver_proto_msgTypes[15]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MetricsResponse.ProtoReflect.Descriptor instead.
|
|
func (*MetricsResponse) Descriptor() ([]byte, []int) {
|
|
return file_driverpb_driver_proto_rawDescGZIP(), []int{15}
|
|
}
|
|
|
|
func (x *MetricsResponse) GetCpuPercent() float64 {
|
|
if x != nil {
|
|
return x.CpuPercent
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *MetricsResponse) GetHeapBytes() int64 {
|
|
if x != nil {
|
|
return x.HeapBytes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *MetricsResponse) GetTotalMemoryBytes() int64 {
|
|
if x != nil {
|
|
return x.TotalMemoryBytes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
var File_driverpb_driver_proto protoreflect.FileDescriptor
|
|
|
|
const file_driverpb_driver_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\x15driverpb/driver.proto\x12\x0euatu.driver.v1\"\a\n" +
|
|
"\x05Empty\"z\n" +
|
|
"\rLaunchRequest\x12\x1b\n" +
|
|
"\tbundle_id\x18\x01 \x01(\tR\bbundleId\x12\x1f\n" +
|
|
"\vclear_state\x18\x02 \x01(\bR\n" +
|
|
"clearState\x12+\n" +
|
|
"\x11launcher_activity\x18\x03 \x01(\tR\x10launcherActivity\"#\n" +
|
|
"\x05Point\x12\f\n" +
|
|
"\x01x\x18\x01 \x01(\x05R\x01x\x12\f\n" +
|
|
"\x01y\x18\x02 \x01(\x05R\x01y\"\x1c\n" +
|
|
"\x04Text\x12\x14\n" +
|
|
"\x05value\x18\x01 \x01(\tR\x05value\" \n" +
|
|
"\bSelector\x12\x14\n" +
|
|
"\x05value\x18\x01 \x01(\tR\x05value\"G\n" +
|
|
"\x05Image\x12\x10\n" +
|
|
"\x03png\x18\x01 \x01(\fR\x03png\x12\x14\n" +
|
|
"\x05width\x18\x02 \x01(\x05R\x05width\x12\x16\n" +
|
|
"\x06height\x18\x03 \x01(\x05R\x06height\"#\n" +
|
|
"\rHierarchyJSON\x12\x12\n" +
|
|
"\x04json\x18\x01 \x01(\tR\x04json\"\"\n" +
|
|
"\bDuration\x12\x16\n" +
|
|
"\x06millis\x18\x01 \x01(\x03R\x06millis\"Z\n" +
|
|
"\fHealthStatus\x12\x14\n" +
|
|
"\x05ready\x18\x01 \x01(\bR\x05ready\x12\x18\n" +
|
|
"\aversion\x18\x02 \x01(\tR\aversion\x12\x1a\n" +
|
|
"\bplatform\x18\x03 \x01(\tR\bplatform\"\x89\x01\n" +
|
|
"\fSwipeRequest\x12)\n" +
|
|
"\x04from\x18\x01 \x01(\v2\x15.uatu.driver.v1.PointR\x04from\x12%\n" +
|
|
"\x02to\x18\x02 \x01(\v2\x15.uatu.driver.v1.PointR\x02to\x12'\n" +
|
|
"\x0fduration_millis\x18\x03 \x01(\x03R\x0edurationMillis\"#\n" +
|
|
"\x0fPressKeyRequest\x12\x10\n" +
|
|
"\x03key\x18\x01 \x01(\tR\x03key\"e\n" +
|
|
"\x11RecentLogsRequest\x12*\n" +
|
|
"\x11since_unix_millis\x18\x01 \x01(\x03R\x0fsinceUnixMillis\x12$\n" +
|
|
"\x0elevel_at_least\x18\x02 \x01(\tR\flevelAtLeast\"@\n" +
|
|
"\n" +
|
|
"LogEntries\x122\n" +
|
|
"\aentries\x18\x01 \x03(\v2\x18.uatu.driver.v1.LogEntryR\aentries\"m\n" +
|
|
"\bLogEntry\x12\x1f\n" +
|
|
"\vunix_millis\x18\x01 \x01(\x03R\n" +
|
|
"unixMillis\x12\x14\n" +
|
|
"\x05level\x18\x02 \x01(\tR\x05level\x12\x10\n" +
|
|
"\x03tag\x18\x03 \x01(\tR\x03tag\x12\x18\n" +
|
|
"\amessage\x18\x04 \x01(\tR\amessage\"-\n" +
|
|
"\x0eMetricsRequest\x12\x1b\n" +
|
|
"\tbundle_id\x18\x01 \x01(\tR\bbundleId\"\x7f\n" +
|
|
"\x0fMetricsResponse\x12\x1f\n" +
|
|
"\vcpu_percent\x18\x01 \x01(\x01R\n" +
|
|
"cpuPercent\x12\x1d\n" +
|
|
"\n" +
|
|
"heap_bytes\x18\x02 \x01(\x03R\theapBytes\x12,\n" +
|
|
"\x12total_memory_bytes\x18\x03 \x01(\x03R\x10totalMemoryBytes2\xcb\x06\n" +
|
|
"\x06Driver\x12>\n" +
|
|
"\x06Launch\x12\x1d.uatu.driver.v1.LaunchRequest\x1a\x15.uatu.driver.v1.Empty\x129\n" +
|
|
"\tTerminate\x12\x15.uatu.driver.v1.Empty\x1a\x15.uatu.driver.v1.Empty\x123\n" +
|
|
"\x03Tap\x12\x15.uatu.driver.v1.Point\x1a\x15.uatu.driver.v1.Empty\x12>\n" +
|
|
"\vTapSelector\x12\x18.uatu.driver.v1.Selector\x1a\x15.uatu.driver.v1.Empty\x128\n" +
|
|
"\tInputText\x12\x14.uatu.driver.v1.Text\x1a\x15.uatu.driver.v1.Empty\x12<\n" +
|
|
"\x05Swipe\x12\x1c.uatu.driver.v1.SwipeRequest\x1a\x15.uatu.driver.v1.Empty\x12B\n" +
|
|
"\bPressKey\x12\x1f.uatu.driver.v1.PressKeyRequest\x1a\x15.uatu.driver.v1.Empty\x12:\n" +
|
|
"\n" +
|
|
"Screenshot\x12\x15.uatu.driver.v1.Empty\x1a\x15.uatu.driver.v1.Image\x12A\n" +
|
|
"\tHierarchy\x12\x15.uatu.driver.v1.Empty\x1a\x1d.uatu.driver.v1.HierarchyJSON\x12K\n" +
|
|
"\n" +
|
|
"RecentLogs\x12!.uatu.driver.v1.RecentLogsRequest\x1a\x1a.uatu.driver.v1.LogEntries\x12>\n" +
|
|
"\vWaitForIdle\x12\x18.uatu.driver.v1.Duration\x1a\x15.uatu.driver.v1.Empty\x12=\n" +
|
|
"\x06Health\x12\x15.uatu.driver.v1.Empty\x1a\x1c.uatu.driver.v1.HealthStatus\x12J\n" +
|
|
"\aMetrics\x12\x1e.uatu.driver.v1.MetricsRequest\x1a\x1f.uatu.driver.v1.MetricsResponseBM\n" +
|
|
"\x12dev.uatu.driver.v1P\x01Z5github.com/priyanshujain/uatu/proto/driverpb;driverpbb\x06proto3"
|
|
|
|
var (
|
|
file_driverpb_driver_proto_rawDescOnce sync.Once
|
|
file_driverpb_driver_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_driverpb_driver_proto_rawDescGZIP() []byte {
|
|
file_driverpb_driver_proto_rawDescOnce.Do(func() {
|
|
file_driverpb_driver_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_driverpb_driver_proto_rawDesc), len(file_driverpb_driver_proto_rawDesc)))
|
|
})
|
|
return file_driverpb_driver_proto_rawDescData
|
|
}
|
|
|
|
var file_driverpb_driver_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
|
|
var file_driverpb_driver_proto_goTypes = []any{
|
|
(*Empty)(nil), // 0: uatu.driver.v1.Empty
|
|
(*LaunchRequest)(nil), // 1: uatu.driver.v1.LaunchRequest
|
|
(*Point)(nil), // 2: uatu.driver.v1.Point
|
|
(*Text)(nil), // 3: uatu.driver.v1.Text
|
|
(*Selector)(nil), // 4: uatu.driver.v1.Selector
|
|
(*Image)(nil), // 5: uatu.driver.v1.Image
|
|
(*HierarchyJSON)(nil), // 6: uatu.driver.v1.HierarchyJSON
|
|
(*Duration)(nil), // 7: uatu.driver.v1.Duration
|
|
(*HealthStatus)(nil), // 8: uatu.driver.v1.HealthStatus
|
|
(*SwipeRequest)(nil), // 9: uatu.driver.v1.SwipeRequest
|
|
(*PressKeyRequest)(nil), // 10: uatu.driver.v1.PressKeyRequest
|
|
(*RecentLogsRequest)(nil), // 11: uatu.driver.v1.RecentLogsRequest
|
|
(*LogEntries)(nil), // 12: uatu.driver.v1.LogEntries
|
|
(*LogEntry)(nil), // 13: uatu.driver.v1.LogEntry
|
|
(*MetricsRequest)(nil), // 14: uatu.driver.v1.MetricsRequest
|
|
(*MetricsResponse)(nil), // 15: uatu.driver.v1.MetricsResponse
|
|
}
|
|
var file_driverpb_driver_proto_depIdxs = []int32{
|
|
2, // 0: uatu.driver.v1.SwipeRequest.from:type_name -> uatu.driver.v1.Point
|
|
2, // 1: uatu.driver.v1.SwipeRequest.to:type_name -> uatu.driver.v1.Point
|
|
13, // 2: uatu.driver.v1.LogEntries.entries:type_name -> uatu.driver.v1.LogEntry
|
|
1, // 3: uatu.driver.v1.Driver.Launch:input_type -> uatu.driver.v1.LaunchRequest
|
|
0, // 4: uatu.driver.v1.Driver.Terminate:input_type -> uatu.driver.v1.Empty
|
|
2, // 5: uatu.driver.v1.Driver.Tap:input_type -> uatu.driver.v1.Point
|
|
4, // 6: uatu.driver.v1.Driver.TapSelector:input_type -> uatu.driver.v1.Selector
|
|
3, // 7: uatu.driver.v1.Driver.InputText:input_type -> uatu.driver.v1.Text
|
|
9, // 8: uatu.driver.v1.Driver.Swipe:input_type -> uatu.driver.v1.SwipeRequest
|
|
10, // 9: uatu.driver.v1.Driver.PressKey:input_type -> uatu.driver.v1.PressKeyRequest
|
|
0, // 10: uatu.driver.v1.Driver.Screenshot:input_type -> uatu.driver.v1.Empty
|
|
0, // 11: uatu.driver.v1.Driver.Hierarchy:input_type -> uatu.driver.v1.Empty
|
|
11, // 12: uatu.driver.v1.Driver.RecentLogs:input_type -> uatu.driver.v1.RecentLogsRequest
|
|
7, // 13: uatu.driver.v1.Driver.WaitForIdle:input_type -> uatu.driver.v1.Duration
|
|
0, // 14: uatu.driver.v1.Driver.Health:input_type -> uatu.driver.v1.Empty
|
|
14, // 15: uatu.driver.v1.Driver.Metrics:input_type -> uatu.driver.v1.MetricsRequest
|
|
0, // 16: uatu.driver.v1.Driver.Launch:output_type -> uatu.driver.v1.Empty
|
|
0, // 17: uatu.driver.v1.Driver.Terminate:output_type -> uatu.driver.v1.Empty
|
|
0, // 18: uatu.driver.v1.Driver.Tap:output_type -> uatu.driver.v1.Empty
|
|
0, // 19: uatu.driver.v1.Driver.TapSelector:output_type -> uatu.driver.v1.Empty
|
|
0, // 20: uatu.driver.v1.Driver.InputText:output_type -> uatu.driver.v1.Empty
|
|
0, // 21: uatu.driver.v1.Driver.Swipe:output_type -> uatu.driver.v1.Empty
|
|
0, // 22: uatu.driver.v1.Driver.PressKey:output_type -> uatu.driver.v1.Empty
|
|
5, // 23: uatu.driver.v1.Driver.Screenshot:output_type -> uatu.driver.v1.Image
|
|
6, // 24: uatu.driver.v1.Driver.Hierarchy:output_type -> uatu.driver.v1.HierarchyJSON
|
|
12, // 25: uatu.driver.v1.Driver.RecentLogs:output_type -> uatu.driver.v1.LogEntries
|
|
0, // 26: uatu.driver.v1.Driver.WaitForIdle:output_type -> uatu.driver.v1.Empty
|
|
8, // 27: uatu.driver.v1.Driver.Health:output_type -> uatu.driver.v1.HealthStatus
|
|
15, // 28: uatu.driver.v1.Driver.Metrics:output_type -> uatu.driver.v1.MetricsResponse
|
|
16, // [16:29] is the sub-list for method output_type
|
|
3, // [3:16] is the sub-list for method input_type
|
|
3, // [3:3] is the sub-list for extension type_name
|
|
3, // [3:3] is the sub-list for extension extendee
|
|
0, // [0:3] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_driverpb_driver_proto_init() }
|
|
func file_driverpb_driver_proto_init() {
|
|
if File_driverpb_driver_proto != nil {
|
|
return
|
|
}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_driverpb_driver_proto_rawDesc), len(file_driverpb_driver_proto_rawDesc)),
|
|
NumEnums: 0,
|
|
NumMessages: 16,
|
|
NumExtensions: 0,
|
|
NumServices: 1,
|
|
},
|
|
GoTypes: file_driverpb_driver_proto_goTypes,
|
|
DependencyIndexes: file_driverpb_driver_proto_depIdxs,
|
|
MessageInfos: file_driverpb_driver_proto_msgTypes,
|
|
}.Build()
|
|
File_driverpb_driver_proto = out.File
|
|
file_driverpb_driver_proto_goTypes = nil
|
|
file_driverpb_driver_proto_depIdxs = nil
|
|
}
|