browser_commander/playwright/protocol/

android_device.rs

// @generated by scripts/generate-playwright-protocol.mjs from
// rust/protocol/playwright/*.yml. Do not edit by hand.

#![allow(clippy::all, missing_docs, unused_imports)]

use serde::{Deserialize, Serialize};

use super::*;
use crate::playwright::connection::{
    Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
};

/// Initializer the driver sends when it creates a `AndroidDevice`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInitializer {
    #[serde(rename = "model")]
    pub model: String,
    #[serde(rename = "serial")]
    pub serial: String,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AndroidDeviceWaitParamsState {
    #[default]
    #[serde(rename = "gone")]
    Gone,
}

/// Parameters of `AndroidDevice.wait` (Wait).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceWaitParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
    pub state: Option<AndroidDeviceWaitParamsState>,
}

/// Parameters of `AndroidDevice.fill` (Fill "{text}").
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceFillParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "text")]
    pub text: String,
}

/// Parameters of `AndroidDevice.tap` (Tap).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceTapParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "duration", default, skip_serializing_if = "Option::is_none")]
    pub duration: Option<f64>,
}

/// Parameters of `AndroidDevice.drag` (Drag).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceDragParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "dest")]
    pub dest: Point,
    #[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
    pub speed: Option<f64>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AndroidDeviceFlingParamsDirection {
    #[default]
    #[serde(rename = "up")]
    Up,
    #[serde(rename = "down")]
    Down,
    #[serde(rename = "left")]
    Left,
    #[serde(rename = "right")]
    Right,
}

/// Parameters of `AndroidDevice.fling` (Fling).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceFlingParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "direction")]
    pub direction: AndroidDeviceFlingParamsDirection,
    #[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
    pub speed: Option<f64>,
}

/// Parameters of `AndroidDevice.longTap` (Long tap).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceLongTapParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
}

/// Parameters of `AndroidDevice.pinchClose` (Pinch close).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDevicePinchCloseParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "percent")]
    pub percent: f64,
    #[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
    pub speed: Option<f64>,
}

/// Parameters of `AndroidDevice.pinchOpen` (Pinch open).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDevicePinchOpenParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "percent")]
    pub percent: f64,
    #[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
    pub speed: Option<f64>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AndroidDeviceScrollParamsDirection {
    #[default]
    #[serde(rename = "up")]
    Up,
    #[serde(rename = "down")]
    Down,
    #[serde(rename = "left")]
    Left,
    #[serde(rename = "right")]
    Right,
}

/// Parameters of `AndroidDevice.scroll` (Scroll).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceScrollParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "direction")]
    pub direction: AndroidDeviceScrollParamsDirection,
    #[serde(rename = "percent")]
    pub percent: f64,
    #[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
    pub speed: Option<f64>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AndroidDeviceSwipeParamsDirection {
    #[default]
    #[serde(rename = "up")]
    Up,
    #[serde(rename = "down")]
    Down,
    #[serde(rename = "left")]
    Left,
    #[serde(rename = "right")]
    Right,
}

/// Parameters of `AndroidDevice.swipe` (Swipe).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceSwipeParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
    #[serde(rename = "direction")]
    pub direction: AndroidDeviceSwipeParamsDirection,
    #[serde(rename = "percent")]
    pub percent: f64,
    #[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
    pub speed: Option<f64>,
}

/// Parameters of `AndroidDevice.info`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInfoParams {
    #[serde(rename = "androidSelector")]
    pub android_selector: AndroidSelector,
}

/// Result of `AndroidDevice.info`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInfoResult {
    #[serde(rename = "info")]
    pub info: AndroidElementInfo,
}

/// Result of `AndroidDevice.screenshot` (Screenshot).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceScreenshotResult {
    #[serde(rename = "binary")]
    pub binary: Binary,
}

/// Parameters of `AndroidDevice.inputType` (Type).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInputTypeParams {
    #[serde(rename = "text")]
    pub text: String,
}

/// Parameters of `AndroidDevice.inputPress` (Press).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInputPressParams {
    #[serde(rename = "key")]
    pub key: String,
}

/// Parameters of `AndroidDevice.inputTap` (Tap).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInputTapParams {
    #[serde(rename = "point")]
    pub point: Point,
}

/// Parameters of `AndroidDevice.inputSwipe` (Swipe).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInputSwipeParams {
    #[serde(rename = "segments")]
    pub segments: Vec<Point>,
    #[serde(rename = "steps")]
    pub steps: i64,
}

