kivyforge 3.0.0.dev0__py3-none-any.whl

kivyforge/platforms/android/bootstrap/templates/sdl3/org/libsdl/app/SDLDummyEdit.java

@@ -0,0 +1,66 @@
+package org.libsdl.app;
+
+import android.content.*;
+import android.text.InputType;
+import android.view.*;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+
+/* This is a fake invisible editor view that receives the input and defines the
+ * pan&scan region
+ */
+public class SDLDummyEdit extends View implements View.OnKeyListener
+{
+    InputConnection ic;
+    int input_type;
+
+    SDLDummyEdit(Context context) {
+        super(context);
+        setFocusableInTouchMode(true);
+        setFocusable(true);
+        setOnKeyListener(this);
+    }
+
+    void setInputType(int input_type) {
+        this.input_type = input_type;
+    }
+
+    @Override
+    public boolean onCheckIsTextEditor() {
+        return true;
+    }
+
+    @Override
+    public boolean onKey(View v, int keyCode, KeyEvent event) {
+        return SDLActivity.handleKeyEvent(v, keyCode, event, ic);
+    }
+
+    //
+    @Override
+    public boolean onKeyPreIme (int keyCode, KeyEvent event) {
+        // As seen on StackOverflow: http://stackoverflow.com/questions/7634346/keyboard-hide-event
+        // FIXME: Discussion at http://bugzilla.libsdl.org/show_bug.cgi?id=1639
+        // FIXME: This is not a 100% effective solution to the problem of detecting if the keyboard is showing or not
+        // FIXME: A more effective solution would be to assume our Layout to be RelativeLayout or LinearLayout
+        // FIXME: And determine the keyboard presence doing this: http://stackoverflow.com/questions/2150078/how-to-check-visibility-of-software-keyboard-in-android
+        // FIXME: An even more effective way would be if Android provided this out of the box, but where would the fun be in that :)
+        if (event.getAction()==KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
+            if (SDLActivity.mTextEdit != null && SDLActivity.mTextEdit.getVisibility() == View.VISIBLE) {
+                SDLActivity.onNativeKeyboardFocusLost();
+            }
+        }
+        return super.onKeyPreIme(keyCode, event);
+    }
+
+    @Override
+    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+        ic = new SDLInputConnection(this, true);
+
+        outAttrs.inputType = input_type;
+        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI |
+                              EditorInfo.IME_FLAG_NO_FULLSCREEN /* API 11 */;
+
+        return ic;
+    }
+}
+

kivyforge/platforms/android/bootstrap/templates/sdl3/org/libsdl/app/SDLInputConnection.java

