xcelerate_core/
page.rs

1use crate::connection::CdpClient;
2use crate::element::Element;
3use crate::error::{XcelerateResult, XcelerateError};
4use std::sync::Arc;
5use browser_protocol::page::{GetLayoutMetricsParams, CaptureScreenshotParams, ReloadParams, NavigateParams, EnableParams};
6use browser_protocol::emulation::{SetDeviceMetricsOverrideParams, ClearDeviceMetricsOverrideParams};
7
8#[derive(uniffi::Object)]
9pub struct Page {
10    pub(crate) client: Arc<CdpClient>,
11    pub(crate) session_id: String,
12}
13
14#[uniffi::export(async_runtime = "tokio")]
15impl Page {
16    /// Finds an element matching the CSS selector.
17    pub async fn find_element(self: Arc<Self>, selector: String) -> XcelerateResult<Arc<Element>> {
18        let js = format!("document.querySelector('{}')", selector);
19        
20        // Evaluate returns complex JSON, we handle it internally
21        self.client.execute_with_session(
22            Some(&self.session_id),
23            js_protocol::runtime::EvaluateParams {
24                expression: js,
25                ..Default::default()
26            }
27        ).await.and_then(|result| {
28            if let Some(obj_id) = result.result.objectId {
29                Ok(Arc::new(Element {
30                    page: self.clone(),
31                    object_id: obj_id,
32                }))
33            } else {
34                Err(XcelerateError::NotFound(selector))
35            }
36        })
37    }
38
39    /// Waits for an element matching the selector to appear in the DOM.
40    pub async fn wait_for_selector(self: Arc<Self>, selector: String) -> XcelerateResult<Arc<Element>> {
41        let start = std::time::Instant::now();
42        let timeout = std::time::Duration::from_secs(30);
43
44        while start.elapsed() < timeout {
45            if let Ok(element) = self.clone().find_element(selector.clone()).await {
46                return Ok(element);
47            }
48            tokio::time::sleep(std::time::Duration::from_millis(250)).await;
49        }
50
51        Err(XcelerateError::NotFound(format!("Timeout waiting for selector: {}", selector)))
52    }
53
54    /// Waits for the page to finish loading.
55    pub async fn wait_for_navigation(&self) -> XcelerateResult<()> {
56        let start = std::time::Instant::now();
57        let timeout = std::time::Duration::from_secs(30);
58
59        while start.elapsed() < timeout {
60            // Internal call to evaluate
61            let res = self.client.execute_with_session(
62                Some(&self.session_id),
63                js_protocol::runtime::EvaluateParams {
64                    expression: "document.readyState".into(),
65                    ..Default::default()
66                }
67            ).await?;
68            
69            if res.result.value.is_some_and(|v| v.as_str() == Some("complete")) {
70                return Ok(());
71            }
72            tokio::time::sleep(std::time::Duration::from_millis(250)).await;
73        }
74
75        Err(XcelerateError::NotFound("Navigation timeout".into()))
76    }
77
78    /// Reloads the page.
79    pub async fn reload(&self) -> XcelerateResult<()> {
80        self.client.execute_with_session(
81            Some(&self.session_id),
82            ReloadParams { ..Default::default() }
83        ).await.map(|_| ())
84    }
85
86    /// Navigates to a URL.
87    pub async fn navigate(&self, url: String) -> XcelerateResult<()> {
88        self.client.execute_with_session(
89            Some(&self.session_id),
90            NavigateParams { 
91                url, 
92                ..Default::default() 
93            }
94        ).await.map(|_| ())
95    }
96
97    /// Returns the page title.
98    pub async fn title(&self) -> XcelerateResult<String> {
99        let res = self.client.execute_with_session(
100            Some(&self.session_id),
101            js_protocol::runtime::EvaluateParams {
102                expression: "document.title".into(),
103                ..Default::default()
104            }
105        ).await?;
106        Ok(res.result.value.and_then(|v| v.as_str().map(|s| s.to_string())).unwrap_or_default())
107    }
108
109    /// Returns the full HTML content of the page.
110    pub async fn content(&self) -> XcelerateResult<String> {
111        let res = self.client.execute_with_session(
112            Some(&self.session_id),
113            js_protocol::runtime::EvaluateParams {
114                expression: "document.documentElement.outerHTML".into(),
115                ..Default::default()
116            }
117        ).await?;
118        Ok(res.result.value.and_then(|v| v.as_str().map(|s| s.to_string())).unwrap_or_default())
119    }
120
121    pub async fn screenshot(&self) -> XcelerateResult<Vec<u8>> {
122        let res = self.client.execute_with_session(
123            Some(&self.session_id),
124            CaptureScreenshotParams { ..Default::default() }
125        ).await?;
126        self.decode_base64(res.data)
127    }
128
129    pub async fn screenshot_full(&self) -> XcelerateResult<Vec<u8>> {
130        let _ = self.client.execute_with_session(
131            Some(&self.session_id),
132            EnableParams { ..Default::default() }
133        ).await?;
134
135        let metrics = self.client.execute_with_session(
136            Some(&self.session_id),
137            GetLayoutMetricsParams {}
138        ).await?;
139
140        let width = metrics.contentSize.width as u64;
141        let height = metrics.contentSize.height as i64;
142
143        let mut params = SetDeviceMetricsOverrideParams { ..Default::default() };
144        params.width = width;
145        params.height = height;
146        params.deviceScaleFactor = 1.0;
147        params.mobile = false;
148
149        self.client.execute_with_session(
150            Some(&self.session_id),
151            params
152        ).await?;
153
154        let res = self.client.execute_with_session(
155            Some(&self.session_id),
156            CaptureScreenshotParams { ..Default::default() }
157        ).await?;
158
159        let _ = self.client.execute_with_session(
160            Some(&self.session_id),
161            ClearDeviceMetricsOverrideParams {}
162        ).await?;
163
164        self.decode_base64(res.data)
165    }
166
167    pub async fn pdf(&self) -> XcelerateResult<Vec<u8>> {
168        let res = self.client.execute_with_session(
169            Some(&self.session_id),
170            browser_protocol::page::PrintToPDFParams { ..Default::default() }
171        ).await?;
172        self.decode_base64(res.data)
173    }
174
175    /// Evaluates a script on every new document.
176    pub async fn add_script_to_evaluate_on_new_document(&self, source: String) -> XcelerateResult<String> {
177        let res = self.client.execute_with_session(
178            Some(&self.session_id),
179            browser_protocol::page::AddScriptToEvaluateOnNewDocumentParams {
180                source,
181                ..Default::default()
182            }
183        ).await?;
184        Ok(res.identifier)
185    }
186
187    pub async fn go_back(&self) -> XcelerateResult<()> {
188        let _ = self.client.execute_with_session(
189            Some(&self.session_id),
190            js_protocol::runtime::EvaluateParams {
191                expression: "window.history.back()".into(),
192                ..Default::default()
193            }
194        ).await?;
195        Ok(())
196    }
197
198    fn decode_base64(&self, data: String) -> XcelerateResult<Vec<u8>> {
199        use base64::{Engine as _, engine::general_purpose};
200        general_purpose::STANDARD.decode(data).map_err(|e| XcelerateError::SerdeError(format!("Base64 decode failed: {}", e)))
201    }
202}
xcelerate_core/page.rs

xcelerate_core/
page.rs
