Debian Codegraph @

tests/pyportaltest/templates/inputcapture.py

raw
1 # SPDX-License-Identifier: LGPL-3.0-only
2 #
3 # This file is formatted with Python Black
4
5 """xdg desktop portals mock template"""
6
7 from pyportaltest.templates import Request, Response, ASVType, Session
8 from typing import Callable, Dict, List, Tuple, Iterator
9 from itertools import count
10
11 _restore_tokens = count()
12
13 import dbus
14 import dbus.service
15 import logging
16 import sys
17
18 from gi.repository import GLib
19
20 BUS_NAME = "org.freedesktop.portal.Desktop"
21 MAIN_OBJ = "/org/freedesktop/portal/desktop"
22 SYSTEM_BUS = False
23 MAIN_IFACE = "org.freedesktop.portal.InputCapture"
24
25 logger = logging.getLogger(f"templates.{__name__}")
26 logger.setLevel(logging.DEBUG)
27
28 zone_set = None
29 eis_serial = None
30
31
32 def load(mock, parameters={}):
33 logger.debug(f"Loading parameters: {parameters}")
34
35 # Delay before Request.response, applies to all functions
36 mock.delay: int = parameters.get("delay", 0)
37
38 # EIS serial number, < 0 means "don't send a serial"
39 eis_serial_start = parameters.get("eis-serial", 0)
40 if eis_serial_start >= 0:
41 global eis_serial
42 eis_serial = count(start=eis_serial_start)
43
44 # Zone set number, < 0 means "don't send a zone_set"
45 zone_set_start = parameters.get("zone-set", 0)
46 if zone_set_start >= 0:
47 global zone_set
48 zone_set = count(start=zone_set_start)
49 mock.current_zone_set = next(zone_set)
50 else:
51 mock.current_zone_set = None
52
53 # An all-zeroes zone means "don't send a zone"
54 mock.current_zones = parameters.get("zones", ((1920, 1080, 0, 0),))
55 if mock.current_zones[0] == (0, 0, 0, 0):
56 mock.current_zones = None
57
58 # second set of zones after the change signal
59 mock.changed_zones = parameters.get("changed-zones", ((0, 0, 0, 0),))
60 if mock.changed_zones[0] == (0, 0, 0, 0):
61 mock.changed_zones = None
62
63 # milliseconds until the zones change to the changed_zones
64 mock.change_zones_after = parameters.get("change-zones-after", 0)
65
66 # List of barrier ids to fail
67 mock.failed_barriers = parameters.get("failed-barriers", [])
68
69 # When to send the Activated signal (in ms after Enable), 0 means no
70 # signal
71 mock.activated_after = parameters.get("activated-after", 0)
72
73 # Barrier ID that triggers Activated (-1 means don't add barrier id)
74 mock.activated_barrier = parameters.get("activated-barrier", None)
75
76 # Position tuple for Activated signal, None means don't add position
77 mock.activated_position = parameters.get("activated-position", None)
78
79 # When to send the Deactivated signal (in ms after Activated), 0 means no
80 # signal
81 mock.deactivated_after = parameters.get("deactivated-after", 0)
82
83 # Position tuple for Deactivated signal, None means don't add position
84 mock.deactivated_position = parameters.get("deactivated-position", None)
85
86 # When to send the Disabled signal (in ms after Enabled), 0 means no
87 # signal
88 mock.disabled_after = parameters.get("disabled-after", 0)
89
90 # How many ms to signal Session.Closed after Start
91 mock.close_after_enable = parameters.get("close-after-enable", 0)
92
93 # persist_mode returned in Start response (0 means none)
94 mock.start_persist_mode = parameters.get("start-persist-mode", 0)
95
96 mock.AddProperties(
97 MAIN_IFACE,
98 dbus.Dictionary(
99 {
100 "version": dbus.UInt32(parameters.get("version", 1)),
101 "SupportedCapabilities": dbus.UInt32(
102 parameters.get("capabilities", 0xF)
103 ),
104 }
105 ),
106 )
107
108 mock.active_sessions: Dict[str, Session] = {}
109
110
111 @dbus.service.method(
112 MAIN_IFACE,
113 sender_keyword="sender",
114 in_signature="sa{sv}",
115 out_signature="o",
116 )
117 def CreateSession(self, parent_window: str, options: ASVType, sender: str):
118 try:
119 request = Request(bus_name=self.bus_name, sender=sender, options=options)
120 session = Session(bus_name=self.bus_name, sender=sender, options=options)
121
122 response = Response(
123 0,
124 {
125 "capabilities": dbus.UInt32(0xF, variant_level=1),
126 "session_handle": dbus.ObjectPath(session.handle),
127 },
128 )
129 self.active_sessions[session.handle] = session
130
131 logger.debug(f"CreateSession with response {response}")
132 request.respond(response, delay=self.delay)
133
134 return request.handle
135 except Exception as e:
136 logger.critical(e)
137
138
139 @dbus.service.method(
140 MAIN_IFACE,
141 sender_keyword="sender",
142 in_signature="a{sv}",
143 out_signature="a{sv}",
144 )
145 def CreateSession2(self, options: ASVType, sender: str):
146 try:
147 session = Session(bus_name=self.bus_name, sender=sender, options=options)
148 self.active_sessions[session.handle] = session
149
150 results = {
151 "session_handle": dbus.ObjectPath(session.handle),
152 }
153
154 logger.debug(f"CreateSession2 with results {results}")
155 return results
156 except Exception as e:
157 logger.critical(e)
158
159
160 @dbus.service.method(
161 MAIN_IFACE,
162 sender_keyword="sender",
163 in_signature="osa{sv}",
164 out_signature="o",
165 )
166 def Start(self, session_handle: str, parent_window: str, options: ASVType, sender: str):
167 try:
168 request = Request(bus_name=self.bus_name, sender=sender, options=options)
169
170 if session_handle not in self.active_sessions:
171 request.respond(Response(2, {}), delay=self.delay)
172 return request.handle
173
174 results = {}
175
176 if self.start_persist_mode != 0:
177 results["restore_token"] = f"restore_token{next(_restore_tokens)}"
178
179 response = Response(response=0, results=results)
180
181 logger.debug(f"Start with response {response}")
182 request.respond(response, delay=self.delay)
183
184 return request.handle
185 except Exception as e:
186 logger.critical(e)
187
188
189 @dbus.service.method(
190 MAIN_IFACE,
191 sender_keyword="sender",
192 in_signature="oa{sv}",
193 out_signature="h",
194 )
195 def ConnectToEIS(self, session_handle: str, options: ASVType, sender: str):
196 try:
197 import socket
198
199 sockets = socket.socketpair()
200 # Write some random data down so it'll break anything that actually
201 # expects the socket to be a real EIS socket
202 sockets[0].send(b"VANILLA")
203 fd = sockets[1]
204 logger.debug(f"ConnectToEIS with fd {fd.fileno()}")
205 return dbus.types.UnixFd(fd)
206 except Exception as e:
207 logger.critical(e)
208
209
210 @dbus.service.method(
211 MAIN_IFACE,
212 sender_keyword="sender",
213 in_signature="oa{sv}",
214 out_signature="o",
215 )
216 def GetZones(self, session_handle: str, options: ASVType, sender: str):
217 try:
218 request = Request(bus_name=self.bus_name, sender=sender, options=options)
219
220 if session_handle not in self.active_sessions:
221 request.respond(Response(2, {}, delay=self.delay))
222 return request.handle
223
224 zone_set = self.current_zone_set
225 zones = self.current_zones
226
227 results = {}
228 if zone_set is not None:
229 results["zone_set"] = dbus.UInt32(zone_set, variant_level=1)
230 if zones is not None:
231 results["zones"] = dbus.Array(
232 [dbus.Struct(z, signature="uuii") for z in zones],
233 signature="(uuii)",
234 variant_level=1,
235 )
236
237 response = Response(response=0, results=results)
238
239 logger.debug(f"GetZones with response {response}")
240 request.respond(response, delay=self.delay)
241
242 if self.change_zones_after > 0:
243
244 def change_zones():
245 global zone_set
246
247 logger.debug("Changing Zones")
248 opts = {"zone_set": dbus.UInt32(self.current_zone_set, variant_level=1)}
249 self.current_zone_set = next(zone_set)
250 self.current_zones = self.changed_zones
251 self.EmitSignalDetailed(
252 "",
253 "ZonesChanged",
254 "oa{sv}",
255 [dbus.ObjectPath(session_handle), opts],
256 details={"destination": sender},
257 )
258
259 GLib.timeout_add(self.change_zones_after, change_zones)
260
261 self.change_zones_after = 0 # Zones only change once
262
263 return request.handle
264 except Exception as e:
265 logger.critical(e)
266
267
268 @dbus.service.method(
269 MAIN_IFACE,
270 sender_keyword="sender",
271 in_signature="oa{sv}aa{sv}u",
272 out_signature="o",
273 )
274 def SetPointerBarriers(
275 self,
276 session_handle: str,
277 options: ASVType,
278 barriers: List[ASVType],
279 zone_set: int,
280 sender: str,
281 ):
282 try:
283 request = Request(bus_name=self.bus_name, sender=sender, options=options)
284
285 if (
286 session_handle not in self.active_sessions
287 or zone_set != self.current_zone_set
288 ):
289 response = Response(2, {})
290 else:
291 results = {
292 "failed_barriers": dbus.Array(
293 self.failed_barriers, signature="u", variant_level=1
294 )
295 }
296 response = Response(0, results)
297
298 logger.debug(f"SetPointerBarriers with response {response}")
299 request.respond(response, delay=self.delay)
300
301 return request.handle
302 except Exception as e:
303 logger.critical(e)
304
305
306 @dbus.service.method(
307 MAIN_IFACE,
308 sender_keyword="sender",
309 in_signature="oa{sv}",
310 out_signature="",
311 )
312 def Enable(self, session_handle, options, sender):
313 try:
314 logger.debug(f"Enable with options {options}")
315 allowed_options = []
316
317 if not all([k in allowed_options for k in options]):
318 logger.error("Enable does not support options")
319
320 if self.activated_after > 0:
321 current_eis_serial = next(eis_serial) if eis_serial else None
322
323 def send_activated():
324 opts = {}
325 if current_eis_serial is not None:
326 opts["activation_id"] = dbus.UInt32(
327 current_eis_serial, variant_level=1
328 )
329
330 if self.activated_position is not None:
331 opts["cursor_position"] = dbus.Struct(
332 self.activated_position, signature="dd", variant_level=1
333 )
334 if self.activated_barrier is not None:
335 opts["barrier_id"] = dbus.UInt32(
336 self.activated_barrier, variant_level=1
337 )
338
339 self.EmitSignalDetailed(
340 "",
341 "Activated",
342 "oa{sv}",
343 [dbus.ObjectPath(session_handle), opts],
344 details={"destination": sender},
345 )
346
347 GLib.timeout_add(self.activated_after, send_activated)
348
349 if self.deactivated_after > 0:
350
351 def send_deactivated():
352 opts = {}
353 if current_eis_serial:
354 opts["activation_id"] = dbus.UInt32(
355 current_eis_serial, variant_level=1
356 )
357
358 if self.deactivated_position is not None:
359 opts["cursor_position"] = dbus.Struct(
360 self.deactivated_position, signature="dd", variant_level=1
361 )
362
363 self.EmitSignalDetailed(
364 "",
365 "Deactivated",
366 "oa{sv}",
367 [dbus.ObjectPath(session_handle), opts],
368 details={"destination": sender},
369 )
370
371 GLib.timeout_add(
372 self.activated_after + self.deactivated_after, send_deactivated
373 )
374
375 if self.disabled_after > 0:
376
377 def send_disabled():
378 self.EmitSignalDetailed(
379 "",
380 "Disabled",
381 "oa{sv}",
382 [dbus.ObjectPath(session_handle), {}],
383 details={"destination": sender},
384 )
385
386 GLib.timeout_add(self.disabled_after, send_disabled)
387
388 if self.close_after_enable > 0:
389 session = self.active_sessions[session_handle]
390 session.close({}, self.close_after_enable)
391
392 except Exception as e:
393 logger.critical(e)
394
395
396 @dbus.service.method(
397 MAIN_IFACE,
398 sender_keyword="sender",
399 in_signature="oa{sv}",
400 out_signature="",
401 )
402 def Disable(self, session_handle, options, sender):
403 try:
404 logger.debug(f"Disable with options {options}")
405 allowed_options = []
406
407 if not all([k in allowed_options for k in options]):
408 logger.error("Disable does not support options")
409 except Exception as e:
410 logger.critical(e)
411
412
413 @dbus.service.method(
414 MAIN_IFACE,
415 sender_keyword="sender",
416 in_signature="oa{sv}",
417 out_signature="",
418 )
419 def Release(self, session_handle, options, sender):
420 try:
421 logger.debug(f"Release with options {options}")
422 allowed_options = ["cursor_position"]
423
424 if not all([k in allowed_options for k in options]):
425 logger.error("Invalid options for Release")
426 except Exception as e:
427 logger.critical(e)