Touchpad on the desktop, and the guest's resolver from the live network

Touch on the desktop now works the way Bannerlator's desktop containers do:
the arrow stays where it is and a finger dragged anywhere moves it from there,
tap clicks, a second finger tapping while one holds (or a two-finger tap)
right-clicks, two fingers scroll, hold-then-drag and double-tap-hold drag.
Steam keeps the direct pointer; the drawer pins either.

The runtime's resolv.conf is written from the active network's DNS servers on
every link change — IPv4 first, never Android's link-local IPv6 ones, the
public pair as fallback — which is what glibc, and so Firefox, resolve with.
Routing needs nothing: proot makes no network namespace.
This commit is contained in:
The412Banner committed 2026-09-20 03:51:59 -04:00
1 parent f5ca6d0053
commit 6568bf667d
6 files changed
+262

No files matched your search

@@ -0,0 +1,151 @@
package com.steamdeck.launcher.input
import android.os.Handler
import android.os.Looper
import android.view.MotionEvent
import kotlin.math.abs
/**
* The screen as a touchpad, the way Bannerlator's desktop containers work: the arrow is where it
* was, and a finger dragged anywhere moves it from there.
*
* - drag one finger .................. moves the pointer (relative, with a little acceleration)
* - tap .............................. left click, where the pointer is
* - second finger taps while one holds right click
* - two-finger tap ................... right click
* - two fingers up / down ............ scroll wheel
* - hold still, then drag ............ left-button drag
* - double-tap, hold, drag ........... left-button drag as well
*
* Positions handed to the listener are the pointer's, in the view's pixels; the caller keeps them
* inside the picture.
*/
class TouchpadGestures(
private val slopPx: Float,
private val listener: PointerGestures.Listener,
) {
/** The pointer, tracked here since every move is relative. */
var x = 0f
private set
var y = 0f
private set
var bounds: android.graphics.RectF = android.graphics.RectF(0f, 0f, 1f, 1f)
var sensitivity = 1.15f
private val handler = Handler(Looper.getMainLooper())
private var lastX = 0f
private var lastY = 0f
private var downAt = 0L
private var lastTapAt = 0L
private var travelled = 0f
private var dragging = false
private var held = false
private var secondDownAt = 0L
private var secondWasTap = false
private var twoFingers = false
private var scrollAnchorY = 0f
private var scrolled = false
private val longPress = Runnable {
held = true
dragging = true
listener.onLongPress()
listener.onButton(PointerGestures.BTN_LEFT, true, x, y)
}
fun place(px: Float, py: Float) {
x = px.coerceIn(bounds.left, bounds.right)
y = py.coerceIn(bounds.top, bounds.bottom)
}
fun onTouch(event: MotionEvent): Boolean {
when (event.actionMasked) {
MotionEvent.ACTION_DOWN -> {
lastX = event.x; lastY = event.y
downAt = event.eventTime
travelled = 0f; held = false; twoFingers = false; scrolled = false; secondWasTap = false
// A tap shortly before this touch: holding now drags (double-tap-and-hold).
if (event.eventTime - lastTapAt < DOUBLE_TAP_MS) {
dragging = true
listener.onButton(PointerGestures.BTN_LEFT, true, x, y)
} else {
dragging = false
handler.postDelayed(longPress, HOLD_MS)
}
return true
}
MotionEvent.ACTION_POINTER_DOWN -> {
handler.removeCallbacks(longPress)
twoFingers = true
secondDownAt = event.eventTime
secondWasTap = true
scrollAnchorY = (event.getY(0) + event.getY(1)) / 2f
return true
}
MotionEvent.ACTION_MOVE -> {
if (twoFingers && event.pointerCount >= 2) {
val mid = (event.getY(0) + event.getY(1)) / 2f
val dy = mid - scrollAnchorY
val steps = (dy / SCROLL_STEP_PX).toInt()
if (steps != 0) {
listener.onWheel(-steps)
scrollAnchorY += steps * SCROLL_STEP_PX
scrolled = true
secondWasTap = false
}
return true
}
val dx = event.x - lastX
val dy = event.y - lastY
lastX = event.x; lastY = event.y
travelled += abs(dx) + abs(dy)
if (travelled > slopPx) {
handler.removeCallbacks(longPress)
// A little acceleration: a slow finger is precise, a fast one crosses the screen.
val speed = (abs(dx) + abs(dy))
val gain = sensitivity * (1f + minOf(speed / 40f, 1.5f))
place(x + dx * gain, y + dy * gain)
listener.onMove(x, y)
}
return true
}
MotionEvent.ACTION_POINTER_UP -> {
// The second finger lifting quickly, with nothing scrolled: a right click.
if (twoFingers && secondWasTap && event.eventTime - secondDownAt < TAP_MS && !scrolled) {
listener.onButton(PointerGestures.BTN_RIGHT, true, x, y)
listener.onButton(PointerGestures.BTN_RIGHT, false, x, y)
secondWasTap = false
}
return true
}
MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
handler.removeCallbacks(longPress)
val cancelled = event.actionMasked == MotionEvent.ACTION_CANCEL
when {
dragging -> listener.onButton(PointerGestures.BTN_LEFT, false, x, y)
twoFingers -> {
// Both fingers down and up together, no scroll: a right click.
if (secondWasTap && !scrolled && !cancelled && event.eventTime - downAt < TAP_MS * 2) {
listener.onButton(PointerGestures.BTN_RIGHT, true, x, y)
listener.onButton(PointerGestures.BTN_RIGHT, false, x, y)
}
}
!cancelled && travelled <= slopPx && event.eventTime - downAt < TAP_MS -> {
listener.onButton(PointerGestures.BTN_LEFT, true, x, y)
listener.onButton(PointerGestures.BTN_LEFT, false, x, y)
lastTapAt = event.eventTime
}
}
dragging = false; held = false; twoFingers = false
return true
}
}
return false
}
companion object {
private const val HOLD_MS = 500L
private const val TAP_MS = 300L
private const val DOUBLE_TAP_MS = 300L
private const val SCROLL_STEP_PX = 36f
}
}