.github/workflows/main.yml

@@ -1,6 +1,8 @@
 name: Android CI
 
-on: push
+on:
+  push:
+    branches: [ master ]
 
 jobs:
   build:

app/CMakeLists.txt

@@ -19,7 +19,7 @@ macro(avnc_check_submodule name)
 endmacro()
 
 
-# Required to enable SIMD support on ARM
+# Requred to enable SIMD support on ARM
 if (CMAKE_ANDROID_ARCH STREQUAL "arm64")
     set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} --target=aarch64-linux-android${ANDROID_NATIVE_API_LEVEL}")
 elseif (CMAKE_ANDROID_ARCH STREQUAL "arm")
@@ -53,7 +53,7 @@ set(AVNC_LIBSSL_SRC_DIR ${AVNC_EXTERN_DIR}/wolfssl)
 set(AVNC_LIBSSL_BUILD_DIR ${CMAKE_BINARY_DIR}/wolfssl)
 
 # CMake support in wolfSSl is still under development, so we have to
-# manually set some flags to enable OpenSSL compatibility layer
+# manully set some flags to enable OpenSSL compatibility layer
 set(WOLFSSL_CRL yes)
 set(WOLFSSL_DES3 yes)
 add_definitions(-DOPENSSL_ALL -DOPENSSL_EXTRA -DHAVE_CRL -DHAVE_EX_DATA

app/src/main/java/com/gaurav/avnc/ui/vnc/TouchHandler.kt

@@ -13,9 +13,6 @@ import android.os.Build
 import android.view.*
 import com.gaurav.avnc.viewmodel.VncViewModel
 import com.gaurav.avnc.vnc.PointerButton
-import kotlin.math.PI
-import kotlin.math.abs
-import kotlin.math.atan2
 import kotlin.math.max
 
 /**
@@ -173,13 +170,11 @@ class TouchHandler(private val viewModel: VncViewModel, private val dispatcher:
     private val gestureDetector = GestureDetector(viewModel.app, this)
     private val multiFingerTapDetector = MultiFingerTapDetector()
     private val dragDetector = DragDetector()
-    private val swipeVsScale = SwipeVsScale()
     private val dragEnabled = viewModel.pref.input.gesture.dragEnabled
     private val swipeSensitivity = viewModel.pref.input.gesture.swipeSensitivity
 
 
     private fun handleGestureEvent(event: MotionEvent): Boolean {
-        swipeVsScale.onTouchEvent(event)
         dragDetector.onTouchEvent(event)
         multiFingerTapDetector.onTouchEvent(event)
         scaleDetector.onTouchEvent(event)
@@ -189,8 +184,7 @@ class TouchHandler(private val viewModel: VncViewModel, private val dispatcher:
     override fun onScaleBegin(detector: ScaleGestureDetector) = true
     override fun onScaleEnd(detector: ScaleGestureDetector) {}
     override fun onScale(detector: ScaleGestureDetector): Boolean {
-        if (swipeVsScale.shouldScale())
-            dispatcher.onScale(detector.scaleFactor, detector.focusX, detector.focusY)
+        dispatcher.onScale(detector.scaleFactor, detector.focusX, detector.focusY)
         return true
     }
 
@@ -220,17 +214,15 @@ class TouchHandler(private val viewModel: VncViewModel, private val dispatcher:
         return true
     }
 
-    override fun onScroll(e1: MotionEvent?, e2: MotionEvent, dX: Float, dY: Float): Boolean {
-        // As weird as it may be, e1 can be null on some devices
-        val startPoint = e1?.point() ?: return false
+    override fun onScroll(e1: MotionEvent, e2: MotionEvent, dX: Float, dY: Float): Boolean {
+        val startPoint = e1.point()
         val currentPoint = e2.point()
         val normalizedDx = -dX * swipeSensitivity
         val normalizedDy = -dY * swipeSensitivity
 
         when (e2.pointerCount) {
             1 -> dispatcher.onSwipe1(startPoint, currentPoint, normalizedDx, normalizedDy)
-            2 -> if (swipeVsScale.shouldSwipe())
-                dispatcher.onSwipe2(startPoint, currentPoint, normalizedDx, normalizedDy)
+            2 -> dispatcher.onSwipe2(startPoint, currentPoint, normalizedDx, normalizedDy)
         }
 
         multiFingerTapDetector.reset()
@@ -350,106 +342,4 @@ class TouchHandler(private val viewModel: VncViewModel, private val dispatcher:
             fingerCount = 0
         }
     }
-
-    /**
-     * Swipe vs Scale detector.
-     *
-     * Many two-finger gestures are detected as both swipe & scale gestures because
-     * [GestureDetector] & [ScaleGestureDetector] work independently. This works
-     * very well when two-finger swipe pref is set to 'pan' (default value).
-     * But when the pref is set to 'remote-scroll', this independent detection
-     * becomes an issue. When user tries to scale, it frequently triggers remote
-     * scrolling. And when user tries to scroll, it triggers scaling.
-     *
-     * This class tries to clearly differentiate between these two gestures.
-     * It works by tracking the fingers, and calculating the angle between two paths.
-     * Then [decide] between two gestures by comparing the angle to some thresholds.
-     *
-     * This class can mis-detect some gestures because fingers don't always move
-     * perfectly, but it does provide huge improvement over existing situation.
-     */
-    private inner class SwipeVsScale {
-        private val enabled = viewModel.pref.input.gesture.swipe2 == "remote-scroll"
-        private var detecting = false
-        private var scaleDetected = false
-        private var swipeDetected = false
-
-        private var f1Id = 0 // Finger 1
-        private var f2Id = 0 // Finger 2
-        private val f1Start = PointF()
-        private val f2Start = PointF()
-        private val f1Current = PointF()
-        private val f2Current = PointF()
-
-
-        fun onTouchEvent(e: MotionEvent) {
-            if (!enabled)
-                return
-
-            when (e.actionMasked) {
-                MotionEvent.ACTION_DOWN,
-                MotionEvent.ACTION_CANCEL,
-                MotionEvent.ACTION_UP,
-                MotionEvent.ACTION_POINTER_UP -> {
-                    detecting = false
-                    scaleDetected = false
-                    swipeDetected = false
-                }
-
-                MotionEvent.ACTION_POINTER_DOWN -> {
-                    detecting = e.pointerCount == 2
-                    if (detecting) {
-                        f1Id = e.getPointerId(0)
-                        f2Id = e.getPointerId(1)
-                        f1Start.set(e.getX(f1Id), e.getY(f1Id))
-                        f2Start.set(e.getX(f2Id), e.getY(f2Id))
-                        f1Current.set(f1Start)
-                        f2Current.set(f2Start)
-                    }
-                }
-
-                MotionEvent.ACTION_MOVE -> {
-                    if (detecting) {
-                        f1Current.set(e.getX(f1Id), e.getY(f1Id))
-                        f2Current.set(e.getX(f2Id), e.getY(f2Id))
-                    }
-                }
-            }
-        }
-
-        fun shouldScale(): Boolean {
-            decide()
-            return !enabled || (detecting && scaleDetected)
-        }
-
-        fun shouldSwipe(): Boolean {
-            decide()
-            return !enabled || (detecting && swipeDetected)
-        }
-
-        /**
-         * Decides if gesture can be considered a swipe/scale
-         */
-        private fun decide() {
-            if (!detecting)
-                return
-
-            val t1 = theta(f1Start, f1Current)
-            val t2 = theta(f2Start, f2Current)
-            val diff = abs(t1 - t2)
-
-            scaleDetected = diff > 45
-            swipeDetected = diff < 30
-        }
-
-        /**
-         * Returns the angle made by line [p1]->[p2] with the positive x-axis.
-         * Returned angle will be in range [0, 360]
-         */
-        private fun theta(p1: PointF, p2: PointF): Double {
-            val theta = atan2(p2.y - p1.y, p2.x - p1.x)
-            val degree = (theta / PI) * 180
-            return (degree + 360) % 360 // Map [-180, 180] to [0, 360]
-        }
-    }
 }

app/src/main/java/com/gaurav/avnc/vnc/VncClient.kt

@@ -171,7 +171,7 @@ class VncClient(private val observer: Observer) {
      * @param x    Horizontal pointer coordinate
      * @param y    Vertical pointer coordinate
      */
-    fun moveClientPointer(x: Int, y: Int) {
+    fun moveClientPointer(x: Int, y: Int) = executeSend {
         pointerX = x
         pointerY = y
         observer.onPointerMoved(x, y)