@@ -0,0 +1,136 @@
+package org.libsdl.app;
+
+import android.content.*;
+import android.os.Build;
+import android.text.Editable;
+import android.view.*;
+import android.view.inputmethod.BaseInputConnection;
+import android.widget.EditText;
+
+class SDLInputConnection extends BaseInputConnection
+{
+    protected EditText mEditText;
+    protected String mCommittedText = "";
+
+    SDLInputConnection(View targetView, boolean fullEditor) {
+        super(targetView, fullEditor);
+        mEditText = new EditText(SDL.getContext());
+    }
+
+    @Override
+    public Editable getEditable() {
+        return mEditText.getEditableText();
+    }
+
+    @Override
+    public boolean sendKeyEvent(KeyEvent event) {
+        /*
+         * This used to handle the keycodes from soft keyboard (and IME-translated input from hardkeyboard)
+         * However, as of Ice Cream Sandwich and later, almost all soft keyboard doesn't generate key presses
+         * and so we need to generate them ourselves in commitText.  To avoid duplicates on the handful of keys
+         * that still do, we empty this out.
+         */
+
+        /*
+         * Return DOES still generate a key event, however.  So rather than using it as the 'click a button' key
+         * as we do with physical keyboards, let's just use it to hide the keyboard.
+         */
+
+        if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
+            if (SDLActivity.onNativeSoftReturnKey()) {
+                return true;
+            }
+        }
+
+        return super.sendKeyEvent(event);
+    }
+
+    @Override
+    public boolean commitText(CharSequence text, int newCursorPosition) {
+        if (!super.commitText(text, newCursorPosition)) {
+            return false;
+        }
+        updateText();
+        return true;
+    }
+
+    @Override
+    public boolean setComposingText(CharSequence text, int newCursorPosition) {
+        if (!super.setComposingText(text, newCursorPosition)) {
+            return false;
+        }
+        updateText();
+        return true;
+    }
+
+    @Override
+    public boolean deleteSurroundingText(int beforeLength, int afterLength) {
+        // Workaround to capture backspace key. Ref: http://stackoverflow.com/questions>/14560344/android-backspace-in-webview-baseinputconnection
+        // and https://bugzilla.libsdl.org/show_bug.cgi?id=2265
+        if (beforeLength > 0 && afterLength == 0) {
+            // backspace(s)
+            while (beforeLength-- > 0) {
+                nativeGenerateScancodeForUnichar('\b');
+            }
+            return true;
+       }
+
+        if (!super.deleteSurroundingText(beforeLength, afterLength)) {
+            return false;
+        }
+        updateText();
+        return true;
+    }
+
+    protected void updateText() {
+        final Editable content = getEditable();
+        if (content == null) {
+            return;
+        }
+
+        String text = content.toString();
+        int compareLength = Math.min(text.length(), mCommittedText.length());
+        int matchLength, offset;
+
+        /* Backspace over characters that are no longer in the string */
+        for (matchLength = 0; matchLength < compareLength; ) {
+            int codePoint = mCommittedText.codePointAt(matchLength);
+            if (codePoint != text.codePointAt(matchLength)) {
+                break;
+            }
+            matchLength += Character.charCount(codePoint);
+        }
+        /* FIXME: This doesn't handle graphemes, like '🌬️' */
+        for (offset = matchLength; offset < mCommittedText.length(); ) {
+            int codePoint = mCommittedText.codePointAt(offset);
+            nativeGenerateScancodeForUnichar('\b');
+            offset += Character.charCount(codePoint);
+        }
+
+        if (matchLength < text.length()) {
+            String pendingText = text.subSequence(matchLength, text.length()).toString();
+            if (!SDLActivity.dispatchingKeyEvent()) {
+                for (offset = 0; offset < pendingText.length(); ) {
+                    int codePoint = pendingText.codePointAt(offset);
+                    if (codePoint == '\n') {
+                        if (SDLActivity.onNativeSoftReturnKey()) {
+                            return;
+                        }
+                    }
+                    /* Higher code points don't generate simulated scancodes */
+                    if (codePoint > 0 && codePoint < 128) {
+                        nativeGenerateScancodeForUnichar((char)codePoint);
+                    }
+                    offset += Character.charCount(codePoint);
+                }
+            }
+            SDLInputConnection.nativeCommitText(pendingText, 0);
+        }
+        mCommittedText = text;
+    }
+
+    public static native void nativeCommitText(String text, int newCursorPosition);
+
+    public static native void nativeGenerateScancodeForUnichar(char c);
+}
+

kivyforge/platforms/android/bootstrap/templates/sdl3/org/libsdl/app/SDLSensorManager.java

@@ -0,0 +1,73 @@
+package org.libsdl.app;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.util.Log;
+
+// This class coordinates synchronized access to sensor manager registration
+//
+// This prevents a java.util.ConcurrentModificationException exception on
+// Android 16, specifically on the Samsung Tab S9 Ultra.
+
+class SDLSensorManager
+{
+    static private SDLSensorManager mManager = new SDLSensorManager();
+
+    static final int RETRY_COUNT = 3;
+
+    public static void registerListener(SensorManager manager, SensorEventListener listener, Sensor sensor, int samplingPeriodUs) {
+        mManager.RegisterListener(manager, listener, sensor, samplingPeriodUs);
+    }
+
+    public static void unregisterListener(SensorManager manager, SensorEventListener listener, Sensor sensor) {
+        mManager.UnregisterListener(manager, listener, sensor);
+    }
+
+    private synchronized void RegisterListener(SensorManager manager, SensorEventListener listener, Sensor sensor, int samplingPeriodUs) {
+        int retries = 0;
+        boolean complete = false;
+        while (!complete) {
+            try {
+                manager.registerListener(listener, sensor, samplingPeriodUs, null);
+                complete = true;
+            } catch (java.util.ConcurrentModificationException e) {
+                ++retries;
+                if (retries <= RETRY_COUNT) {
+                    // Sleep a bit and try again
+                    try {
+                        Thread.sleep(1);
+                    } catch (Exception e2) {
+                    }
+                } else {
+                    Log.v("SDL", "Multiple ConcurrentModificationException caught while registering sensor listener, canceling operation");
+                    complete = true;
+                }
+            }
+        }
+    }
+
+    private synchronized void UnregisterListener(SensorManager manager, SensorEventListener listener, Sensor sensor) {
+        int retries = 0;
+        boolean complete = false;
+        while (!complete) {
+            try {
+                manager.unregisterListener(listener, sensor);
+                complete = true;
+            } catch (java.util.ConcurrentModificationException e) {
+                ++retries;
+                if (retries <= RETRY_COUNT) {
+                    // Sleep a bit and try again
+                    try {
+                        Thread.sleep(1);
+                    } catch (Exception e2) {
+                    }
+                } else {
+                    Log.v("SDL", "Multiple ConcurrentModificationException caught while unregistering sensor listener, canceling operation");
+                    complete = true;
+                }
+            }
+        }
+    }
+}
+