Merge pull request #93933 from m4gr3d/anr_and_crash_bug_fixes

Fix crashes and ANRs reported by the Google Play Console

9 files changed, 240 insertions, 157 deletions

diff --git a/platform/android/java/lib/src/org/godotengine/godot/Godot.kt b/platform/android/java/lib/src/org/godotengine/godot/Godot.kt
index 290be727ab..c188a97ca5 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/Godot.kt
+++ b/platform/android/java/lib/src/org/godotengine/godot/Godot.kt
@@ -84,17 +84,20 @@ class Godot(private val context: Context) : SensorEventListener {
 
 	private companion object {
 		private val TAG = Godot::class.java.simpleName
-	}
 
-	private val windowManager: WindowManager by lazy {
-		requireActivity().getSystemService(Context.WINDOW_SERVICE) as WindowManager
+		// Supported build flavors
+		const val EDITOR_FLAVOR = "editor"
+		const val TEMPLATE_FLAVOR = "template"
 	}
+
+	private val windowManager: WindowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+	private val mSensorManager: SensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+	private val mClipboard: ClipboardManager = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+	private val vibratorService: Vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+
 	private val pluginRegistry: GodotPluginRegistry by lazy {
 		GodotPluginRegistry.getPluginRegistry()
 	}
-	private val mSensorManager: SensorManager by lazy {
-		requireActivity().getSystemService(Context.SENSOR_SERVICE) as SensorManager
-	}
 	private val mAccelerometer: Sensor? by lazy {
 		mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
 	}
@@ -107,9 +110,6 @@ class Godot(private val context: Context) : SensorEventListener {
 	private val mGyroscope: Sensor? by lazy {
 		mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
 	}
-	private val mClipboard: ClipboardManager by lazy {
-		requireActivity().getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-	}
 
 	private val uiChangeListener = View.OnSystemUiVisibilityChangeListener { visibility: Int ->
 		if (visibility and View.SYSTEM_UI_FLAG_FULLSCREEN == 0) {
@@ -192,6 +192,8 @@ class Godot(private val context: Context) : SensorEventListener {
 			return
 		}
 
+		Log.v(TAG, "OnCreate: $primaryHost")
+
 		darkMode = context.resources?.configuration?.uiMode?.and(Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
 
 		beginBenchmarkMeasure("Startup", "Godot::onCreate")
@@ -200,6 +202,8 @@ class Godot(private val context: Context) : SensorEventListener {
 			val activity = requireActivity()
 			val window = activity.window
 			window.addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
+
+			Log.v(TAG, "Initializing Godot plugin registry")
 			GodotPluginRegistry.initializePluginRegistry(this, primaryHost.getHostPlugins(this))
 			if (io == null) {
 				io = GodotIO(activity)
@@ -323,13 +327,17 @@ class Godot(private val context: Context) : SensorEventListener {
 			return false
 		}
 
-		if (expansionPackPath.isNotEmpty()) {
-			commandLine.add("--main-pack")
-			commandLine.add(expansionPackPath)
-		}
-		val activity = requireActivity()
-		if (!nativeLayerInitializeCompleted) {
-			nativeLayerInitializeCompleted = GodotLib.initialize(
+		Log.v(TAG, "OnInitNativeLayer: $host")
+
+		beginBenchmarkMeasure("Startup", "Godot::onInitNativeLayer")
+		try {
+			if (expansionPackPath.isNotEmpty()) {
+				commandLine.add("--main-pack")
+				commandLine.add(expansionPackPath)
+			}
+			val activity = requireActivity()
+			if (!nativeLayerInitializeCompleted) {
+				nativeLayerInitializeCompleted = GodotLib.initialize(
 					activity,
 					this,
 					activity.assets,
@@ -338,15 +346,20 @@ class Godot(private val context: Context) : SensorEventListener {
 					directoryAccessHandler,
 					fileAccessHandler,
 					useApkExpansion,
-			)
-		}
+				)
+				Log.v(TAG, "Godot native layer initialization completed: $nativeLayerInitializeCompleted")
+			}
 
-		if (nativeLayerInitializeCompleted && !nativeLayerSetupCompleted) {
-			nativeLayerSetupCompleted = GodotLib.setup(commandLine.toTypedArray(), tts)
-			if (!nativeLayerSetupCompleted) {
-				Log.e(TAG, "Unable to setup the Godot engine! Aborting...")
-				alert(R.string.error_engine_setup_message, R.string.text_error_title, this::forceQuit)
+			if (nativeLayerInitializeCompleted && !nativeLayerSetupCompleted) {
+				nativeLayerSetupCompleted = GodotLib.setup(commandLine.toTypedArray(), tts)
+				if (!nativeLayerSetupCompleted) {
+					throw IllegalStateException("Unable to setup the Godot engine! Aborting...")
+				} else {
+					Log.v(TAG, "Godot native layer setup completed")
+				}
 			}
+		} finally {
+			endBenchmarkMeasure("Startup", "Godot::onInitNativeLayer")
 		}
 		return isNativeInitialized()
 	}
@@ -370,6 +383,9 @@ class Godot(private val context: Context) : SensorEventListener {
 			throw IllegalStateException("onInitNativeLayer() must be invoked successfully prior to initializing the render view")
 		}
 
+		Log.v(TAG, "OnInitRenderView: $host")
+
+		beginBenchmarkMeasure("Startup", "Godot::onInitRenderView")
 		try {
 			val activity: Activity = host.activity
 			containerLayout = providedContainerLayout
@@ -392,8 +408,7 @@ class Godot(private val context: Context) : SensorEventListener {
 			containerLayout?.addView(editText)
 			renderView = if (usesVulkan()) {
 				if (!meetsVulkanRequirements(activity.packageManager)) {
-					alert(R.string.error_missing_vulkan_requirements_message, R.string.text_error_title, this::forceQuit)
-					return null
+					throw IllegalStateException(activity.getString(R.string.error_missing_vulkan_requirements_message))
 				}
 				GodotVulkanRenderView(host, this)
 			} else {
@@ -482,11 +497,14 @@ class Godot(private val context: Context) : SensorEventListener {
 				containerLayout?.removeAllViews()
 				containerLayout = null
 			}
+
+			endBenchmarkMeasure("Startup", "Godot::onInitRenderView")
 		}
 		return containerLayout
 	}
 
 	fun onStart(host: GodotHost) {
+		Log.v(TAG, "OnStart: $host")
 		if (host != primaryHost) {
 			return
 		}
@@ -495,6 +513,7 @@ class Godot(private val context: Context) : SensorEventListener {
 	}
 
 	fun onResume(host: GodotHost) {
+		Log.v(TAG, "OnResume: $host")
 		if (host != primaryHost) {
 			return
 		}
@@ -527,6 +546,7 @@ class Godot(private val context: Context) : SensorEventListener {
 	}
 
 	fun onPause(host: GodotHost) {
+		Log.v(TAG, "OnPause: $host")
 		if (host != primaryHost) {
 			return
 		}
@@ -539,6 +559,7 @@ class Godot(private val context: Context) : SensorEventListener {
 	}
 
 	fun onStop(host: GodotHost) {
+		Log.v(TAG, "OnStop: $host")
 		if (host != primaryHost) {
 			return
 		}
@@ -547,6 +568,7 @@ class Godot(private val context: Context) : SensorEventListener {
 	}
 
 	fun onDestroy(primaryHost: GodotHost) {
+		Log.v(TAG, "OnDestroy: $primaryHost")
 		if (this.primaryHost != primaryHost) {
 			return
 		}
@@ -604,18 +626,29 @@ class Godot(private val context: Context) : SensorEventListener {
 	 * Invoked on the render thread when the Godot setup is complete.
 	 */
 	private fun onGodotSetupCompleted() {
-		Log.d(TAG, "OnGodotSetupCompleted")
-
-		// These properties are defined after Godot setup completion, so we retrieve them here.
-		val longPressEnabled = java.lang.Boolean.parseBoolean(GodotLib.getGlobal("input_devices/pointing/android/enable_long_press_as_right_click"))
-		val panScaleEnabled = java.lang.Boolean.parseBoolean(GodotLib.getGlobal("input_devices/pointing/android/enable_pan_and_scale_gestures"))
-		val rotaryInputAxis = java.lang.Integer.parseInt(GodotLib.getGlobal("input_devices/pointing/android/rotary_input_scroll_axis"))
-
-		runOnUiThread {
-			renderView?.inputHandler?.apply {
-				enableLongPress(longPressEnabled)
-				enablePanningAndScalingGestures(panScaleEnabled)
-				setRotaryInputAxis(rotaryInputAxis)
+		Log.v(TAG, "OnGodotSetupCompleted")
+
+		if (!isEditorBuild()) {
+			// These properties are defined after Godot setup completion, so we retrieve them here.
+			val longPressEnabled = java.lang.Boolean.parseBoolean(GodotLib.getGlobal("input_devices/pointing/android/enable_long_press_as_right_click"))
+			val panScaleEnabled = java.lang.Boolean.parseBoolean(GodotLib.getGlobal("input_devices/pointing/android/enable_pan_and_scale_gestures"))
+			val rotaryInputAxisValue = GodotLib.getGlobal("input_devices/pointing/android/rotary_input_scroll_axis")
+
+			val useInputBuffering = java.lang.Boolean.parseBoolean(GodotLib.getGlobal("input_devices/buffering/android/use_input_buffering"))
+			val useAccumulatedInput = java.lang.Boolean.parseBoolean(GodotLib.getGlobal("input_devices/buffering/android/use_accumulated_input"))
+			GodotLib.updateInputDispatchSettings(useAccumulatedInput, useInputBuffering)
+
+			runOnUiThread {
+				renderView?.inputHandler?.apply {
+					enableLongPress(longPressEnabled)
+					enablePanningAndScalingGestures(panScaleEnabled)
+					enableInputDispatchToRenderThread(!useInputBuffering && !useAccumulatedInput)
+					try {
+						setRotaryInputAxis(Integer.parseInt(rotaryInputAxisValue))
+					} catch (e: NumberFormatException) {
+						Log.w(TAG, e)
+					}
+				}
 			}
 		}
 
@@ -629,7 +662,7 @@ class Godot(private val context: Context) : SensorEventListener {
 	 * Invoked on the render thread when the Godot main loop has started.
 	 */
 	private fun onGodotMainLoopStarted() {
-		Log.d(TAG, "OnGodotMainLoopStarted")
+		Log.v(TAG, "OnGodotMainLoopStarted")
 
 		for (plugin in pluginRegistry.allPlugins) {
 			plugin.onGodotMainLoopStarted()
@@ -646,12 +679,7 @@ class Godot(private val context: Context) : SensorEventListener {
 		decorView.setOnSystemUiVisibilityChangeListener(uiChangeListener)
 	}
 
-	@Keep
-	private fun alert(message: String, title: String) {
-		alert(message, title, null)
-	}
-
-	private fun alert(
+	fun alert(
 		@StringRes messageResId: Int,
 		@StringRes titleResId: Int,
 		okCallback: Runnable?
@@ -660,7 +688,9 @@ class Godot(private val context: Context) : SensorEventListener {
 		alert(res.getString(messageResId), res.getString(titleResId), okCallback)
 	}
 
-	private fun alert(message: String, title: String, okCallback: Runnable?) {
+	@JvmOverloads
+	@Keep
+	fun alert(message: String, title: String, okCallback: Runnable? = null) {
 		val activity: Activity = getActivity() ?: return
 		runOnUiThread {
 			val builder = AlertDialog.Builder(activity)
@@ -759,6 +789,11 @@ class Godot(private val context: Context) : SensorEventListener {
 		return mClipboard.hasPrimaryClip()
 	}
 
+	/**
+	 * @return true if this is an editor build, false if this is a template build
+	 */
+	fun isEditorBuild() = BuildConfig.FLAVOR == EDITOR_FLAVOR
+
 	fun getClipboard(): String {
 		val clipData = mClipboard.primaryClip ?: return ""
 		val text = clipData.getItemAt(0).text ?: return ""
@@ -770,7 +805,7 @@ class Godot(private val context: Context) : SensorEventListener {
 		mClipboard.setPrimaryClip(clip)
 	}
 
-	private fun forceQuit() {
+	fun forceQuit() {
 		forceQuit(0)
 	}
 
@@ -881,7 +916,6 @@ class Godot(private val context: Context) : SensorEventListener {
 	@Keep
 	private fun vibrate(durationMs: Int, amplitude: Int) {
 		if (durationMs > 0 && requestPermission("VIBRATE")) {
-			val vibratorService = getActivity()?.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator? ?: return
 			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 				if (amplitude <= -1) {
 					vibratorService.vibrate(
diff --git a/platform/android/java/lib/src/org/godotengine/godot/GodotFragment.java b/platform/android/java/lib/src/org/godotengine/godot/GodotFragment.java
index a323045e1b..1612ddd0b3 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/GodotFragment.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/GodotFragment.java
@@ -42,6 +42,7 @@ import android.content.res.Configuration;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Messenger;
+import android.text.TextUtils;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -203,6 +204,12 @@ public class GodotFragment extends Fragment implements IDownloaderClient, GodotH
 			if (godotContainerLayout == null) {
 				throw new IllegalStateException("Unable to initialize engine render view");
 			}
+		} catch (IllegalStateException e) {
+			Log.e(TAG, "Engine initialization failed", e);
+			final String errorMessage = TextUtils.isEmpty(e.getMessage())
+					? getString(R.string.error_engine_setup_message)
+					: e.getMessage();
+			godot.alert(errorMessage, getString(R.string.text_error_title), godot::forceQuit);
 		} catch (IllegalArgumentException ignored) {
 			final Activity activity = getActivity();
 			Intent notifierIntent = new Intent(activity, activity.getClass());
diff --git a/platform/android/java/lib/src/org/godotengine/godot/GodotIO.java b/platform/android/java/lib/src/org/godotengine/godot/GodotIO.java
index 4b51bd778d..219631284a 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/GodotIO.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/GodotIO.java
@@ -121,7 +121,7 @@ public class GodotIO {
 
 			activity.startActivity(intent);
 			return 0;
-		} catch (ActivityNotFoundException e) {
+		} catch (Exception e) {
 			Log.e(TAG, "Unable to open uri " + uriString, e);
 			return 1;
 		}
diff --git a/platform/android/java/lib/src/org/godotengine/godot/GodotLib.java b/platform/android/java/lib/src/org/godotengine/godot/GodotLib.java
index d0c3d4a687..37e889daf7 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/GodotLib.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/GodotLib.java
@@ -240,4 +240,11 @@ public class GodotLib {
 	 * @see GodotRenderer#onActivityPaused()
 	 */
 	public static native void onRendererPaused();
+
+	/**
+	 * Invoked on the GL thread to update the input dispatch settings
+	 * @param useAccumulatedInput True to use accumulated input, false otherwise
+	 * @param useInputBuffering True to use input buffering, false otherwise
+	 */
+	public static native void updateInputDispatchSettings(boolean useAccumulatedInput, boolean useInputBuffering);
 }
diff --git a/platform/android/java/lib/src/org/godotengine/godot/gl/GLSurfaceView.java b/platform/android/java/lib/src/org/godotengine/godot/gl/GLSurfaceView.java
index c316812404..c9421a3257 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/gl/GLSurfaceView.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/gl/GLSurfaceView.java
@@ -1704,15 +1704,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
 				mHasSurface = true;
 				mFinishedCreatingEglSurface = false;
 				sGLThreadManager.notifyAll();
-				while (mWaitingForSurface
-						&& !mFinishedCreatingEglSurface
-						&& !mExited) {
-					try {
-						sGLThreadManager.wait();
-					} catch (InterruptedException e) {
-						Thread.currentThread().interrupt();
-					}
-				}
 			}
 		}
 
@@ -1723,13 +1714,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
 				}
 				mHasSurface = false;
 				sGLThreadManager.notifyAll();
-				while((!mWaitingForSurface) && (!mExited)) {
-					try {
-						sGLThreadManager.wait();
-					} catch (InterruptedException e) {
-						Thread.currentThread().interrupt();
-					}
-				}
 			}
 		}
 
@@ -1740,16 +1724,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
 				}
 				mRequestPaused = true;
 				sGLThreadManager.notifyAll();
-				while ((! mExited) && (! mPaused)) {
-					if (LOG_PAUSE_RESUME) {
-						Log.i("Main thread", "onPause waiting for mPaused.");
-					}
-					try {
-						sGLThreadManager.wait();
-					} catch (InterruptedException ex) {
-						Thread.currentThread().interrupt();
-					}
-				}
 			}
 		}
 
@@ -1762,16 +1736,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
 				mRequestRender = true;
 				mRenderComplete = false;
 				sGLThreadManager.notifyAll();
-				while ((! mExited) && mPaused && (!mRenderComplete)) {
-					if (LOG_PAUSE_RESUME) {
-						Log.i("Main thread", "onResume waiting for !mPaused.");
-					}
-					try {
-						sGLThreadManager.wait();
-					} catch (InterruptedException ex) {
-						Thread.currentThread().interrupt();
-					}
-				}
 			}
 		}
 
@@ -1793,19 +1757,6 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
 				}
 
 				sGLThreadManager.notifyAll();
-
-				// Wait for thread to react to resize and render a frame
-				while (! mExited && !mPaused && !mRenderComplete
-						&& ableToDraw()) {
-					if (LOG_SURFACE) {
-						Log.i("Main thread", "onWindowResize waiting for render complete from tid=" + getId());
-					}
-					try {
-						sGLThreadManager.wait();
-					} catch (InterruptedException ex) {
-						Thread.currentThread().interrupt();
-					}
-				}
 			}
 		}
 
diff --git a/platform/android/java/lib/src/org/godotengine/godot/input/GodotGestureHandler.kt b/platform/android/java/lib/src/org/godotengine/godot/input/GodotGestureHandler.kt
index 49b34a5229..4cd3bd8db9 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/input/GodotGestureHandler.kt
+++ b/platform/android/java/lib/src/org/godotengine/godot/input/GodotGestureHandler.kt
@@ -44,7 +44,7 @@ import org.godotengine.godot.GodotLib
  * @See https://developer.android.com/reference/android/view/GestureDetector.SimpleOnGestureListener
  * @See https://developer.android.com/reference/android/view/ScaleGestureDetector.OnScaleGestureListener
  */
-internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureListener {
+internal class GodotGestureHandler(private val inputHandler: GodotInputHandler) : SimpleOnGestureListener(), OnScaleGestureListener {
 
 	companion object {
 		private val TAG = GodotGestureHandler::class.java.simpleName
@@ -65,13 +65,13 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 	private var lastDragY: Float = 0.0f
 
 	override fun onDown(event: MotionEvent): Boolean {
-		GodotInputHandler.handleMotionEvent(event, MotionEvent.ACTION_DOWN, nextDownIsDoubleTap)
+		inputHandler.handleMotionEvent(event, MotionEvent.ACTION_DOWN, nextDownIsDoubleTap)
 		nextDownIsDoubleTap = false
 		return true
 	}
 
 	override fun onSingleTapUp(event: MotionEvent): Boolean {
-		GodotInputHandler.handleMotionEvent(event)
+		inputHandler.handleMotionEvent(event)
 		return true
 	}
 
@@ -85,10 +85,10 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 		}
 
 		// Cancel the previous down event
-		GodotInputHandler.handleMotionEvent(event, MotionEvent.ACTION_CANCEL)
+		inputHandler.handleMotionEvent(event, MotionEvent.ACTION_CANCEL)
 
 		// Turn a context click into a single tap right mouse button click.
-		GodotInputHandler.handleMouseEvent(
+		inputHandler.handleMouseEvent(
 			event,
 			MotionEvent.ACTION_DOWN,
 			MotionEvent.BUTTON_SECONDARY,
@@ -104,7 +104,7 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 
 		if (!hasCapture) {
 			// Dispatch a mouse relative ACTION_UP event to signal the end of the capture
-			GodotInputHandler.handleMouseEvent(MotionEvent.ACTION_UP, true)
+			inputHandler.handleMouseEvent(MotionEvent.ACTION_UP, true)
 		}
 		pointerCaptureInProgress = hasCapture
 	}
@@ -131,9 +131,9 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 			if (contextClickInProgress || GodotInputHandler.isMouseEvent(event)) {
 				// This may be an ACTION_BUTTON_RELEASE event which we don't handle,
 				// so we convert it to an ACTION_UP event.
-				GodotInputHandler.handleMouseEvent(event, MotionEvent.ACTION_UP)
+				inputHandler.handleMouseEvent(event, MotionEvent.ACTION_UP)
 			} else {
-				GodotInputHandler.handleTouchEvent(event)
+				inputHandler.handleTouchEvent(event)
 			}
 			pointerCaptureInProgress = false
 			dragInProgress = false
@@ -148,7 +148,7 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 
 	private fun onActionMove(event: MotionEvent): Boolean {
 		if (contextClickInProgress) {
-			GodotInputHandler.handleMouseEvent(event, event.actionMasked, MotionEvent.BUTTON_SECONDARY, false)
+			inputHandler.handleMouseEvent(event, event.actionMasked, MotionEvent.BUTTON_SECONDARY, false)
 			return true
 		} else if (!scaleInProgress) {
 			// The 'onScroll' event is triggered with a long delay.
@@ -158,7 +158,7 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 			if (lastDragX != event.getX(0) || lastDragY != event.getY(0)) {
 				lastDragX = event.getX(0)
 				lastDragY = event.getY(0)
-				GodotInputHandler.handleMotionEvent(event)
+				inputHandler.handleMotionEvent(event)
 				return true
 			}
 		}
@@ -168,9 +168,9 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 	override fun onDoubleTapEvent(event: MotionEvent): Boolean {
 		if (event.actionMasked == MotionEvent.ACTION_UP) {
 			nextDownIsDoubleTap = false
-			GodotInputHandler.handleMotionEvent(event)
+			inputHandler.handleMotionEvent(event)
 		} else if (event.actionMasked == MotionEvent.ACTION_MOVE && !panningAndScalingEnabled) {
-			GodotInputHandler.handleMotionEvent(event)
+			inputHandler.handleMotionEvent(event)
 		}
 
 		return true
@@ -191,7 +191,7 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 			if (dragInProgress || lastDragX != 0.0f || lastDragY != 0.0f) {
 				if (originEvent != null) {
 					// Cancel the drag
-					GodotInputHandler.handleMotionEvent(originEvent, MotionEvent.ACTION_CANCEL)
+					inputHandler.handleMotionEvent(originEvent, MotionEvent.ACTION_CANCEL)
 				}
 				dragInProgress = false
 				lastDragX = 0.0f
@@ -202,12 +202,12 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 		val x = terminusEvent.x
 		val y = terminusEvent.y
 		if (terminusEvent.pointerCount >= 2 && panningAndScalingEnabled && !pointerCaptureInProgress && !dragInProgress) {
-			GodotLib.pan(x, y, distanceX / 5f, distanceY / 5f)
+			inputHandler.handlePanEvent(x, y, distanceX / 5f, distanceY / 5f)
 		} else if (!scaleInProgress) {
 			dragInProgress = true
 			lastDragX = terminusEvent.getX(0)
 			lastDragY = terminusEvent.getY(0)
-			GodotInputHandler.handleMotionEvent(terminusEvent)
+			inputHandler.handleMotionEvent(terminusEvent)
 		}
 		return true
 	}
@@ -218,11 +218,7 @@ internal class GodotGestureHandler : SimpleOnGestureListener(), OnScaleGestureLi
 		}
 
 		if (detector.scaleFactor >= 0.8f && detector.scaleFactor != 1f && detector.scaleFactor <= 1.2f) {
-			GodotLib.magnify(
-					detector.focusX,
-					detector.focusY,
-					detector.scaleFactor
-			)
+			inputHandler.handleMagnifyEvent(detector.focusX, detector.focusY, detector.scaleFactor)
 		}
 		return true
 	}
diff --git a/platform/android/java/lib/src/org/godotengine/godot/input/GodotInputHandler.java b/platform/android/java/lib/src/org/godotengine/godot/input/GodotInputHandler.java
index 83e76e49c9..889618914d 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/input/GodotInputHandler.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/input/GodotInputHandler.java
@@ -75,7 +75,9 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 	 */
 	private int lastSeenToolType = MotionEvent.TOOL_TYPE_UNKNOWN;
 
-	private static int rotaryInputAxis = ROTARY_INPUT_VERTICAL_AXIS;
+	private int rotaryInputAxis = ROTARY_INPUT_VERTICAL_AXIS;
+
+	private boolean dispatchInputToRenderThread = false;
 
 	public GodotInputHandler(GodotRenderView godotView) {
 		final Context context = godotView.getView().getContext();
@@ -83,7 +85,7 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		mInputManager = (InputManager)context.getSystemService(Context.INPUT_SERVICE);
 		mInputManager.registerInputDeviceListener(this, null);
 
-		this.godotGestureHandler = new GodotGestureHandler();
+		this.godotGestureHandler = new GodotGestureHandler(this);
 		this.gestureDetector = new GestureDetector(context, godotGestureHandler);
 		this.gestureDetector.setIsLongpressEnabled(false);
 		this.scaleGestureDetector = new ScaleGestureDetector(context, godotGestureHandler);
@@ -109,6 +111,22 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 	}
 
 	/**
+	 * Specifies whether input should be dispatch on the UI thread or on the Render thread.
+	 * @param enable true to dispatch input on the Render thread, false to dispatch input on the UI thread
+	 */
+	public void enableInputDispatchToRenderThread(boolean enable) {
+		this.dispatchInputToRenderThread = enable;
+	}
+
+	/**
+	 * @return true if input must be dispatched from the render thread. If false, input is
+	 * dispatched from the UI thread.
+	 */
+	private boolean shouldDispatchInputToRenderThread() {
+		return dispatchInputToRenderThread;
+	}
+
+	/**
 	 * On Wear OS devices, sets which axis of the mouse wheel rotary input is mapped to. This is 1 (vertical axis) by default.
 	 */
 	public void setRotaryInputAxis(int axis) {
@@ -151,14 +169,14 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 			if (mJoystickIds.indexOfKey(deviceId) >= 0) {
 				final int button = getGodotButton(keyCode);
 				final int godotJoyId = mJoystickIds.get(deviceId);
-				GodotLib.joybutton(godotJoyId, button, false);
+				handleJoystickButtonEvent(godotJoyId, button, false);
 			}
 		} else {
 			// getKeyCode(): The physical key that was pressed.
 			final int physical_keycode = event.getKeyCode();
 			final int unicode = event.getUnicodeChar();
 			final int key_label = event.getDisplayLabel();
-			GodotLib.key(physical_keycode, unicode, key_label, false, event.getRepeatCount() > 0);
+			handleKeyEvent(physical_keycode, unicode, key_label, false, event.getRepeatCount() > 0);
 		};
 
 		return true;
@@ -187,13 +205,13 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 			if (mJoystickIds.indexOfKey(deviceId) >= 0) {
 				final int button = getGodotButton(keyCode);
 				final int godotJoyId = mJoystickIds.get(deviceId);
-				GodotLib.joybutton(godotJoyId, button, true);
+				handleJoystickButtonEvent(godotJoyId, button, true);
 			}
 		} else {
 			final int physical_keycode = event.getKeyCode();
 			final int unicode = event.getUnicodeChar();
 			final int key_label = event.getDisplayLabel();
-			GodotLib.key(physical_keycode, unicode, key_label, true, event.getRepeatCount() > 0);
+			handleKeyEvent(physical_keycode, unicode, key_label, true, event.getRepeatCount() > 0);
 		}
 
 		return true;
@@ -248,7 +266,7 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 					if (joystick.axesValues.indexOfKey(axis) < 0 || (float)joystick.axesValues.get(axis) != value) {
 						// save value to prevent repeats
 						joystick.axesValues.put(axis, value);
-						GodotLib.joyaxis(godotJoyId, i, value);
+						handleJoystickAxisEvent(godotJoyId, i, value);
 					}
 				}
 
@@ -258,7 +276,7 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 					if (joystick.hatX != hatX || joystick.hatY != hatY) {
 						joystick.hatX = hatX;
 						joystick.hatY = hatY;
-						GodotLib.joyhat(godotJoyId, hatX, hatY);
+						handleJoystickHatEvent(godotJoyId, hatX, hatY);
 					}
 				}
 				return true;
@@ -284,10 +302,12 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		int[] deviceIds = mInputManager.getInputDeviceIds();
 		for (int deviceId : deviceIds) {
 			InputDevice device = mInputManager.getInputDevice(deviceId);
-			if (DEBUG) {
-				Log.v(TAG, String.format("init() deviceId:%d, Name:%s\n", deviceId, device.getName()));
+			if (device != null) {
+				if (DEBUG) {
+					Log.v(TAG, String.format("init() deviceId:%d, Name:%s\n", deviceId, device.getName()));
+				}
+				onInputDeviceAdded(deviceId);
 			}
-			onInputDeviceAdded(deviceId);
 		}
 	}
 
@@ -364,7 +384,7 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		}
 		mJoysticksDevices.put(deviceId, joystick);
 
-		GodotLib.joyconnectionchanged(id, true, joystick.name);
+		handleJoystickConnectionChangedEvent(id, true, joystick.name);
 	}
 
 	@Override
@@ -378,7 +398,7 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		final int godotJoyId = mJoystickIds.get(deviceId);
 		mJoystickIds.delete(deviceId);
 		mJoysticksDevices.delete(deviceId);
-		GodotLib.joyconnectionchanged(godotJoyId, false, "");
+		handleJoystickConnectionChangedEvent(godotJoyId, false, "");
 	}
 
 	@Override
@@ -482,15 +502,15 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		}
 	}
 
-	static boolean handleMotionEvent(final MotionEvent event) {
+	boolean handleMotionEvent(final MotionEvent event) {
 		return handleMotionEvent(event, event.getActionMasked());
 	}
 
-	static boolean handleMotionEvent(final MotionEvent event, int eventActionOverride) {
+	boolean handleMotionEvent(final MotionEvent event, int eventActionOverride) {
 		return handleMotionEvent(event, eventActionOverride, false);
 	}
 
-	static boolean handleMotionEvent(final MotionEvent event, int eventActionOverride, boolean doubleTap) {
+	boolean handleMotionEvent(final MotionEvent event, int eventActionOverride, boolean doubleTap) {
 		if (isMouseEvent(event)) {
 			return handleMouseEvent(event, eventActionOverride, doubleTap);
 		}
@@ -523,19 +543,19 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		return (float)Math.cos(orientation) * tiltMult;
 	}
 
-	static boolean handleMouseEvent(final MotionEvent event) {
+	boolean handleMouseEvent(final MotionEvent event) {
 		return handleMouseEvent(event, event.getActionMasked());
 	}
 
-	static boolean handleMouseEvent(final MotionEvent event, int eventActionOverride) {
+	boolean handleMouseEvent(final MotionEvent event, int eventActionOverride) {
 		return handleMouseEvent(event, eventActionOverride, false);
 	}
 
-	static boolean handleMouseEvent(final MotionEvent event, int eventActionOverride, boolean doubleTap) {
+	boolean handleMouseEvent(final MotionEvent event, int eventActionOverride, boolean doubleTap) {
 		return handleMouseEvent(event, eventActionOverride, event.getButtonState(), doubleTap);
 	}
 
-	static boolean handleMouseEvent(final MotionEvent event, int eventActionOverride, int buttonMaskOverride, boolean doubleTap) {
+	boolean handleMouseEvent(final MotionEvent event, int eventActionOverride, int buttonMaskOverride, boolean doubleTap) {
 		final float x = event.getX();
 		final float y = event.getY();
 
@@ -564,11 +584,11 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 		return handleMouseEvent(eventActionOverride, buttonMaskOverride, x, y, horizontalFactor, verticalFactor, doubleTap, sourceMouseRelative, pressure, getEventTiltX(event), getEventTiltY(event));
 	}
 
-	static boolean handleMouseEvent(int eventAction, boolean sourceMouseRelative) {
+	boolean handleMouseEvent(int eventAction, boolean sourceMouseRelative) {
 		return handleMouseEvent(eventAction, 0, 0f, 0f, 0f, 0f, false, sourceMouseRelative, 1f, 0f, 0f);
 	}
 
-	static boolean handleMouseEvent(int eventAction, int buttonsMask, float x, float y, float deltaX, float deltaY, boolean doubleClick, boolean sourceMouseRelative, float pressure, float tiltX, float tiltY) {
+	boolean handleMouseEvent(int eventAction, int buttonsMask, float x, float y, float deltaX, float deltaY, boolean doubleClick, boolean sourceMouseRelative, float pressure, float tiltX, float tiltY) {
 		// Fix the buttonsMask
 		switch (eventAction) {
 			case MotionEvent.ACTION_CANCEL:
@@ -584,6 +604,7 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 				break;
 		}
 
+		final int updatedButtonsMask = buttonsMask;
 		// We don't handle ACTION_BUTTON_PRESS and ACTION_BUTTON_RELEASE events as they typically
 		// follow ACTION_DOWN and ACTION_UP events. As such, handling them would result in duplicate
 		// stream of events to the engine.
@@ -596,22 +617,26 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 			case MotionEvent.ACTION_HOVER_MOVE:
 			case MotionEvent.ACTION_MOVE:
 			case MotionEvent.ACTION_SCROLL: {
-				GodotLib.dispatchMouseEvent(eventAction, buttonsMask, x, y, deltaX, deltaY, doubleClick, sourceMouseRelative, pressure, tiltX, tiltY);
+				if (shouldDispatchInputToRenderThread()) {
+					mRenderView.queueOnRenderThread(() -> GodotLib.dispatchMouseEvent(eventAction, updatedButtonsMask, x, y, deltaX, deltaY, doubleClick, sourceMouseRelative, pressure, tiltX, tiltY));
+				} else {
+					GodotLib.dispatchMouseEvent(eventAction, updatedButtonsMask, x, y, deltaX, deltaY, doubleClick, sourceMouseRelative, pressure, tiltX, tiltY);
+				}
 				return true;
 			}
 		}
 		return false;
 	}
 
-	static boolean handleTouchEvent(final MotionEvent event) {
+	boolean handleTouchEvent(final MotionEvent event) {
 		return handleTouchEvent(event, event.getActionMasked());
 	}
 
-	static boolean handleTouchEvent(final MotionEvent event, int eventActionOverride) {
+	boolean handleTouchEvent(final MotionEvent event, int eventActionOverride) {
 		return handleTouchEvent(event, eventActionOverride, false);
 	}
 
-	static boolean handleTouchEvent(final MotionEvent event, int eventActionOverride, boolean doubleTap) {
+	boolean handleTouchEvent(final MotionEvent event, int eventActionOverride, boolean doubleTap) {
 		final int pointerCount = event.getPointerCount();
 		if (pointerCount == 0) {
 			return true;
@@ -636,10 +661,70 @@ public class GodotInputHandler implements InputManager.InputDeviceListener {
 			case MotionEvent.ACTION_MOVE:
 			case MotionEvent.ACTION_POINTER_UP:
 			case MotionEvent.ACTION_POINTER_DOWN: {
-				GodotLib.dispatchTouchEvent(eventActionOverride, actionPointerId, pointerCount, positions, doubleTap);
+				if (shouldDispatchInputToRenderThread()) {
+					mRenderView.queueOnRenderThread(() -> GodotLib.dispatchTouchEvent(eventActionOverride, actionPointerId, pointerCount, positions, doubleTap));
+				} else {
+					GodotLib.dispatchTouchEvent(eventActionOverride, actionPointerId, pointerCount, positions, doubleTap);
+				}
 				return true;
 			}
 		}
 		return false;
 	}
+
+	void handleMagnifyEvent(float x, float y, float factor) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.magnify(x, y, factor));
+		} else {
+			GodotLib.magnify(x, y, factor);
+		}
+	}
+
+	void handlePanEvent(float x, float y, float deltaX, float deltaY) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.pan(x, y, deltaX, deltaY));
+		} else {
+			GodotLib.pan(x, y, deltaX, deltaY);
+		}
+	}
+
+	private void handleJoystickButtonEvent(int device, int button, boolean pressed) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.joybutton(device, button, pressed));
+		} else {
+			GodotLib.joybutton(device, button, pressed);
+		}
+	}
+
+	private void handleJoystickAxisEvent(int device, int axis, float value) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.joyaxis(device, axis, value));
+		} else {
+			GodotLib.joyaxis(device, axis, value);
+		}
+	}
+
+	private void handleJoystickHatEvent(int device, int hatX, int hatY) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.joyhat(device, hatX, hatY));
+		} else {
+			GodotLib.joyhat(device, hatX, hatY);
+		}
+	}
+
+	private void handleJoystickConnectionChangedEvent(int device, boolean connected, String name) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.joyconnectionchanged(device, connected, name));
+		} else {
+			GodotLib.joyconnectionchanged(device, connected, name);
+		}
+	}
+
+	void handleKeyEvent(int physicalKeycode, int unicode, int keyLabel, boolean pressed, boolean echo) {
+		if (shouldDispatchInputToRenderThread()) {
+			mRenderView.queueOnRenderThread(() -> GodotLib.key(physicalKeycode, unicode, keyLabel, pressed, echo));
+		} else {
+			GodotLib.key(physicalKeycode, unicode, keyLabel, pressed, echo);
+		}
+	}
 }
diff --git a/platform/android/java/lib/src/org/godotengine/godot/input/GodotTextInputWrapper.java b/platform/android/java/lib/src/org/godotengine/godot/input/GodotTextInputWrapper.java
index 06b565c30f..e545669970 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/input/GodotTextInputWrapper.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/input/GodotTextInputWrapper.java
@@ -93,8 +93,8 @@ public class GodotTextInputWrapper implements TextWatcher, OnEditorActionListene
 	@Override
 	public void beforeTextChanged(final CharSequence pCharSequence, final int start, final int count, final int after) {
 		for (int i = 0; i < count; ++i) {
-			GodotLib.key(KeyEvent.KEYCODE_DEL, 0, 0, true, false);
-			GodotLib.key(KeyEvent.KEYCODE_DEL, 0, 0, false, false);
+			mRenderView.getInputHandler().handleKeyEvent(KeyEvent.KEYCODE_DEL, 0, 0, true, false);
+			mRenderView.getInputHandler().handleKeyEvent(KeyEvent.KEYCODE_DEL, 0, 0, false, false);
 
 			if (mHasSelection) {
 				mHasSelection = false;
@@ -115,8 +115,8 @@ public class GodotTextInputWrapper implements TextWatcher, OnEditorActionListene
 				// Return keys are handled through action events
 				continue;
 			}
-			GodotLib.key(0, character, 0, true, false);
-			GodotLib.key(0, character, 0, false, false);
+			mRenderView.getInputHandler().handleKeyEvent(0, character, 0, true, false);
+			mRenderView.getInputHandler().handleKeyEvent(0, character, 0, false, false);
 		}
 	}
 
@@ -127,18 +127,16 @@ public class GodotTextInputWrapper implements TextWatcher, OnEditorActionListene
 			if (characters != null) {
 				for (int i = 0; i < characters.length(); i++) {
 					final int character = characters.codePointAt(i);
-					GodotLib.key(0, character, 0, true, false);
-					GodotLib.key(0, character, 0, false, false);
+					mRenderView.getInputHandler().handleKeyEvent(0, character, 0, true, false);
+					mRenderView.getInputHandler().handleKeyEvent(0, character, 0, false, false);
 				}
 			}
 		}
 
 		if (pActionID == EditorInfo.IME_ACTION_DONE) {
 			// Enter key has been pressed
-			mRenderView.queueOnRenderThread(() -> {
-				GodotLib.key(KeyEvent.KEYCODE_ENTER, 0, 0, true, false);
-				GodotLib.key(KeyEvent.KEYCODE_ENTER, 0, 0, false, false);
-			});
+			mRenderView.getInputHandler().handleKeyEvent(KeyEvent.KEYCODE_ENTER, 0, 0, true, false);
+			mRenderView.getInputHandler().handleKeyEvent(KeyEvent.KEYCODE_ENTER, 0, 0, false, false);
 			mRenderView.getView().requestFocus();
 			return true;
 		}
diff --git a/platform/android/java/lib/src/org/godotengine/godot/utils/BenchmarkUtils.kt b/platform/android/java/lib/src/org/godotengine/godot/utils/BenchmarkUtils.kt
index 69748c0a8d..d39f2309b8 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/utils/BenchmarkUtils.kt
+++ b/platform/android/java/lib/src/org/godotengine/godot/utils/BenchmarkUtils.kt
@@ -81,7 +81,8 @@ fun beginBenchmarkMeasure(scope: String, label: String) {
  *
  * * Note: Only enabled on 'editorDev' build variant.
  */
-fun endBenchmarkMeasure(scope: String, label: String) {
+@JvmOverloads
+fun endBenchmarkMeasure(scope: String, label: String, dumpBenchmark: Boolean = false) {
 	if (BuildConfig.FLAVOR != "editor" || BuildConfig.BUILD_TYPE != "dev") {
 		return
 	}
@@ -93,6 +94,10 @@ fun endBenchmarkMeasure(scope: String, label: String) {
 	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 		Trace.endAsyncSection("[$scope] $label", 0)
 	}
+
+	if (dumpBenchmark) {
+		dumpBenchmark()
+	}
 }
 
 /**
@@ -102,11 +107,11 @@ fun endBenchmarkMeasure(scope: String, label: String) {
  * * Note: Only enabled on 'editorDev' build variant.
  */
 @JvmOverloads
-fun dumpBenchmark(fileAccessHandler: FileAccessHandler?, filepath: String? = benchmarkFile) {
+fun dumpBenchmark(fileAccessHandler: FileAccessHandler? = null, filepath: String? = benchmarkFile) {
 	if (BuildConfig.FLAVOR != "editor" || BuildConfig.BUILD_TYPE != "dev") {
 		return
 	}
-	if (!useBenchmark) {
+	if (!useBenchmark || benchmarkTracker.isEmpty()) {
 		return
 	}