/// Parameters of `AndroidDevice.inputDrag` (Drag).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInputDragParams {
    #[serde(rename = "from")]
    pub from: Point,
    #[serde(rename = "to")]
    pub to: Point,
    #[serde(rename = "steps")]
    pub steps: i64,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceLaunchBrowserParamsProxy {
    #[serde(rename = "server")]
    pub server: String,
    #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
    pub bypass: Option<String>,
    #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
}

/// Parameters of `AndroidDevice.launchBrowser` (Launch browser).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceLaunchBrowserParams {
    /// Properties of the `ContextOptions` mixin.
    #[serde(flatten)]
    pub context_options: ContextOptions,
    #[serde(rename = "pkg", default, skip_serializing_if = "Option::is_none")]
    pub pkg: Option<String>,
    #[serde(rename = "args", default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
    pub proxy: Option<AndroidDeviceLaunchBrowserParamsProxy>,
}

/// Result of `AndroidDevice.launchBrowser` (Launch browser).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceLaunchBrowserResult {
    #[serde(rename = "context")]
    pub context: Ref<BrowserContext>,
}

/// Parameters of `AndroidDevice.open` (Open app).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceOpenParams {
    #[serde(rename = "command")]
    pub command: String,
}

/// Result of `AndroidDevice.open` (Open app).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceOpenResult {
    #[serde(rename = "socket")]
    pub socket: Ref<AndroidSocket>,
}

/// Parameters of `AndroidDevice.shell` (Execute shell command).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceShellParams {
    #[serde(rename = "command")]
    pub command: String,
}

/// Result of `AndroidDevice.shell` (Execute shell command).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceShellResult {
    #[serde(rename = "result")]
    pub result: Binary,
}

/// Parameters of `AndroidDevice.installApk` (Install apk).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceInstallApkParams {
    #[serde(rename = "file")]
    pub file: Binary,
    #[serde(rename = "args", default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
}

/// Parameters of `AndroidDevice.push` (Push).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDevicePushParams {
    #[serde(rename = "file")]
    pub file: Binary,
    #[serde(rename = "path")]
    pub path: String,
    #[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i64>,
}

/// Parameters of `AndroidDevice.connectToWebView` (Connect to Web View).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceConnectToWebViewParams {
    #[serde(rename = "socketName")]
    pub socket_name: String,
}

/// Result of `AndroidDevice.connectToWebView` (Connect to Web View).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceConnectToWebViewResult {
    #[serde(rename = "context")]
    pub context: Ref<BrowserContext>,
}

/// Payload of the `AndroidDevice.webViewAdded` event.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceWebViewAddedEventParams {
    #[serde(rename = "webView")]
    pub web_view: AndroidWebView,
}

/// Payload of the `AndroidDevice.webViewRemoved` event.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidDeviceWebViewRemovedEventParams {
    #[serde(rename = "socketName")]
    pub socket_name: String,
}

/// Events a `AndroidDevice` channel can emit.
#[derive(Debug, Clone, PartialEq)]
pub enum AndroidDeviceEvent {
    /// `AndroidDevice.close`
    Close,
    /// `AndroidDevice.webViewAdded`
    WebViewAdded(AndroidDeviceWebViewAddedEventParams),
    /// `AndroidDevice.webViewRemoved`
    WebViewRemoved(AndroidDeviceWebViewRemovedEventParams),
    /// An event this binding does not know (a newer driver).
    Unknown {
        /// Event name.
        method: String,
        /// Raw event parameters.
        params: serde_json::Value,
    },
}

impl ProtocolEvent for AndroidDeviceEvent {
    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
        match method {
            "close" => Ok(Self::Close),
            "webViewAdded" => Ok(Self::WebViewAdded(serde_json::from_value(params)?)),
            "webViewRemoved" => Ok(Self::WebViewRemoved(serde_json::from_value(params)?)),
            _ => Ok(Self::Unknown { method: method.to_string(), params }),
        }
    }
}

/// Channel for the `AndroidDevice` interface (`android.yml`).
#[derive(Debug, Clone)]
pub struct AndroidDevice {
    channel: Channel,
}

impl ChannelType for AndroidDevice {
    const INTERFACE: &'static str = "AndroidDevice";
    type Initializer = AndroidDeviceInitializer;
    type Event = AndroidDeviceEvent;

    fn accepts(interface: &str) -> bool {
        matches!(interface, "AndroidDevice")
    }

    fn from_channel(channel: Channel) -> Self {
        Self { channel }
    }

    fn channel(&self) -> &Channel {
        &self.channel
    }
}

