mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
* feat(compositor): pen samples drive the pointer like a mouse Input record 13 carries the pen's state (in proximity, tip, right and middle button) and its position in input space as 24.8 fixed point. Hover moves the pointer, the tip holds the left button, and a record without the in-proximity bit releases every button. Under a pointer lock only the buttons pass. A button pressed or released mid-stroke keeps the implicit grab on the window the stroke started in, unless that window closed. * feat(input): a pen moves the pointer while hovering, clicks with its tip and right-clicks with its side button In Mouse mode (the default) a pen's hover moves the pointer, the tip holds the left button and the side button right-clicks; Touch keeps it a finger. The side button can send a middle click or nothing instead, and a Bluetooth pen key counts as the side button while the pen is near. With glasses or a program's pointer lock the pen drives the touchpad. A hover exit followed within 50 ms by more hover or a touch keeps the pen near, so a pen at the edge of its hover range does not flicker out, and a hover that sends nothing for 2 s leaves proximity. On the desktop a pen that comes near releases KWin's grab of a hardware mouse, so the pen moves KWin's pointer. Whatever cancels touches also ends the pen, and stylus devices no longer count as hardware mice. * feat(input): pen mode and side button settings in the Controls tab and the session drawer A Pen group follows the touch settings once the phone has a stylus device or a pen event was seen, which is remembered as penSeen and kept by a settings reset. It holds Pen (Mouse, Touch) and Side button (Right click, Middle click, Off); Side button is hidden in Touch. Before Android 14 a touchscreen reports the stylus source without a pen, so there it counts only with its first pen event. The strings are translated into all 32 languages. * docs: describe pen input and its limits --------- Co-authored-by: alien2003 <11610652+alien2003@users.noreply.github.com>
174 lines
7.6 KiB
Python
174 lines
7.6 KiB
Python
import os
|
|
from pathlib import Path
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
SOURCE = ROOT / 'app/src/main/cpp/waylandcomp/src/compositor.c'
|
|
|
|
|
|
def extract_function(source, name):
|
|
match = re.search(r'^(?:static )?(?:void|int|uint32_t) ' + re.escape(name) + r'\([^;]*?\) \{',
|
|
source, re.MULTILINE)
|
|
if match is None:
|
|
raise AssertionError(f'Missing compositor function: {name}')
|
|
cursor, depth = match.end(), 1
|
|
while depth:
|
|
depth += (source[cursor] == '{') - (source[cursor] == '}')
|
|
cursor += 1
|
|
return source[match.start():cursor]
|
|
|
|
|
|
PREAMBLE = r'''
|
|
#define _GNU_SOURCE
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdatomic.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
struct wl_resource { int version, modes, done, hz, w, h; struct wl_resource *next; };
|
|
struct surface { int xdg_toplevel, toplevel_committed; struct surface *next; };
|
|
struct input_msg { int type, p1, p2, p3, p4; };
|
|
static struct wl_resource second = { .version = 1 };
|
|
static struct wl_resource first = { .version = 4, .next = &second };
|
|
static struct surface surface = { .xdg_toplevel = 1, .toplevel_committed = 1 };
|
|
static int g_input_pipe[2] = {-1, -1};
|
|
static atomic_int g_output_refresh_mhz = 60000;
|
|
static atomic_int g_output_refresh_pending;
|
|
static int g_output_announced_refresh_mhz = 60000;
|
|
static int g_output_w = 1920, g_output_h = 1080;
|
|
static int flushes, resizes, pointers, ticks;
|
|
static int scale_changes, scale_mode, scale_alignment, renders;
|
|
static void *g_display;
|
|
#define WL_OUTPUT_MODE_CURRENT 1
|
|
#define WL_OUTPUT_MODE_PREFERRED 2
|
|
#define wl_resource_for_each(r, list) for ((r) = &first; (r); (r) = (r)->next)
|
|
#define wl_list_for_each(s, list, link) for ((s) = &surface; (s); (s) = (s)->next)
|
|
static int wl_resource_get_version(struct wl_resource *r) { return r->version; }
|
|
static void wl_output_send_mode(struct wl_resource *r, int flags, int w, int h, int hz) {
|
|
assert(flags == 3); r->modes++; r->hz = hz; r->w = w; r->h = h;
|
|
}
|
|
static void wl_output_send_done(struct wl_resource *r) { r->done++; }
|
|
static void wl_display_flush_clients(void *display) { (void)display; flushes++; }
|
|
static void send_toplevel_configure(struct surface *s) { (void)s; resizes++; }
|
|
#define droiddeck_log(...) ((void)0)
|
|
#define deliver_key(m) ((void)0)
|
|
#define pointer_event(...) ((void)0)
|
|
#define pointer_button(...) ((void)0)
|
|
#define scroll_event(...) ((void)0)
|
|
#define axis_event(...) ((void)0)
|
|
#define stream_take(...) ((void)0)
|
|
#define stream_forget_all(...) ((void)0)
|
|
#define pointer_delta(...) ((void)0)
|
|
#define deliver_touch(m) ((void)0)
|
|
#define deliver_pen(m) ((void)0)
|
|
#define deliver_pointer(m) (pointers++)
|
|
static void on_vsync(int64_t ns) { assert(ns > 0); ticks++; }
|
|
static void vk_present_set_scale_mode(int mode, int alignment) {
|
|
scale_changes++; scale_mode = mode; scale_alignment = alignment;
|
|
}
|
|
static void schedule_render(void) { renders++; }
|
|
'''
|
|
|
|
CHECKS = r'''
|
|
static int queued(void) { int n; assert(ioctl(g_input_pipe[0], FIONREAD, &n) == 0); return n; }
|
|
static void drain(void) { on_input_readable(g_input_pipe[0], 0, NULL); }
|
|
static void expect(int modes, int hz, int resize_count) {
|
|
assert(first.modes == modes && second.modes == modes);
|
|
assert(first.hz == hz && second.hz == hz);
|
|
assert(first.w == 1920 && second.w == 1920 && first.h == 1080 && second.h == 1080);
|
|
assert(first.done == modes && second.done == 0);
|
|
assert(resizes == resize_count);
|
|
assert(pointers == 0);
|
|
}
|
|
int main(void) {
|
|
droiddeck_wayland_set_output_refresh_rate(120000);
|
|
assert(atomic_load(&g_output_refresh_mhz) == 120000);
|
|
assert(!atomic_load(&g_output_refresh_pending));
|
|
assert(first.modes == 0 && second.modes == 0);
|
|
assert(pipe2(g_input_pipe, O_CLOEXEC | O_NONBLOCK) == 0);
|
|
g_output_announced_refresh_mhz = atomic_load(&g_output_refresh_mhz);
|
|
droiddeck_wayland_set_scale_mode(1, 4);
|
|
assert(queued() == sizeof(struct input_msg));
|
|
drain();
|
|
assert(scale_changes == 1 && scale_mode == 1 && scale_alignment == 4 && renders == 1);
|
|
assert(first.modes == 0 && second.modes == 0);
|
|
droiddeck_wayland_set_output_refresh_rate(120000);
|
|
assert(queued() == 0);
|
|
droiddeck_wayland_set_output_refresh_rate(60000);
|
|
assert(first.modes == 0 && queued() == sizeof(struct input_msg));
|
|
drain(); expect(1, 60000, 0); assert(flushes == 1);
|
|
droiddeck_wayland_set_output_refresh_rate(60000);
|
|
assert(queued() == 0); drain(); expect(1, 60000, 0);
|
|
droiddeck_wayland_set_output_refresh_rate(90000);
|
|
droiddeck_wayland_set_output_refresh_rate(120000);
|
|
drain(); expect(2, 120000, 0);
|
|
droiddeck_wayland_set_output_refresh_rate(90000);
|
|
droiddeck_wayland_set_output_refresh_rate(120000);
|
|
drain(); expect(2, 120000, 0);
|
|
droiddeck_wayland_set_output_refresh_rate(60000);
|
|
droiddeck_wayland_output_resized();
|
|
drain(); expect(3, 60000, 1); assert(flushes == 3);
|
|
struct input_msg wake = {10, 0, 0, 0, 0};
|
|
int n = 0;
|
|
while (write(g_input_pipe[1], &wake, sizeof(wake)) == sizeof(wake)) n++;
|
|
assert(n > 0 && errno == EAGAIN);
|
|
droiddeck_wayland_set_output_refresh_rate(120000);
|
|
drain(); expect(4, 120000, 1);
|
|
droiddeck_wayland_set_output_refresh_rate(0);
|
|
drain(); expect(5, 60000, 1);
|
|
droiddeck_wayland_set_output_refresh_rate(-1);
|
|
assert(queued() == 0);
|
|
struct input_msg vsync = {5, 0, 16000000, 0, 0};
|
|
assert(write(g_input_pipe[1], &vsync, sizeof(vsync)) == sizeof(vsync));
|
|
drain(); expect(5, 60000, 1); assert(ticks == 1);
|
|
assert(nominal_refresh_ns() == 16666666);
|
|
assert(flushes == 5);
|
|
assert(scale_changes == 1 && scale_mode == 1 && scale_alignment == 4 && renders == 1);
|
|
droiddeck_wayland_set_scale_mode(1, 3);
|
|
droiddeck_wayland_set_output_refresh_rate(90000);
|
|
drain(); expect(6, 90000, 1);
|
|
assert(scale_changes == 2 && scale_mode == 1 && scale_alignment == 3 && renders == 2);
|
|
close(g_input_pipe[0]); close(g_input_pipe[1]);
|
|
puts("PASS");
|
|
}
|
|
'''
|
|
|
|
|
|
@unittest.skipUnless(sys.platform.startswith('linux'), 'needs Linux nonblocking pipes')
|
|
class OutputRefreshTest(unittest.TestCase):
|
|
def test_refresh_notifications_preserve_client_pacing_without_resizing(self):
|
|
compiler = shutil.which(os.environ.get('CC', 'cc'))
|
|
if compiler is None:
|
|
self.skipTest('A host C compiler is required')
|
|
source = SOURCE.read_text()
|
|
functions = ('nominal_refresh_ns', 'output_send_mode', 'output_notify_mode',
|
|
'output_resized', 'on_input_readable', 'droiddeck_wayland_output_resized',
|
|
'droiddeck_wayland_set_scale_mode',
|
|
'droiddeck_wayland_set_output_refresh_rate')
|
|
harness = PREAMBLE + '\n'.join(extract_function(source, name) for name in functions) + CHECKS
|
|
with tempfile.TemporaryDirectory(prefix='droiddeck-output-refresh-') as folder:
|
|
path = Path(folder)
|
|
(path / 'refresh.c').write_text(harness)
|
|
binary = path / 'refresh-test'
|
|
build = subprocess.run([compiler, '-std=c11', '-Wall', '-Wextra', '-Werror',
|
|
'-Wno-unused-parameter', '-O2', str(path / 'refresh.c'),
|
|
'-o', str(binary)], capture_output=True, text=True)
|
|
self.assertEqual(0, build.returncode, build.stderr)
|
|
result = subprocess.run([str(binary)], capture_output=True, text=True, timeout=10)
|
|
self.assertEqual(0, result.returncode, result.stderr)
|
|
self.assertEqual('PASS', result.stdout.strip())
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|