wayland_bridge/
display.rs

1// Copyright 2018 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::client::Client;
6use crate::object::{NewObjectExt, ObjectRef, RequestReceiver};
7use crate::registry::Registry;
8use anyhow::{format_err, Error};
9use fidl::endpoints::ClientEnd;
10use fidl_fuchsia_element::{GraphicalPresenterMarker, GraphicalPresenterProxy};
11use fidl_fuchsia_ui_app::ViewProviderMarker;
12use fidl_fuchsia_ui_gfx::DisplayInfo;
13use fidl_fuchsia_ui_scenic::{ScenicMarker, ScenicProxy};
14use fuchsia_async as fasync;
15use fuchsia_component::client::connect_to_protocol;
16use fuchsia_sync::Mutex;
17use futures::channel::mpsc;
18use std::sync::atomic::{AtomicUsize, Ordering};
19use std::sync::Arc;
20use wayland_server_protocol::*;
21
22/// When the connection is created it is initialized with a 'wl_display' object
23/// that the client can immediately interact with.
24pub const DISPLAY_SINGLETON_OBJECT_ID: u32 = 1;
25
26pub trait LocalViewProducerClient: Send + Sync {
27    /// Notifes the view producer client that a new view has been created.
28    ///
29    /// # Parameters
30    /// - `view_provider`: The view provider associated with the new view.
31    /// - `view_id`: The identifier for the view that was created.
32    fn new_view(&mut self, view_provider: ClientEnd<ViewProviderMarker>, view_id: u32);
33
34    /// Notifies the ViewProducer client that the view with `view_id` is being shut down.
35    fn shutdown_view(&mut self, view_id: u32);
36}
37
38#[derive(Clone)]
39enum ViewProducerClient {
40    Local(Arc<Mutex<Box<dyn LocalViewProducerClient>>>),
41    Invalid,
42}
43
44/// |Display| is the global object used to manage a wayland server.
45///
46/// The |Display| has a |Registry| that will hold the set of global
47/// interfaces that will be advertised to clients.
48#[derive(Clone)]
49pub struct Display {
50    registry: Arc<Mutex<Registry>>,
51    /// A connection to the 'Scenic' service.
52    scenic: Arc<ScenicProxy>,
53    /// A connection to the 'GraphicalPresenter' service.
54    graphical_presenter: Arc<GraphicalPresenterProxy>,
55    /// A binding to a public `ViewProducer` service. This is used to publish
56    /// new views to the consumer.
57    ///
58    /// This must be bound before any views are created.
59    view_producer_client: ViewProducerClient,
60    /// Number of view providers requested.
61    view_provider_requests: Arc<AtomicUsize>,
62    /// The current display info.
63    display_info: DisplayInfo,
64}
65
66impl Display {
67    pub fn new(registry: Registry) -> Result<Self, Error> {
68        let scenic =
69            connect_to_protocol::<ScenicMarker>().expect("failed to connect to Scenic service");
70        let graphical_presenter = connect_to_protocol::<GraphicalPresenterMarker>()
71            .expect("failed to connect to GraphicalPresenter service");
72        Ok(Display {
73            registry: Arc::new(Mutex::new(registry)),
74            scenic: Arc::new(scenic),
75            graphical_presenter: Arc::new(graphical_presenter),
76            view_producer_client: ViewProducerClient::Invalid,
77            view_provider_requests: Arc::new(AtomicUsize::new(0)),
78            display_info: DisplayInfo { width_in_px: 0, height_in_px: 0 },
79        })
80    }
81
82    pub fn new_local(
83        registry: Registry,
84        client: Arc<Mutex<Box<dyn LocalViewProducerClient>>>,
85    ) -> Result<Self, Error> {
86        let scenic =
87            connect_to_protocol::<ScenicMarker>().expect("failed to connect to Scenic service");
88        let graphical_presenter = connect_to_protocol::<GraphicalPresenterMarker>()
89            .expect("failed to connect to GraphicalPresenter service");
90        Ok(Display {
91            registry: Arc::new(Mutex::new(registry)),
92            scenic: Arc::new(scenic),
93            graphical_presenter: Arc::new(graphical_presenter),
94            view_producer_client: ViewProducerClient::Local(client),
95            // Set this to 0 when new_local clients have been updated to request views.
96            view_provider_requests: Arc::new(AtomicUsize::new(1)),
97            // TODO(https://fxbug.dev/42172104): Remove these default values.
98            display_info: DisplayInfo { width_in_px: 1920, height_in_px: 1080 },
99        })
100    }
101
102    /// Creates a `Display` without a valid scenic connection. This is intended
103    /// for unit testing purposes only.
104    #[cfg(test)]
105    pub fn new_no_scenic(registry: Registry) -> Result<Self, Error> {
106        let (c1, _c2) = zx::Channel::create();
107        let scenic = ScenicProxy::new(fasync::Channel::from_channel(c1));
108        let (c1, _c2) = zx::Channel::create();
109        let graphical_presenter = GraphicalPresenterProxy::new(fasync::Channel::from_channel(c1));
110        Ok(Display {
111            registry: Arc::new(Mutex::new(registry)),
112            scenic: Arc::new(scenic),
113            graphical_presenter: Arc::new(graphical_presenter),
114            view_producer_client: ViewProducerClient::Invalid,
115            view_provider_requests: Arc::new(AtomicUsize::new(0)),
116            display_info: DisplayInfo { width_in_px: 0, height_in_px: 0 },
117        })
118    }
119
120    /// Provides access to the Scenic connection for this display.
121    pub fn scenic(&self) -> &Arc<ScenicProxy> {
122        &self.scenic
123    }
124
125    /// Provides access to the GraphicalPresenter connection for this display.
126    pub fn graphical_presenter(&self) -> &Arc<GraphicalPresenterProxy> {
127        &self.graphical_presenter
128    }
129
130    /// Provides access to the global registry for this display.
131    pub fn registry(&self) -> Arc<Mutex<Registry>> {
132        self.registry.clone()
133    }
134
135    /// Take one view provider request off the top. Returns false if no
136    /// request exists.
137    pub fn take_view_provider_requests(&mut self) -> bool {
138        if self.view_provider_requests.load(Ordering::Relaxed) > 0 {
139            self.view_provider_requests.fetch_sub(1, Ordering::SeqCst);
140            true
141        } else {
142            false
143        }
144    }
145
146    /// Publish a new view back to the client for presentation.
147    pub fn new_view_provider(&self, view_provider: ClientEnd<ViewProviderMarker>, view_id: u32) {
148        match &self.view_producer_client {
149            ViewProducerClient::Local(view_producer_client) => {
150                view_producer_client.lock().new_view(view_provider, view_id);
151            }
152            ViewProducerClient::Invalid => {
153                panic!("new_view_provider called without a valid view producer");
154            }
155        }
156    }
157
158    /// Notify client that presentation of view should stop.
159    pub fn delete_view_provider(&self, view_id: u32) {
160        match &self.view_producer_client {
161            ViewProducerClient::Local(view_producer_client) => {
162                view_producer_client.lock().shutdown_view(view_id);
163            }
164            ViewProducerClient::Invalid => {
165                panic!("delete_view_provider called without a valid view producer");
166            }
167        }
168    }
169
170    /// Create a new client and begin polling `chan` for requests.
171    pub fn spawn_new_client(self, chan: fasync::Channel, protocol_logging: bool) {
172        Display::spawn_client(Client::new(chan, self), protocol_logging);
173    }
174
175    pub fn spawn_new_local_client(
176        self,
177        sender: mpsc::UnboundedSender<zx::MessageBuf>,
178        receiver: mpsc::UnboundedReceiver<zx::MessageBuf>,
179        protocol_logging: bool,
180    ) {
181        Display::spawn_client(Client::new_local(sender, receiver, self), protocol_logging);
182    }
183
184    fn spawn_client(mut client: Client, protocol_logging: bool) {
185        client.set_protocol_logging(protocol_logging);
186
187        // Add the global wl_display object. We unwrap here since the object map
188        // is empty so failure should not be possible.
189        client.add_object(DISPLAY_SINGLETON_OBJECT_ID, DisplayReceiver).unwrap();
190
191        // Start polling the channel for messages.
192        client.start();
193    }
194
195    /// The current display info.
196    pub fn display_info(&self) -> DisplayInfo {
197        self.display_info
198    }
199
200    /// Set the current display info.
201    pub fn set_display_info(&mut self, display_info: &DisplayInfo) {
202        self.display_info = *display_info;
203    }
204}
205
206/// An implementation of wl_display.
207struct DisplayReceiver;
208
209impl RequestReceiver<WlDisplay> for DisplayReceiver {
210    fn receive(
211        this: ObjectRef<Self>,
212        request: WlDisplayRequest,
213        client: &mut Client,
214    ) -> Result<(), Error> {
215        match request {
216            WlDisplayRequest::GetRegistry { registry } => {
217                let registry = registry.implement(client, RegistryReceiver)?;
218                RegistryReceiver::report_globals(registry, client)?;
219                Ok(())
220            }
221            WlDisplayRequest::Sync { callback } => {
222                // Since we callback immediately we'll skip actually adding this
223                // object, but we need to send the wl_display::delete_id event
224                // explicitly, which is otherwise done for us in
225                // Client:delete_id.
226                client
227                    .event_queue()
228                    .post(callback.id(), WlCallbackEvent::Done { callback_data: 0 })?;
229                client
230                    .event_queue()
231                    .post(this.id(), WlDisplayEvent::DeleteId { id: callback.id() })?;
232                Ok(())
233            }
234        }
235    }
236}
237
238/// An implementation of wl_registry.
239struct RegistryReceiver;
240
241impl RegistryReceiver {
242    /// Sends a wl_registry::global event for each entry in the |Registry|.
243    pub fn report_globals(this: ObjectRef<Self>, client: &Client) -> Result<(), Error> {
244        let registry = client.display().registry();
245        for (name, global) in registry.lock().globals().iter().enumerate() {
246            client.event_queue().post(
247                this.id(),
248                WlRegistryEvent::Global {
249                    name: name as u32,
250                    interface: global.interface().into(),
251                    version: global.version(),
252                },
253            )?;
254        }
255        Ok(())
256    }
257}
258
259impl RequestReceiver<WlRegistry> for RegistryReceiver {
260    fn receive(
261        _this: ObjectRef<Self>,
262        request: WlRegistryRequest,
263        client: &mut Client,
264    ) -> Result<(), Error> {
265        let WlRegistryRequest::Bind { name, id, id_interface_version: version, .. } = request;
266        let registry = client.display().registry();
267        let (spec, receiver) = {
268            let mut lock = registry.lock();
269            if let Some(global) = lock.globals().get_mut(name as usize) {
270                (global.request_spec(), global.bind(id, version, client)?)
271            } else {
272                return Err(format_err!("Invalid global name {}", name));
273            }
274        };
275        client.add_object_raw(id, receiver, spec)?;
276        Ok(())
277    }
278}
279
280/// An implementation of wl_callback.
281pub struct Callback;
282
283impl Callback {
284    /// Posts the `done` event for this callback.
285    pub fn done(
286        this: ObjectRef<Self>,
287        client: &mut Client,
288        callback_data: u32,
289    ) -> Result<(), Error> {
290        client.event_queue().post(this.id(), WlCallbackEvent::Done { callback_data })
291    }
292}
293
294impl RequestReceiver<WlCallback> for Callback {
295    fn receive(
296        _this: ObjectRef<Self>,
297        request: WlCallbackRequest,
298        _client: &mut Client,
299    ) -> Result<(), Error> {
300        match request {}
301    }
302}
wayland_bridge/display.rs

wayland_bridge/
display.rs