impl AndroidDevice {
    /// `AndroidDevice.wait` ("Wait").
    pub async fn wait(&self, params: AndroidDeviceWaitParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("wait", &params).await
    }

    /// `AndroidDevice.fill` ("Fill "{text}"").
    pub async fn fill(&self, params: AndroidDeviceFillParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("fill", &params).await
    }

    /// `AndroidDevice.tap` ("Tap").
    pub async fn tap(&self, params: AndroidDeviceTapParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("tap", &params).await
    }

    /// `AndroidDevice.drag` ("Drag").
    pub async fn drag(&self, params: AndroidDeviceDragParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("drag", &params).await
    }

    /// `AndroidDevice.fling` ("Fling").
    pub async fn fling(&self, params: AndroidDeviceFlingParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("fling", &params).await
    }

    /// `AndroidDevice.longTap` ("Long tap").
    pub async fn long_tap(&self, params: AndroidDeviceLongTapParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("longTap", &params).await
    }

    /// `AndroidDevice.pinchClose` ("Pinch close").
    pub async fn pinch_close(&self, params: AndroidDevicePinchCloseParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("pinchClose", &params).await
    }

    /// `AndroidDevice.pinchOpen` ("Pinch open").
    pub async fn pinch_open(&self, params: AndroidDevicePinchOpenParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("pinchOpen", &params).await
    }

    /// `AndroidDevice.scroll` ("Scroll").
    pub async fn scroll(&self, params: AndroidDeviceScrollParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("scroll", &params).await
    }

    /// `AndroidDevice.swipe` ("Swipe").
    pub async fn swipe(&self, params: AndroidDeviceSwipeParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("swipe", &params).await
    }

    /// `AndroidDevice.info` (internal).
    pub async fn info(&self, params: AndroidDeviceInfoParams) -> Result<AndroidDeviceInfoResult, ProtocolError> {
        self.channel.send("info", &params).await
    }

    /// `AndroidDevice.screenshot` ("Screenshot").
    pub async fn screenshot(&self) -> Result<AndroidDeviceScreenshotResult, ProtocolError> {
        self.channel.send("screenshot", &serde_json::json!({})).await
    }

    /// `AndroidDevice.inputType` ("Type").
    pub async fn input_type(&self, params: AndroidDeviceInputTypeParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("inputType", &params).await
    }

    /// `AndroidDevice.inputPress` ("Press").
    pub async fn input_press(&self, params: AndroidDeviceInputPressParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("inputPress", &params).await
    }

    /// `AndroidDevice.inputTap` ("Tap").
    pub async fn input_tap(&self, params: AndroidDeviceInputTapParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("inputTap", &params).await
    }

    /// `AndroidDevice.inputSwipe` ("Swipe").
    pub async fn input_swipe(&self, params: AndroidDeviceInputSwipeParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("inputSwipe", &params).await
    }

    /// `AndroidDevice.inputDrag` ("Drag").
    pub async fn input_drag(&self, params: AndroidDeviceInputDragParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("inputDrag", &params).await
    }

    /// `AndroidDevice.launchBrowser` ("Launch browser").
    pub async fn launch_browser(&self, params: AndroidDeviceLaunchBrowserParams) -> Result<AndroidDeviceLaunchBrowserResult, ProtocolError> {
        self.channel.send("launchBrowser", &params).await
    }

    /// `AndroidDevice.open` ("Open app").
    pub async fn open(&self, params: AndroidDeviceOpenParams) -> Result<AndroidDeviceOpenResult, ProtocolError> {
        self.channel.send("open", &params).await
    }

    /// `AndroidDevice.shell` ("Execute shell command").
    pub async fn shell(&self, params: AndroidDeviceShellParams) -> Result<AndroidDeviceShellResult, ProtocolError> {
        self.channel.send("shell", &params).await
    }

    /// `AndroidDevice.installApk` ("Install apk").
    pub async fn install_apk(&self, params: AndroidDeviceInstallApkParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("installApk", &params).await
    }

    /// `AndroidDevice.push` ("Push").
    pub async fn push(&self, params: AndroidDevicePushParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("push", &params).await
    }

    /// `AndroidDevice.connectToWebView` ("Connect to Web View").
    pub async fn connect_to_web_view(&self, params: AndroidDeviceConnectToWebViewParams) -> Result<AndroidDeviceConnectToWebViewResult, ProtocolError> {
        self.channel.send("connectToWebView", &params).await
    }

    /// `AndroidDevice.close` (internal).
    pub async fn close(&self) -> Result<(), ProtocolError> {
        self.channel.send_no_result("close", &serde_json::json!({})).await
    }
}