| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // API for integration testing. To be used on test images with a test component |
| // extension. |
| [platforms=("chromeos"), |
| implemented_in="chrome/browser/chromeos/extensions/autotest_private/autotest_private_api.h"] |
| namespace autotestPrivate { |
| |
| enum ShelfAlignmentType { |
| // BottomLocked not supported by shelf_prefs. |
| Bottom, Left, Right |
| }; |
| |
| // A mapping of ash::ShelfItemType. |
| enum ShelfItemType { |
| App, |
| PinnedApp, |
| BrowserShortcut, |
| Dialog |
| }; |
| |
| // A mapping of ash::ShelfItemStatus. |
| enum ShelfItemStatus { |
| Closed, |
| Running, |
| Attention |
| }; |
| |
| // A mapping of apps::mojom::Type |
| enum AppType { |
| Arc, |
| BuiltIn, |
| Crostini, |
| Extension, |
| Web, |
| MacNative, |
| PluginVm, |
| Lacros |
| }; |
| |
| // A mapping of apps::mojom::Readiness |
| enum AppReadiness { |
| Ready, |
| DisabledByBlacklist, |
| DisabledByPolicy, |
| DisabledByUser, |
| Terminated, |
| UninstalledByUser |
| }; |
| |
| // A subset of Window State types in ash::WindowStateType. We may add more |
| // into the set in the future. |
| enum WindowStateType { |
| Normal, |
| Minimized, |
| Maximized, |
| Fullscreen, |
| LeftSnapped, |
| RightSnapped, |
| PIP |
| }; |
| |
| // A subset of WM event types in ash::WMEventType. We may add more in the |
| // set in the future. |
| enum WMEventType { |
| WMEventNormal, |
| WMEventMaximize, |
| WMEventMinimize, |
| WMEventFullscreen, |
| WMEventSnapLeft, |
| WMEventSnapRight |
| }; |
| |
| // Display orientation type. |
| enum RotationType { |
| Rotate0, |
| Rotate90, |
| Rotate180, |
| Rotate270 |
| }; |
| |
| enum LauncherStateType { |
| Closed, |
| Peeking, |
| Half, |
| FullscreenAllApps, |
| FullscreenSearch |
| }; |
| |
| enum OverviewStateType { |
| Shown, |
| Hidden |
| }; |
| |
| enum MouseButton { |
| Left, |
| Middle, |
| Right |
| }; |
| |
| // A paramter used in setArcAppWindowState() function. |
| dictionary WindowStateChangeDict { |
| // The WM event to change the ARC window state. |
| WMEventType eventType; |
| |
| // If the initial state is already same as the expected state, should we |
| // treat this case as a failure? Default value is false. |
| boolean? failIfNoChange; |
| }; |
| |
| dictionary LoginStatusDict { |
| // Are we logged in? |
| boolean isLoggedIn; |
| // Is the logged-in user the owner? |
| boolean isOwner; |
| // Is the screen locked? |
| boolean isScreenLocked; |
| // Is the screen ready for password? |
| boolean isReadyForPassword; |
| |
| // Is the logged-in user a regular user? |
| boolean isRegularUser; |
| // Are we logged into the guest account? |
| boolean isGuest; |
| // Are we logged into kiosk-app mode? |
| boolean isKiosk; |
| |
| DOMString email; |
| DOMString displayEmail; |
| // User image: 'file', 'profile' or a number. |
| DOMString userImage; |
| }; |
| callback LoginStatusCallback = void (LoginStatusDict status); |
| |
| // |all_policies| will be the full list of policies as returned by the |
| // DictionaryPolicyConversions.ToValue function. |
| callback AllEnterprisePoliciesCallback = void (any all_policies); |
| |
| dictionary ExtensionInfoDict { |
| DOMString id; |
| DOMString version; |
| DOMString name; |
| DOMString publicKey; |
| DOMString description; |
| DOMString backgroundUrl; |
| DOMString optionsUrl; |
| |
| DOMString[] hostPermissions; |
| DOMString[] effectiveHostPermissions; |
| DOMString[] apiPermissions; |
| |
| boolean isComponent; |
| boolean isInternal; |
| boolean isUserInstalled; |
| boolean isEnabled; |
| boolean allowedInIncognito; |
| boolean hasPageAction; |
| }; |
| dictionary ExtensionsInfoArray { |
| ExtensionInfoDict[] extensions; |
| }; |
| callback ExtensionsInfoCallback = void (ExtensionsInfoArray info); |
| |
| dictionary Notification { |
| DOMString id; |
| DOMString type; |
| DOMString title; |
| DOMString message; |
| long priority; |
| long progress; |
| }; |
| callback NotificationArrayCallback = void (Notification[] notifications); |
| |
| dictionary Printer { |
| DOMString printerName; |
| DOMString? printerId; |
| DOMString? printerType; |
| DOMString? printerDesc; |
| DOMString? printerMakeAndModel; |
| DOMString? printerUri; |
| DOMString? printerPpd; |
| }; |
| callback PrinterArrayCallback = void (Printer[] printers); |
| |
| callback ArcStartTimeCallback = void (double startTime); |
| |
| dictionary ArcState { |
| // Whether the ARC is provisioned. |
| boolean provisioned; |
| // Whether ARC Terms of Service needs to be shown. |
| boolean tosNeeded; |
| }; |
| callback ArcStateCallback = void (ArcState result); |
| |
| dictionary PlayStoreState { |
| // Whether the Play Store allowed for the current user. |
| boolean allowed; |
| // Whether the Play Store currently enabled. |
| boolean? enabled; |
| // Whether the Play Store managed by policy. |
| boolean? managed; |
| }; |
| callback PlayStoreStateCallback = void (PlayStoreState result); |
| |
| dictionary AssistantQueryResponse { |
| // Text response returned from server. |
| DOMString? text; |
| // HTML response returned from server, usually accompanied with |
| // fallback text. |
| DOMString? htmlResponse; |
| // Text messages used as the "fallback" for HTML card rendering. |
| // Generally the fallback text is similar to transcribed TTS, |
| // e.g. "It's exactly 6 o'clock." or "Turning bluetooth off.". |
| DOMString? htmlFallback; |
| }; |
| dictionary AssistantQueryStatus { |
| // Indicates whether this might be a voice interaction. |
| boolean isMicOpen; |
| // Query text sent to Assistant. In the event of a voice interaction, |
| // this field will be same as the speech recognition final result. |
| DOMString queryText; |
| // Response for the current query. |
| AssistantQueryResponse queryResponse; |
| }; |
| callback AssistantQueryStatusCallback = void (AssistantQueryStatus status); |
| |
| callback IsAppShownCallback = void (boolean appShown); |
| |
| callback IsArcProvisionedCallback = void (boolean arcProvisioned); |
| |
| callback IsArcPackageListInitialRefreshedCallback = void (boolean refreshed); |
| |
| dictionary ArcAppDict { |
| DOMString name; |
| DOMString packageName; |
| DOMString activity; |
| DOMString intentUri; |
| DOMString iconResourceId; |
| double lastLaunchTime; |
| double installTime; |
| boolean sticky; |
| boolean notificationsEnabled; |
| boolean ready; |
| boolean suspended; |
| boolean showInLauncher; |
| boolean shortcut; |
| boolean launchable; |
| }; |
| callback GetArcAppCallback = void (ArcAppDict package); |
| |
| dictionary ArcPackageDict { |
| DOMString packageName; |
| long packageVersion; |
| DOMString lastBackupAndroidId; |
| double lastBackupTime; |
| boolean shouldSync; |
| boolean system; |
| boolean vpnProvider; |
| }; |
| callback GetArcPackageCallback = void (ArcPackageDict package); |
| |
| dictionary Location { |
| double x; |
| double y; |
| }; |
| |
| dictionary Bounds { |
| double left; |
| double top; |
| double width; |
| double height; |
| }; |
| |
| dictionary ArcAppTracingInfo { |
| boolean success; |
| double fps; |
| double commitDeviation; |
| double renderQuality; |
| }; |
| |
| callback LaunchArcAppCallback = void (boolean appLaunched); |
| |
| callback TakeScreenshotCallback = void (DOMString base64Png); |
| |
| callback GetPrimaryDisplayScaleFactorCallback = void (double scaleFactor); |
| |
| callback IsTabletModeEnabledCallback = void (boolean enabled); |
| |
| callback SetTabletModeEnabledCallback = void(boolean enabled); |
| |
| callback SetOverviewModeStateCallback = void(boolean finished); |
| |
| callback ArcAppTracingCallback = void(ArcAppTracingInfo info); |
| |
| callback WaitForDisplayRotationCallback = void (boolean success); |
| |
| callback InstallPWAForCurrentURLCallback = void (DOMString appId); |
| |
| dictionary App { |
| DOMString appId; |
| DOMString name; |
| DOMString shortName; |
| AppType? type; |
| AppReadiness? readiness; |
| DOMString[] additionalSearchTerms; |
| boolean? showInLauncher; |
| boolean? showInSearch; |
| }; |
| |
| callback GetAllInstalledAppsCallback = void (App[] apps); |
| |
| dictionary ShelfItem { |
| DOMString appId; |
| DOMString launchId; |
| DOMString title; |
| ShelfItemType? type; |
| ShelfItemStatus status; |
| boolean showsTooltip; |
| boolean pinnedByPolicy; |
| boolean hasNotification; |
| }; |
| |
| // A mapping of ash::AppType. |
| enum AppWindowType { |
| Browser, |
| ChromeApp, |
| ArcApp, |
| CrostiniApp, |
| SystemApp, |
| ExtensionApp |
| }; |
| |
| // A mapping of HotseatState in ash/public/cpp/shelf_types.h. |
| enum HotseatState { |
| Hidden, |
| ShownClamShell, |
| ShownHomeLauncher, |
| Extended |
| }; |
| |
| // The frame mode of a window. None if the window is framesless. |
| enum FrameMode { |
| Normal, |
| Immersive |
| }; |
| |
| dictionary OverviewInfo { |
| // Bounds in screen of an OverviewItem. |
| Bounds bounds; |
| // Whether an OverviewItem is being dragged in overview. |
| boolean isDragged; |
| }; |
| |
| dictionary AppWindowInfo { |
| // The identifier of the window. This shouldn't change across the time. |
| long id; |
| |
| // The name of the window object -- typically internal class name of the |
| // window (like 'BrowserFrame'). |
| DOMString name; |
| |
| AppWindowType windowType; |
| WindowStateType stateType; |
| |
| // The bounds of the window, in the coordinate of the root window (i.e. |
| // relative to the display where this window resides). |
| Bounds boundsInRoot; |
| |
| // The identifier of the display where this window resides. |
| DOMString displayId; |
| |
| boolean isVisible; |
| boolean canFocus; |
| |
| // The title of the window; this can be seen in the window caption, or in |
| // the overview mode. Typically, this provides the title of the webpage or |
| // the title supplied by the application. |
| DOMString title; |
| |
| // Whether some animation is ongoing on the window or not. |
| boolean isAnimating; |
| |
| // The final bounds of the window when the animation completes. This should |
| // be same as |boundsInRoot| when |isAnimating| is false. |
| Bounds targetBounds; |
| |
| // Whether or not the window is going to be visible after the animation |
| // completes. This should be same as |isVisible| when |isAnimating| is |
| // false. |
| boolean targetVisibility; |
| |
| // WM Releated states |
| boolean isActive; |
| boolean hasFocus; |
| boolean onActiveDesk; |
| boolean hasCapture; |
| boolean canResize; |
| |
| // Window frame info |
| FrameMode frameMode; |
| boolean isFrameVisible; |
| long captionHeight; |
| // The bitset of the enabled caption buttons. See |
| // ui/views/window/caption_button_types.h. |
| long captionButtonEnabledStatus; |
| // The bitset of the caption buttons which are visible on the frame. |
| long captionButtonVisibleStatus; |
| |
| DOMString? arcPackageName; |
| |
| OverviewInfo? overviewInfo; |
| }; |
| |
| dictionary Accelerator { |
| DOMString keyCode; |
| boolean shift; |
| boolean control; |
| boolean alt; |
| boolean search; |
| boolean pressed; |
| }; |
| |
| // Mapped to ScrollableShelfState in ash/public/cpp/shelf_ui_info.h. |
| // [deprecated="Use ShelfState"] |
| dictionary ScrollableShelfState { |
| double? scrollDistance; |
| }; |
| |
| // Mapped to ShelfState in ash/public/cpp/shelf_ui_info.h. |
| dictionary ShelfState { |
| double? scrollDistance; |
| }; |
| |
| // Mapped to ScrollableShelfInfo in ash/public/cpp/shelf_ui_info.h. |
| // |targetMainAxisOffset| is set when ShelfState used in query |
| // specifies the scroll distance. |
| dictionary ScrollableShelfInfo { |
| double mainAxisOffset; |
| double pageOffset; |
| double? targetMainAxisOffset; |
| Bounds leftArrowBounds; |
| Bounds rightArrowBounds; |
| boolean isAnimating; |
| boolean isOverflow; |
| Bounds[] iconsBoundsInScreen; |
| boolean isShelfWidgetAnimating; |
| }; |
| |
| // Mapped to HotseatSwipeDescriptor in ash/public/cpp/shelf_ui_info.h. |
| dictionary HotseatSwipeDescriptor { |
| Location swipeStartLocation; |
| Location swipeEndLocation; |
| }; |
| |
| // Mapped to HotseatInfo in ash/public/cpp/shelf_ui_info.h. |
| dictionary HotseatInfo { |
| HotseatSwipeDescriptor swipeUp; |
| HotseatState state; |
| boolean isAnimating; |
| }; |
| |
| // The ui information of shelf components, including hotseat and |
| // scrollable shelf. |
| dictionary ShelfUIInfo { |
| HotseatInfo hotseatInfo; |
| ScrollableShelfInfo scrollableShelfInfo; |
| }; |
| |
| callback GetShelfItemsCallback = void (ShelfItem[] items); |
| |
| callback GetShelfAutoHideBehaviorCallback = void (DOMString behavior); |
| |
| callback GetShelfAlignmentCallback = void (ShelfAlignmentType alignment); |
| |
| callback WindowStateCallback = void (WindowStateType currentType); |
| |
| callback VoidCallback = void (); |
| |
| callback DOMStringCallback = void (DOMString data); |
| |
| callback GetAppWindowListCallback = void (AppWindowInfo[] window_list); |
| |
| callback AcceleratorCallback = void (boolean success); |
| |
| callback DesksCallback = void (boolean success); |
| |
| callback GetScrollableShelfInfoForStateCallback = void ( |
| ScrollableShelfInfo info); |
| |
| callback GetShelfUIInfoForStateCallback = void (ShelfUIInfo info); |
| |
| dictionary TraceConfig { |
| // The recording mode of the trace. Possible options are: |
| // "record-until-full", "record-continuously", "record-as-much-as-possible", |
| // and "trace-to-console". |
| DOMString? record_mode; |
| // Stop trace after capturing |trace_buffer_size_in_events| events. |
| long? trace_buffer_size_in_events; |
| // Stop trace after capturing |trace_buffer_size_in_kb| kilobytes worth of |
| // events. |
| long? trace_buffer_size_in_kb; |
| // Determines whether systrace events should be included in the trace. |
| boolean? enable_systrace; |
| // Enables argument filter. |
| boolean? enable_argument_filter; |
| // A list of categories that should be included in the trace. |
| DOMString[]? included_categories; |
| // A list of categories that should be excluded from the the trace. |
| DOMString[]? excluded_categories; |
| // A list of processes from which events should be included in the trace. If |
| // this parameter is empty or missing, traces from all processes are |
| // included. |
| DOMString[]? included_process_ids; |
| // A list of Systrace events that will be included in the trace. |
| DOMString[]? enable_systrace_events; |
| }; |
| |
| // Defines a callback that will be run when the trace is complete. The parameter |
| // |data| contains the result of the trace in Trace Event JSON format. |
| callback TraceCompleteCallback = void (DOMString data); |
| |
| // Result of calling setWindowBounds, which returns the actual bounds and |
| // display the window was set to. This may be different than the requested |
| // bounds and display, for example if the window is showing an ARC app and |
| // Android modifies the bounds request. Further, this result may never be |
| // returned in some situations (e.g. Android ignoring a bounds request), |
| // causing a timeout. |
| dictionary SetWindowBoundsResult { |
| // Bounds of the window. |
| Bounds bounds; |
| // Display ID of the display the window is on. |
| DOMString displayId; |
| }; |
| callback WindowBoundsCallback = void (SetWindowBoundsResult result); |
| |
| // Callback invoked to report the smoothness after StopSmoothnessTracking is |
| // called. |smoothness| is a percentage number between 0 to 100. |
| callback StopSmoothnessTrackingCallback = void (long smoothness); |
| |
| interface Functions { |
| // Must be called to allow autotestPrivateAPI events to be fired. |
| static void initializeEvents(); |
| |
| // Logout of a user session. |
| static void logout(); |
| |
| // Restart the browser. |
| static void restart(); |
| |
| // Shutdown the browser. |
| // |force|: if set, ignore ongoing downloads and onunbeforeunload handlers. |
| static void shutdown(boolean force); |
| |
| // Get login status. |
| static void loginStatus(LoginStatusCallback callback); |
| |
| // Locks the screen. |
| static void lockScreen(); |
| |
| // Get info about installed extensions. |
| static void getExtensionsInfo(ExtensionsInfoCallback callback); |
| |
| // Get state of the policies. |
| // Will contain device policies and policies from the active profile. |
| // The policy values are formatted as they would be for exporting in |
| // chrome://policy. |
| static void getAllEnterprisePolicies( |
| AllEnterprisePoliciesCallback callback); |
| |
| // Refreshes the Enterprise Policies. |
| static void refreshEnterprisePolicies(VoidCallback callback); |
| |
| // Simulates a memory access bug for asan testing. |
| static void simulateAsanMemoryBug(); |
| |
| // Set the touchpad pointer sensitivity setting. |
| // |value|: the pointer sensitivity setting index. |
| static void setTouchpadSensitivity(long value); |
| |
| // Turn on/off tap-to-click for the touchpad. |
| // |enabled|: if set, enable tap-to-click. |
| static void setTapToClick(boolean enabled); |
| |
| // Turn on/off three finger click for the touchpad. |
| // |enabled|: if set, enable three finger click. |
| static void setThreeFingerClick(boolean enabled); |
| |
| // Turn on/off tap dragging for the touchpad. |
| // |enabled|: if set, enable tap dragging. |
| static void setTapDragging(boolean enabled); |
| |
| // Turn on/off Australian scrolling for devices other than wheel mouse. |
| // |enabled|: if set, enable Australian scrolling. |
| static void setNaturalScroll(boolean enabled); |
| |
| // Set the mouse pointer sensitivity setting. |
| // |value|: the pointer sensitivity setting index. |
| static void setMouseSensitivity(long value); |
| |
| // Swap the primary mouse button for left click. |
| // |right|: if set, swap the primary mouse button. |
| static void setPrimaryButtonRight(boolean right); |
| |
| // Turn on/off reverse scrolling for mice. |
| // |enabled|: if set, enable reverse scrolling. |
| static void setMouseReverseScroll(boolean enabled); |
| |
| // Get visible notifications on the system. |
| static void getVisibleNotifications(NotificationArrayCallback callback); |
| |
| // Get ARC start time. |
| static void getArcStartTime(ArcStartTimeCallback callback); |
| |
| // Get state of the ARC session. |
| static void getArcState(ArcStateCallback callback); |
| |
| // Get state of the Play Store. |
| static void getPlayStoreState(PlayStoreStateCallback callback); |
| |
| // Get list of available printers |
| static void getPrinterList(PrinterArrayCallback callback); |
| |
| // Returns true if requested app is shown in Chrome. |
| static void isAppShown(DOMString appId, IsAppShownCallback callback); |
| |
| // Returns true if ARC is provisioned. |
| // [deprecated="Use getArcState()"] |
| static void isArcProvisioned(IsArcProvisionedCallback callback); |
| |
| // Gets information about the requested ARC app. |
| static void getArcApp(DOMString appId, GetArcAppCallback callback); |
| |
| // Gets information about requested ARC package. |
| static void getArcPackage(DOMString packageName, |
| GetArcPackageCallback callback); |
| |
| // Launches ARC app with optional intent. Returns true if ARC is active, |
| // app exists and launch request is passed to Android. |
| static void launchArcApp(DOMString appId, DOMString intent, |
| LaunchArcAppCallback callback); |
| |
| // Launches an application from the launcher with the given appId. |
| static void launchApp(DOMString appId, VoidCallback callback); |
| |
| // Closes an application the given appId in case it was running. |
| static void closeApp(DOMString appId, VoidCallback callback); |
| |
| // Update printer. Printer with empty ID is considered new. |
| static void updatePrinter(Printer printer); |
| |
| // Remove printer. |
| static void removePrinter(DOMString printerId); |
| |
| // Enable/disable the Play Store. |
| // |enabled|: if set, enable the Play Store. |
| // |callback|: Called when the operation has completed. |
| static void setPlayStoreEnabled(boolean enabled, VoidCallback callback); |
| |
| // Get text from ui::Clipboard. |
| // |callback|: Called with result. |
| static void getClipboardTextData(DOMStringCallback callback); |
| |
| // Set text in ui::Clipbaord. |
| // |callback|: Called when operation is complete. |
| static void setClipboardTextData(DOMString data, VoidCallback callback); |
| |
| // Run the crostini installer GUI to install the default crostini |
| // vm / container and create sshfs mount. The installer launches the |
| // crostini terminal app on completion. The installer expects that |
| // crostini is not already installed. |
| // |callback|: Called when the operation has completed. |
| static void runCrostiniInstaller(VoidCallback callback); |
| |
| // Run the crostini uninstaller GUI to remove the default crostini |
| // vm / container. The callback is invoked upon completion. |
| static void runCrostiniUninstaller(VoidCallback callback); |
| |
| // Enable/disable Crostini in preferences. |
| // |enabled|: Enable Crostini. |
| // |callback|: Called when the operation has completed. |
| static void setCrostiniEnabled(boolean enabled, VoidCallback callback); |
| |
| // Export the crostini container. |
| // |path|: The path in Downloads to save the export. |
| // |callback|: Called when the operation has completed. |
| static void exportCrostini(DOMString path, VoidCallback callback); |
| |
| // Import the crostini container. |
| // |path|: The path in Downloads to read the import. |
| // |callback|: Called when the operation has completed. |
| static void importCrostini(DOMString path, VoidCallback callback); |
| |
| // Sets mock Plugin VM policy. |
| // |imageUrl|: URL to the image to install. |
| // |imageHash|: Hash for the provided image. |
| // |licenseKey|: License key for Plugin VM. |
| static void setPluginVMPolicy(DOMString imageUrl, |
| DOMString imageHash, |
| DOMString licenseKey); |
| |
| // Shows the Plugin VM installer. Does not start installation. |
| static void showPluginVMInstaller(); |
| |
| // Register a component with CrOSComponentManager. |
| // |name|: The name of the component. |
| // |path|: Path to the component. |
| static void registerComponent(DOMString name, DOMString path); |
| |
| // Takes a screenshot and returns the data in base64 encoded PNG format. |
| static void takeScreenshot(TakeScreenshotCallback callback); |
| |
| // Tasks a screenshot for a display. |
| // |display_id|: the display id of the display. |
| // |callback|: called when the operation has completed. |
| static void takeScreenshotForDisplay(DOMString display_id, |
| TakeScreenshotCallback callback); |
| |
| // Makes a basic request to ML Service, triggering 1. ML Service |
| // daemon startup, and 2. the initial D-Bus -> Mojo IPC bootstrap. |
| // |callback|: Called when the operation has completed. |
| static void bootstrapMachineLearningService(VoidCallback callback); |
| |
| // Enables/disables the Google Assistant. |
| // |callback|: Called when the operation has completed. |
| static void setAssistantEnabled(boolean enabled, long timeout_ms, |
| VoidCallback callback); |
| |
| // Bring up the Assistant service, and wait for the ready signal. |
| // |callback|: Called when the operation has completed. |
| static void enableAssistantAndWaitForReady(VoidCallback callback); |
| |
| // Sends a text query via Google Assistant. |
| // |callback|: Called when response has been received. |
| static void sendAssistantTextQuery(DOMString query, long timeout_ms, |
| AssistantQueryStatusCallback callback); |
| |
| // Invokes |callback| once the current text/voice interaction is completed. |
| // Responds with the the query status if any valid response was caught |
| // before the timeout. This API should be called before sending the query. |
| // To use it for testing a voice query via OKG in Autotest, for example, |
| // you can do: |
| // |
| // // Enable hotword setting for Assistant. |
| // assistant_util.enable_hotword(); |
| // |
| // // Call this API with your callback function. |
| // chrome.autotestPrivate.waitForAssistantQueryStatus(timeout_s, |
| // function(status) {...}); |
| // |
| // then start Assistant via OKG and send voice query before timeout. |
| // |
| // TODO(meilinw@): disable warmer welcome to avoid an unintended early |
| // return of this API when launching Assistant via hotkey. |
| // TODO(meilinw@): update the comment above to use Tast instead after |
| // adding API to enable hotword in Tast. |
| static void waitForAssistantQueryStatus( |
| long timeout_s, |
| AssistantQueryStatusCallback callback); |
| |
| // Whether the local list of installed ARC packages has been refreshed for |
| // the first time after user login. |
| static void isArcPackageListInitialRefreshed( |
| IsArcPackageListInitialRefreshedCallback callback); |
| |
| // Set value for the specified user pref in the pref tree. |
| static void setWhitelistedPref(DOMString pref_name, any value, |
| VoidCallback callback); |
| |
| // Enable/disable a Crostini app's "scaled" property. |
| // |appId|: The Crostini application ID. |
| // |scaled|: The app is "scaled" when shown, which means it uses low display |
| // density. |
| // |callback|: Called when the operation has completed. |
| static void setCrostiniAppScaled(DOMString appId, boolean scaled, |
| VoidCallback callback); |
| |
| // Get the primary display scale factor. |
| // |callback| is invoked with the scale factor. |
| static void getPrimaryDisplayScaleFactor( |
| GetPrimaryDisplayScaleFactorCallback callback); |
| |
| // Get the tablet mode enabled status. |
| // |callback| is invoked with the tablet mode enablement status. |
| static void isTabletModeEnabled(IsTabletModeEnabledCallback callback); |
| |
| // Enable/disable tablet mode. After calling this function, it won't be |
| // possible to physically switch to/from tablet mode since that |
| // functionality will be disabled. |
| // |enabled|: if set, enable tablet mode. |
| // |callback|: Called when the operation has completed. |
| static void setTabletModeEnabled(boolean enabled, |
| SetTabletModeEnabledCallback callback); |
| |
| // Get the list of all installed applications |
| static void getAllInstalledApps(GetAllInstalledAppsCallback callback); |
| |
| // Get the list of all shelf items |
| static void getShelfItems(GetShelfItemsCallback callback); |
| |
| // Get the shelf auto hide behavior. |
| // |displayId|: display that contains the shelf. |
| // |callback| is invoked with the shelf auto hide behavior. Possible |
| // behavior values are: "always", "never" or "hidden". |
| static void getShelfAutoHideBehavior(DOMString displayId, |
| GetShelfAutoHideBehaviorCallback callback); |
| |
| // Set the shelf auto hide behavior. |
| // |displayId|: display that contains the shelf. |
| // |behavior|: an enum of "always", "never" or "hidden". |
| // |callback|: Called when the operation has completed. |
| static void setShelfAutoHideBehavior(DOMString displayId, |
| DOMString behavior, VoidCallback callback); |
| |
| // Get the shelf alignment. |
| // |displayId|: display that contains the shelf. |
| // |callback| is invoked with the shelf alignment type. |
| static void getShelfAlignment(DOMString displayId, |
| GetShelfAlignmentCallback callback); |
| |
| // Set the shelf alignment. |
| // |displayId|: display that contains the shelf. |
| // |alignment|: the type of alignment to set. |
| // |callback|: Called when the operation has completed. |
| static void setShelfAlignment(DOMString displayId, |
| ShelfAlignmentType alignment, VoidCallback callback); |
| |
| // Create a pin on shelf for the app specified by |appId|. |
| static void pinShelfIcon(DOMString appId, VoidCallback callback); |
| |
| // Enter or exit the overview mode. |
| // |start|: whether entering to or exiting from the overview mode. |
| // |callback|: called after the overview mode switch finishes. |
| static void setOverviewModeState(boolean start, |
| SetOverviewModeStateCallback callback); |
| |
| // Show virtual keyboard of the current input method if it's available. |
| static void showVirtualKeyboardIfEnabled(); |
| |
| // Start ARC performance tracing for the active ARC app window. |
| // |callback|: Called when the operation has completed. |
| static void arcAppTracingStart(VoidCallback callback); |
| |
| // Stop ARC performance tracing if it was started and analyze results. |
| // |callback|: callback to deliver tracing results. |
| static void arcAppTracingStopAndAnalyze(ArcAppTracingCallback callback); |
| |
| // Swap the windows in the split view. |
| // |callback|: Called when the operation has completed. |
| static void swapWindowsInSplitView(VoidCallback callback); |
| |
| // Set ARC app window focused. |
| // |packageName|: the package name of the ARC app window. |
| // |callback|: called when the operation has completed. |
| static void setArcAppWindowFocus(DOMString packageName, |
| VoidCallback callback); |
| |
| // Invokes the callback when the display rotation animation is finished, or |
| // invokes it immediately if it is not animating. The callback argument |
| // is true if the display's rotation is same as |rotation|, or false otherwise. |
| // |displayId|: display that contains the shelf. |
| // |rotation|: the target rotation. |
| // |callback|: called when the operation has completed. |
| static void waitForDisplayRotation(DOMString displayId, |
| RotationType rotation, |
| WaitForDisplayRotationCallback callback); |
| |
| // Get information on all application windows. Callback will be called |
| // with the list of |AppWindowInfo| dictionary. |
| // |callback|: called with window list. |
| static void getAppWindowList(GetAppWindowListCallback callback); |
| |
| // Send WM event to change the app window's window state. |
| // |id|: the id of the window |
| // |change|: WM event type to send to the app window. |
| // |callback|: called when the window state is changed. |
| static void setAppWindowState(long id, |
| WindowStateChangeDict change, |
| WindowStateCallback callback); |
| |
| // Closes an app window given by "id". |
| // |id|: the id of the window |
| // |callback|: called when the window state is requested to close. |
| static void closeAppWindow(long id, VoidCallback callback); |
| |
| // Installs the Progressive Web App (PWA) that is in the current URL. |
| // |timeout_ms|: Timeout in milliseconds for the operation to complete. |
| // |callback|: called when the operation has completed. Passes the app Id |
| // of the recently installed PWA as argument. |
| static void installPWAForCurrentURL( |
| long timeout_ms, |
| InstallPWAForCurrentURLCallback callback); |
| |
| // Activates shortcut. |
| // |accelerator|: the accelerator to activate. |
| // |callback|: called when the operation has completed. |
| static void activateAccelerator(Accelerator accelerator, |
| AcceleratorCallback callback); |
| |
| // Wwait until the launcher is transitionto the |launcherState|, if it's not |
| // in that state. |
| // |launcherState|: the target launcher state. |
| // |callback|: called when the operation has completed. |
| static void waitForLauncherState(LauncherStateType launcherState, |
| VoidCallback callback); |
| |
| // Wait until overview has transitioned to |overviewState|, if it is not in |
| // that state. |
| // |overviewState|: the target overview state. |
| // |callback|: called when overview has reached |overviewState|. |
| static void waitForOverviewState(OverviewStateType overviewState, |
| VoidCallback callback); |
| |
| // Creates a new desk if the maximum number of desks has not been reached. |
| // |callback|: called to indicate success or failure. |
| static void createNewDesk(DesksCallback callback); |
| |
| // Activates the desk at the given |index| triggering the activate-desk |
| // animation. |
| // |index|: the zero-based index of the desk desired to be activated. |
| // |callback|: called indicating success when the animation completes, or |
| // failure when the desk at |index| is already the active desk. |
| static void activateDeskAtIndex(long index, DesksCallback callback); |
| |
| // Removes the currently active desk and triggers the remove-desk animation. |
| // |callback|: called indicating success when the animation completes, or |
| // failure if the currently active desk is the last available desk which |
| // cannot be removed. |
| static void removeActiveDesk(DesksCallback callback); |
| |
| // Create mouse events to cause a mouse click. |
| // |button|: the mouse button for the click event. |
| // |callback|: called after the mouse click finishes. |
| static void mouseClick(MouseButton button, VoidCallback callback); |
| |
| // Create a mouse event to cause mouse pressing. The mouse button stays |
| // in the pressed state. |
| // |button|: the mouse button to be pressed. |
| // |callback|: called after the mouse pressed event is handled. |
| static void mousePress(MouseButton button, VoidCallback callback); |
| |
| // Create a mouse event to release a mouse button. This does nothing and |
| // returns immediately if the specified button is not pressed. |
| // |button|: the mouse button to be released. |
| // |callback|: called after the mouse is released. |
| static void mouseRelease(MouseButton button, VoidCallback callback); |
| |
| // Create mouse events to move a mouse cursor to the location. This can |
| // cause a dragging if a button is pressed. It starts from the last mouse |
| // location. It does not support the move or drag across display boundaries. |
| // |location|: the target location (in display's coordinate). |
| // |duration_in_ms|: the duration (in milliseconds) for the mouse movement. |
| // The mouse will move linearly. 0 means moving immediately. |
| // |callback|: called after the mouse move finishes. |
| static void mouseMove(Location location, |
| double duration_in_ms, |
| VoidCallback callback); |
| |
| // Enable/disable metrics reporting in preferences. |
| // |enabled|: Enable metrics reporting. |
| // |callback|: Called when the operation has completed. |
| static void setMetricsEnabled(boolean enabled, VoidCallback callback); |
| |
| // Starts Chrome tracing. |
| // |config|: the tracing configuration. |
| // |callback|: called when tracing has started. |
| static void startTracing(TraceConfig config, VoidCallback callback); |
| |
| // Stops Chrome tracing. |
| // |completeCallback|: called when tracing is complete, with results as a |
| // parameter. |
| static void stopTracing(TraceCompleteCallback completeCallback); |
| |
| // Sends ARC touch mode enabled or disabled. |
| // |enable|: whether enabled touch mode. |
| // |callback|: called when action performed. |
| static void setArcTouchMode(boolean enabled, VoidCallback callback); |
| |
| // Fetches ui information of scrollable shelf view for the given shelf |
| // state. This function does not change scrollable shelf. |
| // [deprecated="Use getShelfUIInfoForState()"] |
| static void getScrollableShelfInfoForState( |
| ScrollableShelfState state, |
| GetScrollableShelfInfoForStateCallback callback); |
| |
| // Fetches UI information of shelf (including scrollable shelf and hotseat) |
| // for the given shelf state. This function does not change any shelf |
| // component. |
| static void getShelfUIInfoForState( |
| ShelfState state, |
| GetShelfUIInfoForStateCallback callback); |
| |
| // Sends a WM event to change a window's bounds and/or the display it is on. |
| // |id|: the id of the window. |
| // |bounds|: bounds the window should be set to. |
| // |displayId|: id of display to move the window to. |
| // |callback|: called when the window bounds are changed. |
| static void setWindowBounds( |
| long id, |
| Bounds bounds, |
| DOMString displayId, |
| WindowBoundsCallback callback); |
| |
| // Starts smoothness tracking for a display. If the display id is not |
| // specified, the primary display is used. Otherwise, the display specified |
| // by the display id is used. |
| static void startSmoothnessTracking(optional DOMString displayId, |
| VoidCallback callback); |
| |
| // Stops smoothness tracking for a display and report the smoothness. If |
| // the display id is not specified, the primary display is used. Otherwise, |
| // the display specified by the display id is used. |
| static void stopSmoothnessTracking(optional DOMString displayId, |
| StopSmoothnessTrackingCallback callback); |
| |
| // When neccesary, disables showing the dialog when Switch Access is disabled. |
| static void disableSwitchAccessDialog(); |
| |
| // Waits for the completion of photo transition animation in ambient mode. |
| // |photoRefreshInterval|: photo refresh interval in seconds. |
| // |numCompletions|: number of completions of the animation. |
| // |timeout|: the timeout in seconds. |
| // |callback|: Called when the operation has completed. |
| static void waitForAmbientPhotoAnimation( |
| long photoRefreshInterval, |
| long numCompletions, |
| long timeout, |
| VoidCallback callback); |
| |
| // Disables the automation feature. Note that the event handlers and caches |
| // of automation nodes still remain in the test extension and so the next |
| // automation.getDesktop will miss initialization. The caller should ensure |
| // invalidation of those information (i.e. reloading the entire background |
| // page). |
| static void disableAutomation(VoidCallback callback); |
| }; |
| |
| interface Events { |
| // Fired when the data in ui::Clipboard is changed. |
| static void onClipboardDataChanged(); |
| }; |
| }; |