| // Copyright (C) 2018 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Note that if you add/remove methods in this file you must update |
| // the metrics sql as well ./android/scripts/gen-grpc-sql.py |
| // |
| // Please group deleted methods in a block including the date (MM/DD/YY) |
| // it was removed. This enables us to easily keep metrics around after removal |
| // |
| // List of deleted methods |
| // rpc iWasDeleted (03/12/12) |
| // ... |
| syntax = "proto3"; |
| |
| option java_multiple_files = true; |
| option java_package = "com.android.emulator.control"; |
| option objc_class_prefix = "AEC"; |
| |
| package android.emulation.control; |
| import "google/protobuf/empty.proto"; |
| |
| // An EmulatorController service lets you control the emulator. |
| // Note that this is currently an experimental feature, and that the |
| // service definition might change without notice. Use at your own risk! |
| // |
| // We use the following rough conventions: |
| // |
| // streamXXX --> streams values XXX (usually for emulator lifetime). Values |
| // are updated as soon as they become available. |
| // getXXX --> gets a single value XXX |
| // setXXX --> sets a single value XXX, does not returning state, these |
| // usually have an observable lasting side effect. |
| // sendXXX --> send a single event XXX, possibly returning state information. |
| // android usually responds to these events. |
| service EmulatorController { |
| // set/get/stream the sensor data |
| rpc streamSensor(SensorValue) returns (stream SensorValue) {} |
| rpc getSensor(SensorValue) returns (SensorValue) {} |
| rpc setSensor(SensorValue) returns (google.protobuf.Empty) {} |
| |
| // set/get/stream the physical model, this is likely the one you are |
| // looking for when you wish to modify the device state. |
| rpc setPhysicalModel(PhysicalModelValue) returns (google.protobuf.Empty) {} |
| rpc getPhysicalModel(PhysicalModelValue) returns (PhysicalModelValue) {} |
| rpc streamPhysicalModel(PhysicalModelValue) |
| returns (stream PhysicalModelValue) {} |
| |
| // Atomically set/get the current primary clipboard data. |
| rpc setClipboard(ClipData) returns (google.protobuf.Empty) {} |
| rpc getClipboard(google.protobuf.Empty) returns (ClipData) {} |
| |
| // Streams the current data on the clipboard. This will immediately produce |
| // a result with the current state of the clipboard after which the stream |
| // will block and wait until a new clip event is available from the guest. |
| // Calling the setClipboard method above will not result in generating a clip |
| // event. It is possible to lose clipboard events if the clipboard updates |
| // very rapidly. |
| rpc streamClipboard(google.protobuf.Empty) returns (stream ClipData) {} |
| |
| // Set/get the battery to the given state. |
| rpc setBattery(BatteryState) returns (google.protobuf.Empty) {} |
| rpc getBattery(google.protobuf.Empty) returns (BatteryState) {} |
| |
| // Set the state of the gps, gps support will only work |
| // properly if: |
| // |
| // - no location ui is active. That is the emulator |
| // is launched in headless mode (-no-window) or the location |
| // ui is disabled (-no-location-ui). |
| // - the passiveUpdate is set to false. Setting this to false |
| // will disable/break the LocationUI. |
| // |
| // Keep in mind that android usually only samples the gps at 1 hz. |
| rpc setGps(GpsState) returns (google.protobuf.Empty) {} |
| |
| // Gets the latest gps state as delivered by the setGps call, or location ui |
| // if active. |
| // |
| // Note: this is not necessarily the actual gps coordinate visible at the |
| // time, due to gps sample frequency (usually 1hz). |
| rpc getGps(google.protobuf.Empty) returns (GpsState) {} |
| |
| // Simulate a touch event on the finger print sensor. |
| rpc sendFingerprint(Fingerprint) returns (google.protobuf.Empty) {} |
| |
| // Send a keyboard event. Translating the event. |
| rpc sendKey(KeyboardEvent) returns (google.protobuf.Empty) {} |
| |
| // Send touch/mouse events. Note that mouse events can be simulated |
| // by touch events. |
| rpc sendTouch(TouchEvent) returns (google.protobuf.Empty) {} |
| rpc sendMouse(MouseEvent) returns (google.protobuf.Empty) {} |
| |
| // Make a phone call. |
| rpc sendPhone(PhoneCall) returns (PhoneResponse) {} |
| |
| // Sends an sms message to the emulator. |
| rpc sendSms(SmsMessage) returns (PhoneResponse) {} |
| |
| // Retrieve the status of the emulator. This will contain general |
| // hardware information, and whether the device has booted or not. |
| rpc getStatus(google.protobuf.Empty) returns (EmulatorStatus) {} |
| |
| // Gets an individual screenshot in the desired format. |
| // |
| // The image will be scaled to the desired ImageFormat, while maintaining |
| // the aspect ratio. The returned image will never exceed the provided width |
| // and height. Not setting the width or height (i.e. they are 0) will result |
| // in using the device width and height. |
| // |
| // The resulting image will be properly oriented and can be displayed |
| // directly without post processing. For example, if the device has a |
| // 1080x1920 screen and is in landscape mode and called with no width or |
| // height parameter, it will return an 1920x1080 image. |
| // |
| // This method will return an empty image if the display is not visible. |
| rpc getScreenshot(ImageFormat) returns (Image) {} |
| |
| // Streams a series of screenshots in the desired format. |
| // A new frame will be delivered whenever the device produces a new frame. |
| // (Beware that this can produce a significant amount of data, and that |
| // certain translations are (png transform) can be costly). |
| // |
| // If the requested display is not visible it will send a single empty image |
| // and wait start producing images once the display becomes active, again |
| // producing a single empty image when the display becomes inactive. |
| rpc streamScreenshot(ImageFormat) returns (stream Image) {} |
| |
| // Streams a series of audio packets in the desired format. |
| // A new frame will be delivered whenever the emulated device |
| // produces a new audio frame. You can expect packets to be |
| // delivered in intervals of 20-30ms. |
| // |
| // Be aware that this can block when the emulator does not |
| // produce any audio whatsoever! |
| rpc streamAudio(AudioFormat) returns (stream AudioPacket) {} |
| |
| |
| // Injects a series of audio packets to the android microphone. |
| // A new frame will be delivered whenever the emulated device |
| // requests a new audio frame. Audio is usually delivered at a rate |
| // that the emulator is requesting frames. Audio will be stored in a |
| // temporary buffer that can hold 300ms of audio. |
| // |
| // Notes: |
| // - Only the first audio format packet that is delivered will be |
| // honored. There is no need to send the audio format multiple times. |
| // - Real time audio currently immediately overrides the buffer. This |
| // means you must provide a constant rate of audio packets. The real |
| // time mode is experimental. Timestamps of audio packets might be |
| // used in the future to improve synchronization. |
| // |
| // - INVALID_ARGUMENT (code 3) The sampling rate was too high/low |
| // - INVALID_ARGUMENT (code 3) The audio packet was too large to handle. |
| // - FAILED_PRECONDITION (code 9) If there was a microphone registered already. |
| rpc injectAudio(stream AudioPacket) returns (google.protobuf.Empty) {} |
| |
| // Returns the last 128Kb of logcat output from the emulator |
| // Note that parsed logcat messages are only available after L (Api >23). |
| // it is possible that the logcat buffer gets overwritten, or falls behind. |
| rpc getLogcat(LogMessage) returns (LogMessage) {} |
| |
| // Streams the logcat output from the emulator. The first call |
| // can retrieve up to 128Kb. This call will not return. |
| // Note that parsed logcat messages are only available after L (Api >23) |
| // it is possible that the logcat buffer gets overwritten, or falls behind. |
| rpc streamLogcat(LogMessage) returns (stream LogMessage) {} |
| |
| // Transition the virtual machine to the desired state. Note that |
| // some states are only observable. For example you cannot transition |
| // to the error state. |
| rpc setVmState(VmRunState) returns (google.protobuf.Empty) {} |
| |
| // Gets the state of the virtual machine. |
| rpc getVmState(google.protobuf.Empty) returns (VmRunState) {} |
| |
| // Atomically changes the current multi-display configuration. |
| // After this call the given display configurations will be activated. You |
| // can only update secondary displays. Displays with id 0 will be ignored. |
| // |
| // This call can result in the removal or addition of secondary displays, the final |
| // display state can be observed by the returned configuration. |
| // |
| // The following gRPC error codes can be returned: |
| // - FAILED_PRECONDITION (code 9) if the AVD does not support a configurable |
| // secondary display. |
| // - INVALID_ARGUMENT (code 3) if: |
| // - The same display id is defined multiple times. |
| // - The display configurations are outside valid ranges. |
| // See DisplayConfiguration for details on valid ranges. |
| // - INTERNAL (code 13) if there was an internal emulator failure. |
| rpc setDisplayConfigurations(DisplayConfigurations) |
| returns (DisplayConfigurations) {} |
| |
| // Returns all currently valid logical displays. |
| // |
| // The gRPC error code FAILED_PRECONDITION (code 9) is returned if the AVD |
| // does not support a configurable secondary display. |
| rpc getDisplayConfigurations(google.protobuf.Empty) |
| returns (DisplayConfigurations) {} |
| |
| // Notifies client of the following changes: |
| // |
| // - Virtual scene camera status change. |
| // - Display configuration changes from extended ui. This will only be fired |
| // if the user makes modifications the extended displays through the extended |
| // control tab. |
| // |
| // Note that this method will send the initial virtual scene state immediately. |
| rpc streamNotification(google.protobuf.Empty) returns (stream Notification) {} |
| |
| // RotationRadian is relative to the camera's current orientation. |
| rpc rotateVirtualSceneCamera(RotationRadian) returns (google.protobuf.Empty) { |
| } |
| // Velocity is absolute |
| rpc setVirtualSceneCameraVelocity(Velocity) |
| returns (google.protobuf.Empty) {} |
| // Set foldable posture |
| rpc setPosture(Posture) returns (google.protobuf.Empty) {} |
| |
| // Get the backlight brightness. |
| // The following gRPC error codes can be returned: |
| // - FAILED_PRECONDITION (code 9) if the AVD does not support hw-control. |
| rpc getBrightness(BrightnessValue) returns (BrightnessValue) {} |
| |
| // Set the backlight brightness. |
| // The following gRPC error codes can be returned: |
| // - FAILED_PRECONDITION (code 9) if the AVD does not support hw-control. |
| // - INVALID_ARGUMENT (code 3) The brightness exceeds the valid range. |
| rpc setBrightness(BrightnessValue) returns (google.protobuf.Empty) {} |
| |
| // Returns the current mode of the primary display of a resizable AVD. |
| // The following gRPC error codes can be returned: |
| // - FAILED_PRECONDITION (code 9) if the AVD is not resizable. |
| rpc getDisplayMode(google.protobuf.Empty) returns (DisplayMode) {} |
| |
| // Sets the size of the primary display of a resizable AVD. Fails if the AVD is |
| // not resizable. |
| // The following gRPC error codes can be returned: |
| // - FAILED_PRECONDITION (code 9) if the AVD is not resizable. |
| rpc setDisplayMode(DisplayMode) returns (google.protobuf.Empty) {} |
| } |
| |
| // A Run State that describes the state of the Virtual Machine. |
| message VmRunState { |
| enum RunState { |
| // The emulator is in an unknown state. You cannot transition to this state. |
| UNKNOWN = 0; |
| // Guest is actively running. You can transition to this state from the |
| // paused state. |
| RUNNING = 1; |
| // Guest is paused to load a snapshot. You cannot transition to this state. |
| RESTORE_VM = 2; |
| // Guest has been paused. Transitioning to this state will pause the |
| // emulator the guest will not be consuming any cpu cycles. |
| PAUSED = 3; |
| // Guest is paused to take or export a snapshot. You cannot |
| // transition to this state. |
| SAVE_VM = 4; |
| // System shutdown, note that it is similar to power off. It tries to set |
| // the system status and notify guest. The system is likely going to |
| // disappear soon and do proper cleanup of resources, possibly taking |
| // a snapshot. This is the same behavior as closing the emulator by clicking |
| // the X (close) in the user interface. |
| SHUTDOWN = 5; |
| // Immediately terminate the emulator. No resource cleanup will take place. |
| // There is a good change to corrupt the system. |
| TERMINATE = 7; |
| // Will cause the emulator to reset. This is not a state you can observe. |
| RESET = 9; |
| // Guest experienced some error state, you cannot transition to this state. |
| INTERNAL_ERROR = 10; |
| } |
| |
| RunState state = 1; |
| } |
| |
| message ParameterValue { repeated float data = 1 [ packed = true ]; } |
| |
| message PhysicalModelValue { |
| enum State { |
| OK = 0; |
| NO_SERVICE = -3; // qemud service is not available/initiated. |
| DISABLED = -2; // Sensor is disabled. |
| UNKNOWN = -1; // Unknown sensor (should not happen) |
| } |
| |
| // Details on the sensors documentation can be found here: |
| // https://developer.android.com/reference/android/hardware/Sensor.html#TYPE_ |
| // The types must follow the order defined in "external/qemu/android/hw-sensors.h" |
| enum PhysicalType { |
| POSITION = 0; |
| |
| // All values are angles in degrees. |
| // values = [x,y,z] |
| ROTATION = 1; |
| |
| MAGNETIC_FIELD = 2; |
| |
| // Temperature in °C |
| TEMPERATURE = 3; |
| |
| // Proximity sensor distance measured in centimeters |
| PROXIMITY = 4; |
| |
| // Ambient light level in SI lux units |
| LIGHT = 5; |
| |
| // Atmospheric pressure in hPa (millibar) |
| PRESSURE = 6; |
| |
| // Relative ambient air humidity in percent |
| HUMIDITY = 7; |
| |
| VELOCITY = 8; |
| AMBIENT_MOTION = 9; |
| |
| // Describing a hinge angle sensor in degrees. |
| HINGE_ANGLE0 = 10; |
| HINGE_ANGLE1 = 11; |
| HINGE_ANGLE2 = 12; |
| |
| ROLLABLE0 = 13; |
| ROLLABLE1 = 14; |
| ROLLABLE2 = 15; |
| |
| // Describing the device posture; the value should be an enum defined |
| // in Posture::PostureValue. |
| POSTURE = 16; |
| |
| // Heart rate in bpm |
| HEART_RATE = 17; |
| |
| // Ambient RGBC light intensity. Values are in order (Red, Green, Blue, |
| // Clear). |
| RGBC_LIGHT = 18; |
| |
| // Wrist tilt gesture (1 = gaze, 0 = ungaze) |
| WRIST_TILT = 19; |
| } |
| PhysicalType target = 1; |
| |
| // [Output Only] |
| State status = 2; |
| |
| // Value interpretation depends on sensor. |
| ParameterValue value = 3; |
| } |
| |
| // A single sensor value. |
| message SensorValue { |
| enum State { |
| OK = 0; |
| NO_SERVICE = -3; // qemud service is not available/initiated. |
| DISABLED = -2; // Sensor is disabled. |
| UNKNOWN = -1; // Unknown sensor (should not happen) |
| } |
| |
| // These are the various sensors that can be available in an emulated |
| // devices. |
| enum SensorType { |
| // Measures the acceleration force in m/s2 that is applied to a device |
| // on all three physical axes (x, y, and z), including the force of |
| // gravity. |
| ACCELERATION = 0; |
| // Measures a device's rate of rotation in rad/s around each of the |
| // three physical axes (x, y, and z). |
| GYROSCOPE = 1; |
| // Measures the ambient geomagnetic field for all three physical axes |
| // (x, y, z) in μT. |
| MAGNETIC_FIELD = 2; |
| // Measures degrees of rotation that a device makes around all three |
| // physical axes (x, y, z) |
| ORIENTATION = 3; |
| // Measures the temperature of the device in degrees Celsius (°C). |
| TEMPERATURE = 4; |
| // Measures the proximity of an object in cm relative to the view screen |
| // of a device. This sensor is typically used to determine whether a |
| // handset is being held up to a person's ear. |
| PROXIMITY = 5; |
| // Measures the ambient light level (illumination) in lx. |
| LIGHT = 6; |
| // Measures the ambient air pressure in hPa or mbar. |
| PRESSURE = 7; |
| // Measures the relative ambient humidity in percent (%). |
| HUMIDITY = 8; |
| MAGNETIC_FIELD_UNCALIBRATED = 9; |
| GYROSCOPE_UNCALIBRATED = 10; |
| |
| // HINGE_ANGLE0 (11), HINGE_ANGLE1 (12), HINGE_ANGLE2 (13) are |
| // skipped; clients should use get/setPhysicalModel() instead for these |
| // "sensors". |
| |
| // Measures the heart rate in bpm. |
| HEART_RATE = 14; |
| // Measures the ambient RGBC light intensity. |
| // Values are in order (Red, Green, Blue, Clear). |
| RGBC_LIGHT = 15; |
| // WIRST_TILT (16) is skipped; clients should use get/setPhysicalModel() |
| // instead. |
| } |
| |
| // Type of sensor |
| SensorType target = 1; |
| |
| // [Output Only] |
| State status = 2; |
| |
| // Value interpretation depends on sensor enum. |
| ParameterValue value = 3; |
| } |
| |
| // A single backlight brightness value. |
| message BrightnessValue { |
| enum LightType { |
| // Display backlight. This will affect all displays. |
| LCD = 0; |
| KEYBOARD = 1; |
| BUTTON = 2; |
| } |
| |
| // Type of light |
| LightType target = 1; |
| |
| // Light intensity, ranges from 0-255. |
| uint32 value = 2; |
| } |
| |
| // in line with android/emulation/resizable_display_config.h |
| enum DisplayModeValue { |
| PHONE = 0; |
| FOLDABLE = 1; |
| TABLET = 2; |
| DESKTOP = 3; |
| } |
| |
| message DisplayMode{ |
| DisplayModeValue value = 1; |
| } |
| |
| message LogMessage { |
| // [Output Only] The contents of the log output. |
| string contents = 1; |
| // The starting byte position of the output that was returned. This |
| // should match the start parameter sent with the request. If the serial |
| // console output exceeds the size of the buffer, older output will be |
| // overwritten by newer content and the start values will be mismatched. |
| int64 start = 2; |
| //[Output Only] The position of the next byte of content from the serial |
| // console output. Use this value in the next request as the start |
| // parameter. |
| int64 next = 3; |
| |
| // Set the sort of response you are interested it in. |
| // It the type is "Parsed" the entries field will contain the parsed |
| // results. otherwise the contents field will be set. |
| LogType sort = 4; |
| |
| // [Output Only] The parsed logcat entries so far. Only set if sort is |
| // set to Parsed |
| repeated LogcatEntry entries = 5; |
| |
| enum LogType { |
| Text = 0; |
| Parsed = 1; |
| } |
| } |
| |
| // A parsed logcat entry. |
| message LogcatEntry { |
| // The possible log levels. |
| enum LogLevel { |
| UNKNOWN = 0; |
| DEFAULT = 1; |
| VERBOSE = 2; |
| DEBUG = 3; |
| INFO = 4; |
| WARN = 5; |
| ERR = 6; |
| FATAL = 7; |
| SILENT = 8; |
| } |
| |
| // A Unix timestamps in milliseconds (The number of milliseconds that |
| // have elapsed since January 1, 1970 (midnight UTC/GMT), not counting |
| // leap seconds) |
| uint64 timestamp = 1; |
| |
| // Process id. |
| uint32 pid = 2; |
| |
| // Thread id. |
| uint32 tid = 3; |
| LogLevel level = 4; |
| string tag = 5; |
| string msg = 6; |
| } |
| |
| // Information about the hypervisor that is currently in use. |
| message VmConfiguration { |
| enum VmHypervisorType { |
| // An unknown hypervisor |
| UNKNOWN = 0; |
| |
| // No hypervisor is in use. This usually means that the guest is |
| // running on a different CPU than the host, or you are using a |
| // platform where no hypervisor is available. |
| NONE = 1; |
| |
| // The Kernel based Virtual Machine |
| // (https://www.linux-kvm.org/page/Main_Page) |
| KVM = 2; |
| |
| // Intel® Hardware Accelerated Execution Manager (Intel® HAXM) |
| // https://github.com/intel/haxm |
| HAXM = 3; |
| |
| // Hypervisor Framework. |
| // https://developer.apple.com/documentation/hypervisor |
| HVF = 4; |
| |
| // Window Hypervisor Platform |
| // https://docs.microsoft.com/en-us/virtualization/api/ |
| WHPX = 5; |
| |
| GVM = 6; |
| } |
| |
| VmHypervisorType hypervisorType = 1; |
| int32 numberOfCpuCores = 2; |
| int64 ramSizeBytes = 3; |
| } |
| |
| // Representation of a clipped data object on the clipboard. |
| message ClipData { |
| // UTF-8 Encoded text. |
| string text = 1; |
| } |
| |
| // The Touch interface represents a single contact point on a |
| // touch-sensitive device. The contact point is commonly a finger or stylus |
| // and the device may be a touchscreen or trackpad. |
| message Touch { |
| // The horizontal coordinate. This is the physical location on the |
| // screen For example 0 indicates the leftmost coordinate. |
| int32 x = 1; |
| |
| // The vertical coordinate. This is the physical location on the screen |
| // For example 0 indicates the top left coordinate. |
| int32 y = 2; |
| |
| // The identifier is an arbitrary non-negative integer that is used to |
| // identify and track each tool independently when multiple tools are |
| // active. For example, when multiple fingers are touching the device, |
| // each finger should be assigned a distinct tracking id that is used as |
| // long as the finger remains in contact. Tracking ids may be reused |
| // when their associated tools move out of range. |
| // |
| // The emulator currently supports up to 10 concurrent touch events. The |
| // identifier can be any uninque value and will be mapped to the next |
| // available internal identifier. |
| int32 identifier = 3; |
| |
| // Reports the physical pressure applied to the tip of the tool or the |
| // signal strength of the touch contact. |
| // |
| // The values reported must be non-zero when the tool is touching the |
| // device and zero otherwise to indicate that the touch event is |
| // completed. |
| // |
| // Make sure to deliver a pressure of 0 for the given identifier when |
| // the touch event is completed, otherwise the touch identifier will not |
| // be unregistered! |
| int32 pressure = 4; |
| |
| // Optionally reports the cross-sectional area of the touch contact, or |
| // the length of the longer dimension of the touch contact. |
| int32 touch_major = 5; |
| |
| // Optionally reports the length of the shorter dimension of the touch |
| // contact. This axis will be ignored if touch_major is reporting an |
| // area measurement greater than 0. |
| int32 touch_minor = 6; |
| |
| enum EventExpiration { |
| // The system will use the default time of 120s to track |
| // the touch event with the given identifier. If no update happens |
| // within this timeframe the identifier is considered expired |
| // and can be made available for re-use. This means that a touch event |
| // with pressure 0 for this identifier will be send to the emulator. |
| EVENT_EXPIRATION_UNSPECIFIED = 0; |
| |
| // Never expire the given slot. You must *ALWAYS* close the identifier |
| // by sending a touch event with 0 pressure. |
| NEVER_EXPIRE = 1; |
| } |
| |
| EventExpiration expiration = 7; |
| } |
| |
| // A TouchEvent contains a list of Touch objects that are in contact with |
| // the touch surface. |
| // |
| // Touch events are delivered in sequence as specified in the touchList. |
| // |
| // TouchEvents are delivered to the emulated devices using ["Protocol |
| // B"](https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt) |
| message TouchEvent { |
| // The list of Touch objects, note that these do not need to be unique |
| repeated Touch touches = 1; |
| |
| // The display device where the touch event occurred. |
| // Omitting or using the value 0 indicates the main display. |
| // |
| // Touch events cannot be send to displays other than 0, due to |
| // https://issuetracker.google.com/issues/150699691 |
| int32 display = 2; |
| } |
| |
| // The MouseEvent interface represents events that occur due to the user |
| // interacting with a pointing device (such as a mouse). |
| message MouseEvent { |
| // The horizontal coordinate. This is the physical location on the |
| // screen For example 0 indicates the leftmost coordinate. |
| int32 x = 1; |
| |
| // The vertical coordinate. This is the physical location on the screen |
| // For example 0 indicates the top left coordinate. |
| int32 y = 2; |
| |
| // Indicates which buttons are pressed. |
| // 0: No button was pressed |
| // 1: Primary button (left) |
| // 2: Secondary button (right) |
| int32 buttons = 3; |
| |
| // The display device where the mouse event occurred. |
| // Omitting or using the value 0 indicates the main display. |
| int32 display = 4; |
| } |
| |
| // KeyboardEvent objects describe a user interaction with the keyboard; each |
| // event describes a single interaction between the user and a key (or |
| // combination of a key with modifier keys) on the keyboard. |
| // This follows the pattern as set by |
| // (javascript)[https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent] |
| // |
| // Note: that only keyCode, key, or text can be set and that the semantics |
| // will slightly vary. |
| message KeyboardEvent { |
| // Code types that the emulator can receive. Note that the emulator |
| // will do its best to translate the code to an evdev value that |
| // will be send to the emulator. This translation is based on |
| // the chromium translation tables. See |
| // (this)[https://android.googlesource.com/platform/external/qemu/+/refs/heads/emu-master-dev/android/android-grpc/android/emulation/control/keyboard/keycode_converter_data.inc] |
| // for details on the translation. |
| enum KeyCodeType { |
| Usb = 0; |
| Evdev = 1; |
| XKB = 2; |
| Win = 3; |
| Mac = 4; |
| } |
| |
| enum KeyEventType { |
| // Indicates that this keyevent should be send to the emulator |
| // as a key down event. Meaning that the key event will be |
| // translated to an EvDev event type and bit 11 (0x400) will be |
| // set before it is sent to the emulator. |
| keydown = 0; |
| |
| // Indicates that the keyevent should be send to the emulator |
| // as a key up event. Meaning that the key event will be |
| // translated to an EvDev event type and |
| // sent to the emulator. |
| keyup = 1; |
| |
| // Indicates that the keyevent will be send to the emulator |
| // as e key down event and immediately followed by a keyup event. |
| keypress = 2; |
| } |
| |
| // Type of keycode contained in the keyCode field. |
| KeyCodeType codeType = 1; |
| |
| // The type of keyboard event that should be sent to the emulator |
| KeyEventType eventType = 2; |
| |
| // This property represents a physical key on the keyboard (as opposed |
| // to the character generated by pressing the key). In other words, this |
| // property is a value which isn't altered by keyboard layout or the |
| // state of the modifier keys. This value will be interpreted by the |
| // emulator depending on the KeyCodeType. The incoming key code will be |
| // translated to an evdev code type and send to the emulator. |
| // The values in key and text will be ignored. |
| int32 keyCode = 3; |
| |
| // The value of the key pressed by the user, taking into consideration |
| // the state of modifier keys such as Shift as well as the keyboard |
| // locale and layout. This follows the w3c standard used in browsers. |
| // You can find an accurate description of valid values |
| // [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values) |
| // |
| // Note that some keys can result in multiple evdev events that are |
| // delivered to the emulator. for example the Key "A" will result in a |
| // sequence: |
| // ["Shift", "a"] -> [0x2a, 0x1e] whereas "a" results in ["a"] -> [0x1e]. |
| // |
| // Not all documented keys are understood by android, and only printable |
| // ASCII [32-127) characters are properly translated. |
| // |
| // Keep in mind that there are a set of key values that result in android |
| // specific behavior |
| // [see](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values#Phone_keys): |
| // |
| // - "AppSwitch": Behaves as the "Overview" button in android. |
| // - "GoBack": The Back button. |
| // - "GoHome": The Home button, which takes the user to the phone's main |
| // screen (usually an application launcher). |
| // - "Power": The Power button. |
| string key = 4; |
| |
| // Series of utf8 encoded characters to send to the emulator. An attempt |
| // will be made to translate every character will an EvDev event type and |
| // send to the emulator as a keypress event. The values in keyCode, |
| // eventType, codeType and key will be ignored. |
| // |
| // Note that most printable ASCII characters (range [32-127) can be send |
| // individually with the "key" param. Do not expect arbitrary UTF symbols to |
| // arrive in the emulator (most will be ignored). |
| // |
| // Note that it is possible to overrun the keyboard buffer by slamming this |
| // endpoint with large quantities of text (>1kb). The clipboard api is better |
| // suited for transferring large quantities of text. |
| string text = 5; |
| } |
| |
| message Fingerprint { |
| // True when the fingprint is touched. |
| bool isTouching = 1; |
| |
| // The identifier of the registered fingerprint. |
| int32 touchId = 2; |
| } |
| |
| message GpsState { |
| // Setting this to false will disable auto updating from the LocationUI, |
| // otherwise the location UI will override the location at a frequency of 1hz. |
| // |
| // - This is unused if the emulator is launched with -no-window, or when he |
| // location ui is disabled. |
| // - This will BREAK the location ui experience if it is set to false. For |
| // example routing will no longer function. |
| bool passiveUpdate = 1; |
| |
| // The latitude, in degrees. |
| double latitude = 2; |
| |
| // The longitude, in degrees. |
| double longitude = 3; |
| |
| // The speed if it is available, in meters/second over ground |
| double speed = 4; |
| |
| // gets the horizontal direction of travel of this device, and is not |
| // related to the device orientation. It is guaranteed to be in the |
| // range [0.0, 360.0] if the device has a bearing. 0=North, 90=East, |
| // 180=South, etc.. |
| double bearing = 5; |
| |
| // The altitude if available, in meters above the WGS 84 reference |
| // ellipsoid. |
| double altitude = 6; |
| |
| // The number of satellites used to derive the fix |
| int32 satellites = 7; |
| } |
| |
| message BatteryState { |
| enum BatteryStatus { |
| UNKNOWN = 0; |
| CHARGING = 1; |
| DISCHARGING = 2; |
| NOT_CHARGING = 3; |
| FULL = 4; |
| } |
| |
| enum BatteryCharger { |
| NONE = 0; |
| AC = 1; |
| USB = 2; |
| WIRELESS = 3; |
| } |
| |
| enum BatteryHealth { |
| GOOD = 0; |
| FAILED = 1; |
| DEAD = 2; |
| OVERVOLTAGE = 3; |
| OVERHEATED = 4; |
| } |
| |
| bool hasBattery = 1; |
| bool isPresent = 2; |
| BatteryCharger charger = 3; |
| int32 chargeLevel = 4; |
| BatteryHealth health = 5; |
| BatteryStatus status = 6; |
| } |
| |
| // An ImageTransport allows for specifying a side channel for |
| // delivering image frames versus using the standard bytes array that is |
| // returned with the gRPC request. |
| message ImageTransport { |
| enum TransportChannel { |
| // Return full frames over the gRPC transport |
| TRANSPORT_CHANNEL_UNSPECIFIED = 0; |
| |
| // Write images to the a file/shared memory handle. |
| MMAP = 1; |
| } |
| |
| // The desired transport channel used for delivering image frames. Only |
| // relevant when streaming screenshots. |
| TransportChannel channel = 1; |
| |
| // Handle used for writing image frames if transport is mmap. The client sets |
| // and owns this handle. It can be either a shm region, or a mmap. A mmap |
| // should be a url that starts with `file:///` |
| // Note: the mmap can result in tearing. |
| string handle = 2; |
| } |
| |
| // The aspect ratio (width/height) will be different from the one |
| // where the device is unfolded. |
| message FoldedDisplay { |
| uint32 width = 1; |
| uint32 height = 2; |
| // It is possible for the screen to be folded in different ways depending |
| // on which surface is shown to the user. So xOffset and yOffset indicate |
| // the top left corner of the folded screen within the original unfolded screen. |
| uint32 xOffset = 3; |
| uint32 yOffset = 4; |
| } |
| |
| message ImageFormat { |
| enum ImgFormat { |
| // Portable Network Graphics format |
| // (https://en.wikipedia.org/wiki/Portable_Network_Graphics) |
| PNG = 0; |
| |
| // Three-channel RGB color model supplemented with a fourth alpha |
| // channel. https://en.wikipedia.org/wiki/RGBA_color_model |
| // Each pixel consists of 4 bytes. |
| RGBA8888 = 1; |
| |
| // Three-channel RGB color model, each pixel consists of 3 bytes |
| RGB888 = 2; |
| } |
| |
| // The (desired) format of the resulting bytes. |
| ImgFormat format = 1; |
| |
| // [Output Only] The rotation of the image. The image will be rotated |
| // based upon the coarse grained orientation of the device. |
| Rotation rotation = 2; |
| |
| // The (desired) width of the image. When passed as input |
| // the image will be scaled to match the given |
| // width, while maintaining the aspect ratio of the device. |
| // The returned image will never exceed the given width, but can be less. |
| // Omitting this value (or passing in 0) will result in no scaling, |
| // and the width of the actual device will be used. |
| uint32 width = 3; |
| |
| // The (desired) height of the image. When passed as input |
| // the image will be scaled to match the given |
| // height, while maintaining the aspect ratio of the device. |
| // The returned image will never exceed the given height, but can be less. |
| // Omitting this value (or passing in 0) will result in no scaling, |
| // and the height of the actual device will be used. |
| uint32 height = 4; |
| |
| // The (desired) display id of the device. Setting this to 0 (or omitting) |
| // indicates the main display. |
| uint32 display = 5; |
| |
| // Set this if you wish to use a different transport channel to deliver image |
| // frames. |
| ImageTransport transport = 6; |
| |
| // [Output Only] Display configuration when screen is folded. The value is the |
| // original configuration before scaling. |
| FoldedDisplay foldedDisplay = 7; |
| |
| // [Output Only] Display mode when AVD is resizable. |
| DisplayModeValue displayMode = 8; |
| } |
| |
| message Image { |
| ImageFormat format = 1; |
| |
| uint32 width = 2 [ deprecated = true ]; // width is contained in format. |
| uint32 height = 3 [ deprecated = true ]; // height is contained in format. |
| |
| // The organization of the pixels in the image buffer is from left to |
| // right and bottom up. This will be empty if an alternative image transport |
| // is requested in the image format. In that case the side channel should |
| // be used to obtain the image data. |
| bytes image = 4; |
| |
| // [Output Only] Monotonically increasing sequence number in a stream of |
| // screenshots. The first screenshot will have a sequence of 0. A single |
| // screenshot will always have a sequence number of 0. The sequence is not |
| // necessarily contiguous, and can be used to detect how many frames were |
| // dropped. An example sequence could be: [0, 3, 5, 7, 9, 11]. |
| uint32 seq = 5; |
| |
| // [Output Only] Unix timestamp in microseconds when the emulator estimates |
| // the frame was generated. The timestamp is before the actual frame is |
| // copied and transformed. This can be used to calculate variance between |
| // frame production time, and frame depiction time. |
| uint64 timestampUs = 6; |
| } |
| |
| message Rotation { |
| enum SkinRotation { |
| PORTRAIT = 0; // 0 degrees |
| LANDSCAPE = 1; // 90 degrees |
| REVERSE_PORTRAIT = 2; // -180 degrees |
| REVERSE_LANDSCAPE = 3; // -90 degrees |
| } |
| |
| // The rotation of the device, derived from the sensor state |
| // of the emulator. The derivation reflects how android observes |
| // the rotation state. |
| SkinRotation rotation = 1; |
| |
| // Specifies the angle of rotation, in degrees [-180, 180] |
| double xAxis = 2; |
| double yAxis = 3; |
| double zAxis = 4; |
| } |
| |
| message PhoneCall { |
| enum Operation { |
| InitCall = 0; |
| AcceptCall = 1; |
| RejectCallExplicit = 2; |
| RejectCallBusy = 3; |
| DisconnectCall = 4; |
| PlaceCallOnHold = 5; |
| TakeCallOffHold = 6; |
| } |
| Operation operation = 1; |
| string number = 2; |
| } |
| |
| message PhoneResponse { |
| enum Response { |
| OK = 0; |
| BadOperation = 1; // Enum out of range |
| BadNumber = 2; // Mal-formed telephone number |
| InvalidAction = 3; // E.g., disconnect when no call is in progress |
| ActionFailed = 4; // Internal error |
| RadioOff = 5; // Radio power off |
| } |
| Response response = 1; |
| } |
| |
| message Entry { |
| string key = 1; |
| string value = 2; |
| } |
| |
| message EntryList { repeated Entry entry = 1; } |
| |
| message EmulatorStatus { |
| // The emulator version string. |
| string version = 1; |
| |
| // The time the emulator has been active in .ms |
| uint64 uptime = 2; |
| |
| // True if the device has completed booting. |
| // For P and later this information will accurate, |
| // for older images we rely on adb. |
| bool booted = 3; |
| |
| // The current vm configuration |
| VmConfiguration vmConfig = 4; |
| |
| // The hardware configuration of the running emulator as |
| // key valure pairs. |
| EntryList hardwareConfig = 5; |
| } |
| |
| message AudioFormat { |
| enum SampleFormat { |
| AUD_FMT_U8 = 0; // Unsigned 8 bit |
| AUD_FMT_S16 = 1; // Signed 16 bit (little endian) |
| } |
| |
| enum Channels { |
| Mono = 0; |
| Stereo = 1; |
| } |
| |
| enum DeliveryMode { |
| // The audio queue will block and wait until the emulator requests packets. |
| // The client does not have to throttle and can push packets at will. |
| // This can result in the client falling behind. |
| MODE_UNSPECIFIED = 0; |
| // Audio packets will be delivered in real time (when possible). The audio queue |
| // will be overwritten with incoming data if data is made available. |
| // This means the client needs to control timing properly, or packets will get |
| // overwritten. |
| MODE_REAL_TIME = 1; // |
| } |
| // Sampling rate to use, defaulting to 44100 if this is not set. |
| // Note, that android devices typically will not use a sampling |
| // rate higher than 48kHz. See https://developer.android.com/ndk/guides/audio. |
| uint64 samplingRate = 1; |
| Channels channels = 2; |
| SampleFormat format = 3; |
| |
| // [Input Only] |
| // The mode used when delivering audio packets. |
| DeliveryMode mode = 4; |
| } |
| |
| message AudioPacket { |
| AudioFormat format = 1; |
| |
| // Unix epoch in us when this frame was captured. |
| uint64 timestamp = 2; |
| |
| // Contains a sample in the given audio format. |
| bytes audio = 3; |
| } |
| |
| message SmsMessage { |
| // The source address where this message came from. |
| // |
| // The address should be a valid GSM-formatted address as specified by |
| // 3GPP 23.040 Sec 9.1.2.5. |
| // |
| // For example: +3106225412 or (650) 555-1221 |
| string srcAddress = 1; |
| |
| // A utf8 encoded text message that should be delivered. |
| string text = 2; |
| } |
| |
| // A DisplayConfiguration describes a primary or secondary |
| // display available to the emulator. The screen aspect ratio |
| // cannot be longer (or wider) than 21:9 (or 9:21). Screen sizes |
| // larger than 4k will be rejected. |
| // |
| // Common configurations (w x h) are: |
| // - 480p (480x720) 142 dpi |
| // - 720p (720x1280) 213 dpi |
| // - 1080p (1080x1920) 320 dpi |
| // - 4K (2160x3840) 320 dpi |
| // - 4K (2160x3840) 640 dpi (upscaled) |
| // |
| // The behavior of the virtual display depends on the flags that are provided to |
| // this method. By default, virtual displays are created to be private, |
| // non-presentation and unsecure. |
| message DisplayConfiguration { |
| |
| // These are the set of known android flags and their respective values. |
| // you can combine the int values to (de)construct the flags field below. |
| enum DisplayFlags { |
| DISPLAYFLAGS_UNSPECIFIED = 0; |
| |
| // When this flag is set, the virtual display is public. |
| // A public virtual display behaves just like most any other display |
| // that is connected to the system such as an external or wireless |
| // display. Applications can open windows on the display and the system |
| // may mirror the contents of other displays onto it. see: |
| // https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_PUBLIC |
| VIRTUAL_DISPLAY_FLAG_PUBLIC = 1; |
| |
| // When this flag is set, the virtual display is registered as a |
| // presentation display in the presentation display category. |
| // Applications may automatically project their content to presentation |
| // displays to provide richer second screen experiences. |
| // https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_PRESENTATION |
| VIRTUAL_DISPLAY_FLAG_PRESENTATION = 2; |
| |
| // When this flag is set, the virtual display is considered secure as |
| // defined by the Display#FLAG_SECURE display flag. The caller promises |
| // to take reasonable measures, such as over-the-air encryption, to |
| // prevent the contents of the display from being intercepted or |
| // recorded on a persistent medium. |
| // see: |
| // https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_SECURE |
| VIRTUAL_DISPLAY_FLAG_SECURE = 4; |
| |
| // This flag is used in conjunction with VIRTUAL_DISPLAY_FLAG_PUBLIC. |
| // Ordinarily public virtual displays will automatically mirror the |
| // content of the default display if they have no windows of their own. |
| // When this flag is specified, the virtual display will only ever show |
| // its own content and will be blanked instead if it has no windows. See |
| // https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY |
| VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY = 8; |
| |
| // Allows content to be mirrored on private displays when no content is |
| // being shown. |
| // This flag is mutually exclusive with |
| // VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY. If both flags are specified |
| // then the own-content only behavior will be applied. |
| // see: |
| // https://developer.android.com/reference/android/hardware/display/DisplayManager#VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR) |
| VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR = 16; |
| } |
| |
| // The width of the display, restricted to: |
| // 320 * (dpi / 160) <= width |
| uint32 width = 1; |
| |
| // The heigh of the display, restricted to: |
| // * 320 * (dpi / 160) <= height |
| uint32 height = 2; |
| |
| // The pixel density (dpi). |
| // See https://developer.android.com/training/multiscreen/screendensities |
| // for details. This value should be in the range [120, ..., 640] |
| uint32 dpi = 3; |
| |
| // A combination of virtual display flags. These flags can be constructed |
| // by combining the DisplayFlags enum described above. |
| // |
| // The behavior of the virtual display depends on the flags. By default |
| // virtual displays are created to be private, non-presentation and |
| // unsecure. |
| uint32 flags = 4; |
| |
| // The id of the display. |
| // The primary (default) display has the display ID of 0. |
| // A secondary display has a display ID not 0. |
| // |
| // A display with the id in the range [1, userConfigurable] |
| // can be modified. See DisplayConfigurations below for details. |
| // |
| // The id can be used to get or stream a screenshot. |
| uint32 display = 5; |
| } |
| // Provides information about all the displays that can be attached |
| // to the emulator. The emulator will always have at least one display. |
| // |
| // The emulator usually has the following display configurations: |
| // 0: The default display. |
| // 1 - 3: User configurable displays. These can be added/removed. |
| // For example the standalone emulator allows you to modify these |
| // in the extended controls. |
| // 6 - 11: Fixed external displays. For example Android Auto uses fixed |
| // displays in this range. |
| message DisplayConfigurations { |
| repeated DisplayConfiguration displays = 1; |
| |
| // Display configurations with id [1, userConfigurable] are |
| // user configurable, that is they can be added, removed or |
| // updated. |
| uint32 userConfigurable = 2; |
| |
| // The maximum number of attached displays this emulator supports. |
| // This is the total number of displays that can be attached to |
| // the emulator. |
| // |
| // Note: A display with an id that is larger than userConfigurable cannot |
| // be modified. |
| uint32 maxDisplays = 3; |
| } |
| |
| message Notification { |
| enum EventType { |
| VIRTUAL_SCENE_CAMERA_INACTIVE = 0; |
| VIRTUAL_SCENE_CAMERA_ACTIVE = 1; |
| |
| // Fired when an update to a display event has been fired through |
| // the extended ui. This does not fire events when the display |
| // is changed through the console or gRPC endpoint. |
| DISPLAY_CONFIGURATIONS_CHANGED_UI = 2; |
| // Keep adding more for other event types |
| } |
| |
| EventType event = 1; |
| } |
| |
| message RotationRadian { |
| float x = 1; // x axis is horizontal and orthogonal to the view direction. |
| float y = 2; // y axis points up and is perpendicular to the floor. |
| float z = 3; // z axis is the view direction and is set to 0.0 in |
| // rotateVirtualSceneCamera call. |
| } |
| |
| message Velocity { |
| float x = 1; // x axis is horizontal and orthogonal to the view direction. |
| float y = 2; // y axis points up and is perpendicular to the floor. |
| float z = 3; // z axis is the view direction |
| } |
| |
| // must follow the definition in "external/qemu/android/hw-sensors.h" |
| message Posture { |
| enum PostureValue { |
| POSTURE_UNKNOWN = 0; |
| POSTURE_CLOSED = 1; |
| POSTURE_HALF_OPENED = 2; |
| POSTURE_OPENED = 3; |
| POSTURE_FLIPPED = 4; |
| POSTURE_TENT = 5; |
| POSTURE_MAX = 6; |
| } |
| PostureValue value = 3; |
| } |