@aiot-toolkit/emulator 2.0.6-beta.1 → 2.0.6-beta.11

package/lib/static/proto/emulator_controller.proto

@@ -57,6 +57,9 @@ service EmulatorController {
             returns (stream PhysicalModelValue) {}
 
     // Atomically set/get the current primary clipboard data.
+    // Note that a call to setClipboard will result in an immediate
+    // event for those who made a call to streamClipboard and are
+    // on a different channel than the one used to set the clipboard.
     rpc setClipboard(ClipData) returns (google.protobuf.Empty) {}
     rpc getClipboard(google.protobuf.Empty) returns (ClipData) {}
 
@@ -176,15 +179,13 @@ service EmulatorController {
     // 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) {}
+    // Deprecated, please use the streamLogcat method instead.
+    rpc getLogcat(LogMessage) returns (LogMessage) {
+        option deprecated = true;
+    }
 
-    // Streams the logcat output from the emulator. The first call
-    // can retrieve up to 128Kb. This call will not return.
+    // Streams the 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 streamLogcat(LogMessage) returns (stream LogMessage) {}
 
     // Transition the virtual machine to the desired state. Note that
@@ -233,10 +234,19 @@ service EmulatorController {
     rpc streamNotification(google.protobuf.Empty)
             returns (stream Notification) {}
 
-    // RotationRadian is relative to the camera's current orientation.
+    // Rotation angles are relative to the camera's current orientation.
+    // The coordinate system is right-handed and is defined as follows:
+    //   x axis is pointing right
+    //   y axis is pointing up
+    //   z axis is pointing towards the viewer
+    // The z component of rotation is not used when calling this method.
     rpc rotateVirtualSceneCamera(RotationRadian)
             returns (google.protobuf.Empty) {}
-    // Velocity is absolute
+    // Velocity is absolute and is measured in meters per second.
+    // The coordinate system is right-handed and is defined as follows:
+    //   x axis is pointing right
+    //   y axis is pointing up
+    //   z axis is pointing towards the viewer
     rpc setVirtualSceneCameraVelocity(Velocity)
             returns (google.protobuf.Empty) {}
     // Set foldable posture
@@ -262,6 +272,16 @@ service EmulatorController {
     // 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) {}
+
+    // Changes the XR-related settings. Fails if the AVD is not XR. The
+    // following gRPC error codes can be returned:
+    // -  FAILED_PRECONDITION (code 9) if the AVD is not XR.
+    rpc setXrOptions(XrOptions) returns (google.protobuf.Empty) {}
+
+    // Gets the current state of XR-related settings. Fails if the AVD is not
+    // XR. The following gRPC error codes can be returned:
+    // -  FAILED_PRECONDITION (code 9) if the AVD is not XR.
+    rpc getXrOptions(google.protobuf.Empty) returns (XrOptions) {}
 }
 
 // A Run State that describes the state of the Virtual Machine.
@@ -297,6 +317,12 @@ message VmRunState {
         // Guest experienced some error state, you cannot transition to this
         // state.
         INTERNAL_ERROR = 10;
+        // Completely restart the emulator.
+        RESTART = 11;
+        // Resume a stopped emulator
+        START = 12;
+        // Stop (pause) a running emulator
+        STOP = 13;
     }
 
     RunState state = 1;
@@ -470,6 +496,26 @@ message DisplayMode {
     DisplayModeValue value = 1;
 }
 
+message XrOptions {
+    enum Environment {
+        LIVING_ROOM_DAY = 0;
+        LIVING_ROOM_NIGHT = 1;
+        // More environments may be added later.
+    }
+
+    // The currently active artificial surrounding environment (a.k.a.
+    // passthrough environment).
+    Environment environment = 1;
+
+    // A value of 0.0 means that the real or artificial surrounding environment
+    // (a.k.a. passthrough environment) is not visible. A value of 1.0 means
+    // that the passthrough environment is fully visible. Any value outside of
+    // the range [0.0-1.0] is ignored and leaves the state of passthrough
+    // unchanged. For simplicity of the implementation, this number may be
+    // rounded to an integer before applying.
+    float passthrough_coefficient = 2;
+}
+
 message LogMessage {
     // [Output Only] The contents of the log output.
     string contents = 1;
@@ -477,11 +523,11 @@ message LogMessage {
     // 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;
+    int64 start = 2 [deprecated = true];
     //[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;
+    int64 next = 3 [deprecated = true];
 
     // Set the sort of response you are interested it in.
     // It the type is "Parsed" the entries field will contain the parsed
@@ -628,6 +674,21 @@ message Touch {
     }
 
     EventExpiration expiration = 7;
+
+    // The orientation of the contact, if any.
+    int32 orientation = 8;
+}
+
+// A Pen is similar to a touch, with the addition
+// of button and rubber information.
+message Pen {
+    Touch location = 1;
+
+    // True if the button is pressed or not
+    bool button_pressed = 2;
+
+    // True if it is a rubber pointer.
+    bool rubber_pointer = 3;
 }
 
 // A TouchEvent contains a list of Touch objects that are in contact with
@@ -643,9 +704,15 @@ message TouchEvent {
 
     // 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;
+}
+
+message PenEvent {
+    // The list of Pen objects, note that these do not need to be unique
+    repeated Pen events = 1;
+
+    // The display device where the pen event occurred.
+    // Omitting or using the value 0 indicates the main display.
     int32 display = 2;
 }
 
@@ -653,11 +720,11 @@ message TouchEvent {
 // 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.
+    // screen, where 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.
+    // The vertical coordinate. This is the physical location on the screen,
+    // where 0 indicates the topmost coordinate.
     int32 y = 2;
 
     // Indicates which buttons are pressed.
@@ -783,15 +850,57 @@ message KeyboardEvent {
     string text = 5;
 }
 
+message XrCommand {
+    enum Action {
+        // Recenter the viewport position and rotation.
+        RECENTER = 0;
+    }
+
+    Action action = 1;
+}
+
 // An input event that can be delivered to the emulator.
 message InputEvent {
     oneof type {
         KeyboardEvent key_event = 1;
         TouchEvent touch_event = 2;
         MouseEvent mouse_event = 3;
+        AndroidEvent android_event = 4;
+        PenEvent pen_event = 5;
+        WheelEvent wheel_event = 6;
+        MouseEvent xr_hand_event = 7;
+        MouseEvent xr_eye_event = 8;
+        XrCommand xr_command = 9;
+        RotationRadian xr_head_rotation_event = 10;
+        Translation xr_head_movement_event = 11;
+        AngularVelocity xr_head_angular_velocity_event = 12;
+        Velocity xr_head_velocity_event = 13;
     }
 };
 
+// The android input event system is a framework for handling input from a
+// variety of devices by generating events that describe changes in the
+// state of the devices and forwarding them to user space applications.
+//
+// An AndroidEvents will be delivered directly to the kernel as is.
+message AndroidEvent {
+    // The type of the event. The types of the event are specified
+    // by the android kernel. Some examples are:
+    // EV_SYN, EV_KEY, EV_SW, etc..
+    // The exact definitions can be found in the input.h header file.
+    int32 type = 1;
+
+    // The actual code to be send to the kernel. The actual meaning
+    // of the code depends on the type definition.
+    int32 code = 2;
+
+    // The actual value of the event.
+    int32 value = 3;
+
+    // The display id associated with this input event.
+    int32 display = 4;
+};
+
 message Fingerprint {
     // True when the fingprint is touched.
     bool isTouching = 1;
@@ -1054,6 +1163,17 @@ message EmulatorStatus {
     // The hardware configuration of the running emulator as
     // key valure pairs.
     EntryList hardwareConfig = 5;
+
+    // Some guests will produce a heart beat, that can be used to
+    // detect if the guest is active.
+    // This is a monotonically increasing number that gets incremented
+    // around once a second.
+    uint64 heartbeat = 6;
+
+    // The configuration of services in the guest, this map
+    // contains key value pairs that are specific to the image
+    // used by the guest.
+    map<string, string> guestConfig = 7;
 }
 
 message AudioFormat {
@@ -1258,11 +1378,17 @@ message Notification {
         DisplayConfigurationsChangedNotification
                 displayConfigurationsChangedNotification = 3;
         Posture posture = 4;
-        BootCompletedNotication booted = 5;
+        BootCompletedNotification booted = 5;
+        BrightnessValue brightness = 6;
+
+        // This notification is sent when a TextView receives or loses focus.
+        // It is also sent immediately in response to the streamNotification
+        // call.
+        TextViewFocus textViewFocus = 7;
     }
 }
 
-message BootCompletedNotication {
+message BootCompletedNotification {
     // The time in milliseconds it took for the boot to complete.
     // Note that this value can be 0 when you are loading from a snapshot.
     int32 time = 1;
@@ -1277,6 +1403,15 @@ message CameraNotification {
     int32 display = 2;
 }
 
+message TextViewFocus {
+    // Indicates whether a text view currently has focus.
+    bool textViewHasFocus = 1;
+
+    // If a text view has focus, the display where the text view is located.
+    // Otherwise, unset.
+    int32 display = 2;
+}
+
 // 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 the gRPC endpoint.
@@ -1285,16 +1420,36 @@ message DisplayConfigurationsChangedNotification {
 }
 
 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.
+    // Components of the rotation vector in radians.
+    // Rotation angles are relative to the current orientation.
+    float x = 1;  // Angle of rotation around the x axis in right-handed direction.
+    float y = 2;  // Angle of rotation around the y axis in right-handed direction.
+    float z = 3;  // Angle of rotation around the z axis in right-handed direction.
+}
+
+message Translation {
+    // Components of the translation vector in meters.
+    float delta_x = 1;
+    float delta_y = 2;
+    float delta_z = 3;
+}
+
+message AngularVelocity {
+    // Components of the target angular velocity vector in radians per second.
+    // Transition to these values is implementation dependent, and may be
+    // smoothed over time.
+    float omega_x = 1;
+    float omega_y = 2;
+    float omega_z = 3;
 }
 
 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
+    // Components of the target velocity vector in meters per second.
+    // Transition to these values is implementation dependent, and may be
+    // smoothed over time.
+    float x = 1;
+    float y = 2;
+    float z = 3;
 }
 
 // Must follow the definition in "external/qemu/android/hw-sensors.h"

package/lib/static/proto/ui_controller_service.proto

@@ -0,0 +1,147 @@
+// Copyright 2020 Google LLC
+//
+// 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.
+
+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";
+
+service UiController {
+    // PaneEntry specifies which pane will be selected when
+    // the extended control is shown. If the extended is visible already,
+    // this method will set visibilityChangedto to false.
+    rpc showExtendedControls(PaneEntry) returns (ExtendedControlsStatus) {}
+    // this method has no effect if the extended controls are hidden.
+    // In that case, visibilityChanged will be set to false;
+    rpc closeExtendedControls(google.protobuf.Empty)
+            returns (ExtendedControlsStatus) {}
+    rpc setUiTheme(ThemingStyle) returns (google.protobuf.Empty) {}
+
+    // Returns the user configuration of the running emulator. The user
+    // configuration contains information about the user interface.
+    rpc getUserConfig(google.protobuf.Empty) returns (UserConfig) {}
+}
+
+message UserConfigEntry {
+    string key = 1;
+    string value = 2;
+}
+
+// The user configuration of the running emulator as
+// key value pairs. This contains the data you normally find
+// in emulator-user.ini
+message UserConfig {
+    repeated UserConfigEntry entries = 1;
+}
+
+message ThemingStyle {
+    enum Style {
+        LIGHT = 0;
+        DARK = 1;
+        CONTRAST = 2;
+    }
+    Style style = 1;
+}
+
+message ExtendedControlsStatus {
+    bool visibilityChanged = 1;
+}
+
+// The pixel coordinates are resolution independent, meaning the coordinates
+// are independent from the pixel grid, resulting in a graphical user
+// interface that is displayed at a consistent location, regardless of the
+// resolution of the screen.
+//
+// For technical details: https://doc.qt.io/qt-5/highdpi.html
+//
+// Some things to note:
+//
+// - You cannot move a window offscreen.
+// - There is a padding of around 10px around the frame.
+//
+// This means that moving to (0, 0) or (10, 10) will have the same result.
+// This means that anchoring might not exactly behave as requested.
+message WindowPosition {
+    // Anchor that is used to determine horizontal window placement.
+    enum HorizontalAnchor {
+        LEFT = 0;  // The x coordinate will be treated as the left edge of the
+                   // window.
+        HCENTER = 1;  // The x coordinate will be treated as the middle between
+                      // the left and right edges of the window.
+        RIGHT = 2;    // The x coordinate will be treated as the right edge of
+                      // the window.
+    }
+
+    // Anchor that is used to determine vertical window placement.
+    enum VerticalAnchor {
+        TOP = 0;      // The y coordinate will be treated as the top edge of the
+                      // window.
+        VCENTER = 1;  // The y coordinate will be treated as the middle between
+                      // the top and bottom edges of the window.
+        BOTTOM = 3;   // The y coordinate will be treated as the bottom edge of
+                      // the window.
+    }
+
+    // Corresponds to the x and y coordinate of the window geometry. The window
+    // geometry includes the window frame.
+    // See: https://doc.qt.io/qt-5/application-windows.html#window-geometry for
+    // details and pecularities on linux.
+    uint32 x = 1;
+    uint32 y = 2;
+
+    HorizontalAnchor horizontalAnchor = 3;
+    VerticalAnchor verticalAnchor = 4;
+}
+
+message PaneEntry {
+    enum PaneIndex {
+        // When specified as KEEP_CURRENT, extended controls will display the
+        // current pane.
+        // If it is the first time for extended controls to be shown, LOCATION
+        // will be used.
+        KEEP_CURRENT = 0;
+        // Referenced from
+        // external/qemu/android/android-emu/android/skin/qt/extended-window-styles.h
+        LOCATION = 1;
+        MULTIDISPLAY = 2;
+        CELLULAR = 3;
+        BATTERY = 4;
+        CAMERA = 5;
+        TELEPHONE = 6;
+        DPAD = 7;
+        TV_REMOTE = 8;
+        ROTARY = 9;
+        MICROPHONE = 10;
+        FINGER = 11;
+        VIRT_SENSORS = 12;
+        SNAPSHOT = 13;
+        BUGREPORT = 14;
+        RECORD = 15;
+        GOOGLE_PLAY = 16;
+        SETTINGS = 17;
+        HELP = 18;
+        CAR = 19;
+        CAR_ROTARY = 20;
+        SENSOR_REPLAY = 21;
+    };
+    PaneIndex index = 1;
+
+    // Set the window position to the specified coordinates if no coordinates are
+    // present in the AVD, otherwise this value will be igonred.
+    WindowPosition position = 2;
+}

package/lib/typing/Vvd.d.ts

@@ -27,8 +27,9 @@ export interface IVvdParams {
     flavor?: string;
     density?: string;
     customLcdRadius?: string;
-    imageType: VelaImageType;
+    imageType?: VelaImageType;
     skinInfo?: EmulatorSkin;
+    marketName?: string;
 }
 export interface EmulatorPart {
     display: {
@@ -100,7 +101,8 @@ export declare enum SDKParts {
     QA = "qa",
     SKINS = "skins",
     SYSTEM_IMAGES = "system-images",
-    MODEM_SIMULATOR = "modem_simulator"
+    MODEM_SIMULATOR = "modem_simulator",
+    TOOLS = "tools"
 }
 export declare enum VELAHOME {
     SDK = ".vela/sdk",

package/lib/typing/Vvd.js

@@ -23,6 +23,7 @@ let SDKParts = exports.SDKParts = /*#__PURE__*/function (SDKParts) {
   SDKParts["SKINS"] = "skins";
   SDKParts["SYSTEM_IMAGES"] = "system-images";
   SDKParts["MODEM_SIMULATOR"] = "modem_simulator";
+  SDKParts["TOOLS"] = "tools";
   return SDKParts;
 }({});
 let VELAHOME = exports.VELAHOME = /*#__PURE__*/function (VELAHOME) {

package/lib/vvd/grpc/index.d.ts

@@ -1,27 +1,35 @@
 import { Readable } from 'stream';
-import { MouseEvent } from './types/MouseEvent';
-import { GrpcKeyboardEvent } from './types/KeyEvent';
 import { GrpcClient } from './types/GrpcClient';
 import { EmulatorConfig } from '../../emulatorutil/running';
 import { Metadata } from '@grpc/grpc-js';
-export default class GrpcEmulator {
+import { ImageFormat, KeyboardEvent, LogMessage, MouseEvent, SensorValue } from './types/proto-types';
+import { UiControllerClient } from './types/UiControllerClient';
+export declare const AuthorizationKey = "Authorization";
+export declare class GrpcEmulator {
     eConf: EmulatorConfig;
-    protoPath: string;
+    protoPath: string[];
+    ip: string;
     client: GrpcClient;
+    uiClient: UiControllerClient;
     connected: boolean;
     token: string;
     authMate: Metadata;
-    deadline: Date;
     controller: any;
     screenshotStream?: Readable;
-    constructor(eConf: EmulatorConfig, protoPath: string);
+    logcatStream?: Readable;
+    constructor(eConf: EmulatorConfig, protoPath: string[], ip?: string);
     close(): void;
     getAuthMeta(): Metadata;
     waitForReady(): Promise<boolean>;
-    startStream(onStreamScreenshot: (buffer: Buffer) => void): Promise<void>;
+    streamScreenshot(imageFormat?: ImageFormat): Promise<Readable>;
     getScreenshot(): Promise<Buffer>;
     getStatus(): Promise<unknown>;
     sendMouse(message: MouseEvent): void;
-    sendKey(data: GrpcKeyboardEvent): void;
+    sendKey(data: KeyboardEvent): void;
+    showExtendedControls(paneIndex?: number): Promise<unknown>;
+    closeExtendedControls(): Promise<unknown>;
+    setSensor(sensorValue: SensorValue): Promise<unknown>;
+    getSensor(sensorValue: SensorValue): Promise<unknown>;
+    streamLogcat(params?: LogMessage): Promise<Readable>;
 }
 export declare function createGrpcClient(eConf: EmulatorConfig): GrpcEmulator;