+
+#include "common/gamesdk_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GAMETEXTINPUT_MAJOR_VERSION 4
+#define GAMETEXTINPUT_MINOR_VERSION 0
+#define GAMETEXTINPUT_BUGFIX_VERSION 0
+#define GAMETEXTINPUT_PACKED_VERSION \
+ ANDROID_GAMESDK_PACKED_VERSION(GAMETEXTINPUT_MAJOR_VERSION, \
+ GAMETEXTINPUT_MINOR_VERSION, \
+ GAMETEXTINPUT_BUGFIX_VERSION)
+
+/**
+ * This struct holds a span within a region of text from start (inclusive) to
+ * end (exclusive). An empty span or cursor position is specified with
+ * start==end. An undefined span is specified with start = end = SPAN_UNDEFINED.
+ */
+typedef struct GameTextInputSpan {
+ /** The start of the region (inclusive). */
+ int32_t start;
+ /** The end of the region (exclusive). */
+ int32_t end;
+} GameTextInputSpan;
+
+/**
+ * Values with special meaning in a GameTextInputSpan.
+ */
+enum GameTextInputSpanFlag : int32_t { SPAN_UNDEFINED = -1 };
+
+/**
+ * This struct holds the state of an editable section of text.
+ * The text can have a selection and a composing region defined on it.
+ * A composing region is used by IMEs that allow input using multiple steps to
+ * compose a glyph or word. Use functions GameTextInput_getState and
+ * GameTextInput_setState to read and modify the state that an IME is editing.
+ */
+typedef struct GameTextInputState {
+ /**
+ * Text owned by the state, as a modified UTF-8 string. Null-terminated.
+ * https://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8
+ */
+ const char *text_UTF8;
+ /**
+ * Length in bytes of text_UTF8, *not* including the null at end.
+ */
+ int32_t text_length;
+ /**
+ * A selection defined on the text.
+ */
+ GameTextInputSpan selection;
+ /**
+ * A composing region defined on the text.
+ */
+ GameTextInputSpan composingRegion;
+} GameTextInputState;
+
+/**
+ * A callback called by GameTextInput_getState.
+ * @param context User-defined context.
+ * @param state State, owned by the library, that will be valid for the duration
+ * of the callback.
+ */
+typedef void (*GameTextInputGetStateCallback)(
+ void *context, const struct GameTextInputState *state);
+
+/**
+ * Opaque handle to the GameTextInput API.
+ */
+typedef struct GameTextInput GameTextInput;
+
+/**
+ * Initialize the GameTextInput library.
+ * If called twice without GameTextInput_destroy being called, the same pointer
+ * will be returned and a warning will be issued.
+ * @param env A JNI env valid on the calling thread.
+ * @param max_string_size The maximum length of a string that can be edited. If
+ * zero, the maximum defaults to 65536 bytes. A buffer of this size is allocated
+ * at initialization.
+ * @return A handle to the library.
+ */
+GameTextInput *GameTextInput_init(JNIEnv *env, uint32_t max_string_size);
+
+/**
+ * When using GameTextInput, you need to create a gametextinput.InputConnection
+ * on the Java side and pass it using this function to the library, unless using
+ * GameActivity in which case this will be done for you. See the GameActivity
+ * source code or GameTextInput samples for examples of usage.
+ * @param input A valid GameTextInput library handle.
+ * @param inputConnection A gametextinput.InputConnection object.
+ */
+void GameTextInput_setInputConnection(GameTextInput *input,
+ jobject inputConnection);
+
+/**
+ * Unless using GameActivity, it is required to call this function from your
+ * Java gametextinput.Listener.stateChanged method to convert eventState and
+ * trigger any event callbacks. When using GameActivity, this does not need to
+ * be called as event processing is handled by the Activity.
+ * @param input A valid GameTextInput library handle.
+ * @param eventState A Java gametextinput.State object.
+ */
+void GameTextInput_processEvent(GameTextInput *input, jobject eventState);
+
+/**
+ * Free any resources owned by the GameTextInput library.
+ * Any subsequent calls to the library will fail until GameTextInput_init is
+ * called again.
+ * @param input A valid GameTextInput library handle.
+ */
+void GameTextInput_destroy(GameTextInput *input);
+
+/**
+ * Flags to be passed to GameTextInput_showIme.
+ */
+enum ShowImeFlags : uint32_t {
+ SHOW_IME_UNDEFINED = 0, // Default value.
+ SHOW_IMPLICIT =
+ 1, // Indicates that the user has forced the input method open so it
+ // should not be closed until they explicitly do so.
+ SHOW_FORCED = 2 // Indicates that this is an implicit request to show the
+ // input window, not as the result of a direct request by
+ // the user. The window may not be shown in this case.
+};
+
+/**
+ * Show the IME. Calls InputMethodManager.showSoftInput().
+ * @param input A valid GameTextInput library handle.
+ * @param flags Defined in ShowImeFlags above. For more information see:
+ * https://developer.android.com/reference/android/view/inputmethod/InputMethodManager
+ */
+void GameTextInput_showIme(GameTextInput *input, uint32_t flags);
+
+/**
+ * Flags to be passed to GameTextInput_hideIme.
+ */
+enum HideImeFlags : uint32_t {
+ HIDE_IME_UNDEFINED = 0, // Default value.
+ HIDE_IMPLICIT_ONLY =
+ 1, // Indicates that the soft input window should only be hidden if it
+ // was not explicitly shown by the user.
+ HIDE_NOT_ALWAYS =
+ 2, // Indicates that the soft input window should normally be hidden,
+ // unless it was originally shown with SHOW_FORCED.
+};
+
+/**
+ * Hide the IME. Calls InputMethodManager.hideSoftInputFromWindow().
+ * @param input A valid GameTextInput library handle.
+ * @param flags Defined in HideImeFlags above. For more information see:
+ * https://developer.android.com/reference/android/view/inputmethod/InputMethodManager
+ */
+void GameTextInput_hideIme(GameTextInput *input, uint32_t flags);
+
+/**
+ * Restarts the input method. Calls InputMethodManager.restartInput().
+ * @param input A valid GameTextInput library handle.
+ */
+void GameTextInput_restartInput(GameTextInput *input);
+
+/**
+ * Call a callback with the current GameTextInput state, which may have been
+ * modified by changes in the IME and calls to GameTextInput_setState. We use a
+ * callback rather than returning the state in order to simplify ownership of
+ * text_UTF8 strings. These strings are only valid during the calling of the
+ * callback.
+ * @param input A valid GameTextInput library handle.
+ * @param callback A function that will be called with valid state.
+ * @param context Context used by the callback.
+ */
+void GameTextInput_getState(GameTextInput *input,
+ GameTextInputGetStateCallback callback,
+ void *context);
+
+/**
+ * Set the current GameTextInput state. This state is reflected to any active
+ * IME.
+ * @param input A valid GameTextInput library handle.
+ * @param state The state to set. Ownership is maintained by the caller and must
+ * remain valid for the duration of the call.
+ */
+void GameTextInput_setState(GameTextInput *input,
+ const GameTextInputState *state);
+
+/**
+ * Type of the callback needed by GameTextInput_setEventCallback that will be
+ * called every time the IME state changes.
+ * @param context User-defined context set in GameTextInput_setEventCallback.
+ * @param current_state Current IME state, owned by the library and valid during
+ * the callback.
+ */
+typedef void (*GameTextInputEventCallback)(
+ void *context, const GameTextInputState *current_state);
+
+/**
+ * Optionally set a callback to be called whenever the IME state changes.
+ * Not necessary if you are using GameActivity, which handles these callbacks
+ * for you.
+ * @param input A valid GameTextInput library handle.
+ * @param callback Called by the library when the IME state changes.
+ * @param context Context passed as first argument to the callback.
+ * This function is deprecated. Don't perform any complex processing inside
+ * the callback other than copying the state variable. Using any synchronization
+ * primitives inside this callback may cause a deadlock.
+ */
+void GameTextInput_setEventCallback(GameTextInput *input,
+ GameTextInputEventCallback callback,
+ void *context);
+
+/**
+ * Type of the callback needed by GameTextInput_setImeInsetsCallback that will
+ * be called every time the IME window insets change.
+ * @param context User-defined context set in
+ * GameTextInput_setImeWIndowInsetsCallback.
+ * @param current_insets Current IME insets, owned by the library and valid
+ * during the callback.
+ */
+typedef void (*GameTextInputImeInsetsCallback)(void *context,
+ const ARect *current_insets);
+
+/**
+ * Optionally set a callback to be called whenever the IME insets change.
+ * Not necessary if you are using GameActivity, which handles these callbacks
+ * for you.
+ * @param input A valid GameTextInput library handle.
+ * @param callback Called by the library when the IME insets change.
+ * @param context Context passed as first argument to the callback.
+ */
+void GameTextInput_setImeInsetsCallback(GameTextInput *input,
+ GameTextInputImeInsetsCallback callback,
+ void *context);
+
+/**
+ * Get the current window insets for the IME.
+ * @param input A valid GameTextInput library handle.
+ * @param insets Filled with the current insets by this function.
+ */
+void GameTextInput_getImeInsets(const GameTextInput *input, ARect *insets);
+
+/**
+ * Unless using GameActivity, it is required to call this function from your
+ * Java gametextinput.Listener.onImeInsetsChanged method to
+ * trigger any event callbacks. When using GameActivity, this does not need to
+ * be called as insets processing is handled by the Activity.
+ * @param input A valid GameTextInput library handle.
+ * @param eventState A Java gametextinput.State object.
+ */
+void GameTextInput_processImeInsets(GameTextInput *input, const ARect *insets);
+
+/**
+ * Convert a GameTextInputState struct to a Java gametextinput.State object.
+ * Don't forget to delete the returned Java local ref when you're done.
+ * @param input A valid GameTextInput library handle.
+ * @param state Input state to convert.
+ * @return A Java object of class gametextinput.State. The caller is required to
+ * delete this local reference.
+ */
+jobject GameTextInputState_toJava(const GameTextInput *input,
+ const GameTextInputState *state);
+
+/**
+ * Convert from a Java gametextinput.State object into a C GameTextInputState
+ * struct.
+ * @param input A valid GameTextInput library handle.
+ * @param state A Java gametextinput.State object.
+ * @param callback A function called with the C struct, valid for the duration
+ * of the call.
+ * @param context Context passed to the callback.
+ */
+void GameTextInputState_fromJava(const GameTextInput *input, jobject state,
+ GameTextInputGetStateCallback callback,
+ void *context);
+
+/**
+ * Definitions for inputType argument of GameActivity_setImeEditorInfo()
+ *
+ *
+ * |-------|-------|-------|-------|
+ * 1111 TYPE_MASK_CLASS
+ * 11111111 TYPE_MASK_VARIATION
+ * 111111111111 TYPE_MASK_FLAGS
+ * |-------|-------|-------|-------|
+ * TYPE_NULL
+ * |-------|-------|-------|-------|
+ * 1 TYPE_CLASS_TEXT
+ * 1 TYPE_TEXT_VARIATION_URI
+ * 1 TYPE_TEXT_VARIATION_EMAIL_ADDRESS
+ * 11 TYPE_TEXT_VARIATION_EMAIL_SUBJECT
+ * 1 TYPE_TEXT_VARIATION_SHORT_MESSAGE
+ * 1 1 TYPE_TEXT_VARIATION_LONG_MESSAGE
+ * 11 TYPE_TEXT_VARIATION_PERSON_NAME
+ * 111 TYPE_TEXT_VARIATION_POSTAL_ADDRESS
+ * 1 TYPE_TEXT_VARIATION_PASSWORD
+ * 1 1 TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
+ * 1 1 TYPE_TEXT_VARIATION_WEB_EDIT_TEXT
+ * 1 11 TYPE_TEXT_VARIATION_FILTER
+ * 11 TYPE_TEXT_VARIATION_PHONETIC
+ * 11 1 TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS
+ * 111 TYPE_TEXT_VARIATION_WEB_PASSWORD
+ * 1 TYPE_TEXT_FLAG_CAP_CHARACTERS
+ * 1 TYPE_TEXT_FLAG_CAP_WORDS
+ * 1 TYPE_TEXT_FLAG_CAP_SENTENCES
+ * 1 TYPE_TEXT_FLAG_AUTO_CORRECT
+ * 1 TYPE_TEXT_FLAG_AUTO_COMPLETE
+ * 1 TYPE_TEXT_FLAG_MULTI_LINE
+ * 1 TYPE_TEXT_FLAG_IME_MULTI_LINE
+ * 1 TYPE_TEXT_FLAG_NO_SUGGESTIONS
+ * 1 TYPE_TEXT_FLAG_ENABLE_TEXT_CONVERSION_SUGGESTIONS
+ * |-------|-------|-------|-------|
+ * 1 TYPE_CLASS_NUMBER
+ * 1 TYPE_NUMBER_VARIATION_PASSWORD
+ * 1 TYPE_NUMBER_FLAG_SIGNED
+ * 1 TYPE_NUMBER_FLAG_DECIMAL
+ * |-------|-------|-------|-------|
+ * 11 TYPE_CLASS_PHONE
+ * |-------|-------|-------|-------|
+ * 1 TYPE_CLASS_DATETIME
+ * 1 TYPE_DATETIME_VARIATION_DATE
+ * 1 TYPE_DATETIME_VARIATION_TIME
+ * |-------|-------|-------|-------|
+ */
+
+enum GameTextInputType : uint32_t {
+ /**
+ * Mask of bits that determine the overall class
+ * of text being given. Currently supported classes are:
+ * {@link #TYPE_CLASS_TEXT}, {@link #TYPE_CLASS_NUMBER},
+ * {@link #TYPE_CLASS_PHONE}, {@link #TYPE_CLASS_DATETIME}.
+ * IME authors: If the class is not one you
+ * understand, assume {@link #TYPE_CLASS_TEXT} with NO variation
+ * or flags.
+ */
+ TYPE_MASK_CLASS = 0x0000000f,
+
+ /**
+ * Mask of bits that determine the variation of
+ * the base content class.
+ */
+ TYPE_MASK_VARIATION = 0x00000ff0,
+
+ /**
+ * Mask of bits that provide addition bit flags
+ * of options.
+ */
+ TYPE_MASK_FLAGS = 0x00fff000,
+
+ /**
+ * Special content type for when no explicit type has been specified.
+ * This should be interpreted to mean that the target input connection
+ * is not rich, it can not process and show things like candidate text nor
+ * retrieve the current text, so the input method will need to run in a
+ * limited "generate key events" mode, if it supports it. Note that some
+ * input methods may not support it, for example a voice-based input
+ * method will likely not be able to generate key events even if this
+ * flag is set.
+ */
+ TYPE_NULL = 0x00000000,
+
+ // ----------------------------------------------------------------------
+
+ /**
+ * Class for normal text. This class supports the following flags (only
+ * one of which should be set):
+ * {@link #TYPE_TEXT_FLAG_CAP_CHARACTERS},
+ * {@link #TYPE_TEXT_FLAG_CAP_WORDS}, and.
+ * {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}. It also supports the
+ * following variations:
+ * {@link #TYPE_TEXT_VARIATION_NORMAL}, and
+ * {@link #TYPE_TEXT_VARIATION_URI}. If you do not recognize the
+ * variation, normal should be assumed.
+ */
+ TYPE_CLASS_TEXT = 0x00000001,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: capitalize all characters. Overrides
+ * {@link #TYPE_TEXT_FLAG_CAP_WORDS} and
+ * {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}. This value is explicitly defined
+ * to be the same as {@link TextUtils#CAP_MODE_CHARACTERS}. Of course,
+ * this only affects languages where there are upper-case and lower-case
+ * letters.
+ */
+ TYPE_TEXT_FLAG_CAP_CHARACTERS = 0x00001000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of
+ * every word. Overrides {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}. This
+ * value is explicitly defined
+ * to be the same as {@link TextUtils#CAP_MODE_WORDS}. Of course,
+ * this only affects languages where there are upper-case and lower-case
+ * letters.
+ */
+ TYPE_TEXT_FLAG_CAP_WORDS = 0x00002000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of
+ * each sentence. This value is explicitly defined
+ * to be the same as {@link TextUtils#CAP_MODE_SENTENCES}. For example
+ * in English it means to capitalize after a period and a space (note that
+ * other languages may have different characters for period, or not use
+ * spaces, or use different grammatical rules). Of course, this only affects
+ * languages where there are upper-case and lower-case letters.
+ */
+ TYPE_TEXT_FLAG_CAP_SENTENCES = 0x00004000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: the user is entering free-form
+ * text that should have auto-correction applied to it. Without this flag,
+ * the IME will not try to correct typos. You should always set this flag
+ * unless you really expect users to type non-words in this field, for
+ * example to choose a name for a character in a game.
+ * Contrast this with {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE} and
+ * {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:
+ * {@code TYPE_TEXT_FLAG_AUTO_CORRECT} means that the IME will try to
+ * auto-correct typos as the user is typing, but does not define whether
+ * the IME offers an interface to show suggestions.
+ */
+ TYPE_TEXT_FLAG_AUTO_CORRECT = 0x00008000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: the text editor (which means
+ * the application) is performing auto-completion of the text being entered
+ * based on its own semantics, which it will present to the user as they type.
+ * This generally means that the input method should not be showing
+ * candidates itself, but can expect the editor to supply its own
+ * completions/candidates from
+ * {@link android.view.inputmethod.InputMethodSession#displayCompletions
+ * InputMethodSession.displayCompletions()} as a result of the editor calling
+ * {@link android.view.inputmethod.InputMethodManager#displayCompletions
+ * InputMethodManager.displayCompletions()}.
+ * Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and
+ * {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:
+ * {@code TYPE_TEXT_FLAG_AUTO_COMPLETE} means the editor should show an
+ * interface for displaying suggestions, but instead of supplying its own
+ * it will rely on the Editor to pass completions/corrections.
+ */
+ TYPE_TEXT_FLAG_AUTO_COMPLETE = 0x00010000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: multiple lines of text can be
+ * entered into the field. If this flag is not set, the text field
+ * will be constrained to a single line. The IME may also choose not to
+ * display an enter key when this flag is not set, as there should be no
+ * need to create new lines.
+ */
+ TYPE_TEXT_FLAG_MULTI_LINE = 0x00020000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: the regular text view associated
+ * with this should not be multi-line, but when a fullscreen input method
+ * is providing text it should use multiple lines if it can.
+ */
+ TYPE_TEXT_FLAG_IME_MULTI_LINE = 0x00040000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: the input method does not need to
+ * display any dictionary-based candidates. This is useful for text views that
+ * do not contain words from the language and do not benefit from any
+ * dictionary-based completions or corrections. It overrides the
+ * {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} value when set.
+ * Please avoid using this unless you are certain this is what you want.
+ * Many input methods need suggestions to work well, for example the ones
+ * based on gesture typing. Consider clearing
+ * {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} instead if you just do not
+ * want the IME to correct typos.
+ * Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and
+ * {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE}:
+ * {@code TYPE_TEXT_FLAG_NO_SUGGESTIONS} means the IME does not need to
+ * show an interface to display suggestions. Most IMEs will also take this to
+ * mean they do not need to try to auto-correct what the user is typing.
+ */
+ TYPE_TEXT_FLAG_NO_SUGGESTIONS = 0x00080000,
+
+ /**
+ * Flag for {@link #TYPE_CLASS_TEXT}: Let the IME know the text conversion
+ * suggestions are required by the application. Text conversion suggestion is
+ * for the transliteration languages which has pronunciation characters and
+ * target characters. When the user is typing the pronunciation charactes, the
+ * IME could provide the possible target characters to the user. When this
+ * flag is set, the IME should insert the text conversion suggestions through
+ * {@link Builder#setTextConversionSuggestions(List)} and
+ * the {@link TextAttribute} with initialized with the text conversion
+ * suggestions is provided by the IME to the application. To receive the
+ * additional information, the application needs to implement {@link
+ * InputConnection#setComposingText(CharSequence, int, TextAttribute)},
+ * {@link InputConnection#setComposingRegion(int, int, TextAttribute)}, and
+ * {@link InputConnection#commitText(CharSequence, int, TextAttribute)}.
+ */
+ TYPE_TEXT_FLAG_ENABLE_TEXT_CONVERSION_SUGGESTIONS = 0x00100000,
+
+ // ----------------------------------------------------------------------
+
+ /**
+ * Default variation of {@link #TYPE_CLASS_TEXT}: plain old normal text.
+ */
+ TYPE_TEXT_VARIATION_NORMAL = 0x00000000,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering a URI.
+ */
+ TYPE_TEXT_VARIATION_URI = 0x00000010,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering an e-mail address.
+ */
+ TYPE_TEXT_VARIATION_EMAIL_ADDRESS = 0x00000020,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering the subject line of
+ * an e-mail.
+ */
+ TYPE_TEXT_VARIATION_EMAIL_SUBJECT = 0x00000030,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering a short, possibly informal
+ * message such as an instant message or a text message.
+ */
+ TYPE_TEXT_VARIATION_SHORT_MESSAGE = 0x00000040,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering the content of a long,
+ * possibly formal message such as the body of an e-mail.
+ */
+ TYPE_TEXT_VARIATION_LONG_MESSAGE = 0x00000050,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering the name of a person.
+ */
+ TYPE_TEXT_VARIATION_PERSON_NAME = 0x00000060,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering a postal mailing address.
+ */
+ TYPE_TEXT_VARIATION_POSTAL_ADDRESS = 0x00000070,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering a password.
+ */
+ TYPE_TEXT_VARIATION_PASSWORD = 0x00000080,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering a password, which should
+ * be visible to the user.
+ */
+ TYPE_TEXT_VARIATION_VISIBLE_PASSWORD = 0x00000090,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering text inside of a web form.
+ */
+ TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x000000a0,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering text to filter contents
+ * of a list etc.
+ */
+ TYPE_TEXT_VARIATION_FILTER = 0x000000b0,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering text for phonetic
+ * pronunciation, such as a phonetic name field in contacts. This is mostly
+ * useful for languages where one spelling may have several phonetic
+ * readings, like Japanese.
+ */
+ TYPE_TEXT_VARIATION_PHONETIC = 0x000000c0,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering e-mail address inside
+ * of a web form. This was added in
+ * {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An IME must target
+ * this API version or later to see this input type; if it doesn't, a request
+ * for this type will be seen as {@link #TYPE_TEXT_VARIATION_EMAIL_ADDRESS}
+ * when passed through {@link
+ * android.view.inputmethod.EditorInfo#makeCompatible(int)
+ * EditorInfo.makeCompatible(int)}.
+ */
+ TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS = 0x000000d0,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_TEXT}: entering password inside
+ * of a web form. This was added in
+ * {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An IME must target
+ * this API version or later to see this input type; if it doesn't, a request
+ * for this type will be seen as {@link #TYPE_TEXT_VARIATION_PASSWORD}
+ * when passed through {@link
+ * android.view.inputmethod.EditorInfo#makeCompatible(int)
+ * EditorInfo.makeCompatible(int)}.
+ */
+ TYPE_TEXT_VARIATION_WEB_PASSWORD = 0x000000e0,
+
+ // ----------------------------------------------------------------------
+
+ /**
+ * Class for numeric text. This class supports the following flags:
+ * {@link #TYPE_NUMBER_FLAG_SIGNED} and
+ * {@link #TYPE_NUMBER_FLAG_DECIMAL}. It also supports the following
+ * variations: {@link #TYPE_NUMBER_VARIATION_NORMAL} and
+ * {@link #TYPE_NUMBER_VARIATION_PASSWORD}.
+ *
IME authors: If you do not recognize
+ * the variation, normal should be assumed.
+ */
+ TYPE_CLASS_NUMBER = 0x00000002,
+
+ /**
+ * Flag of {@link #TYPE_CLASS_NUMBER}: the number is signed, allowing
+ * a positive or negative sign at the start.
+ */
+ TYPE_NUMBER_FLAG_SIGNED = 0x00001000,
+
+ /**
+ * Flag of {@link #TYPE_CLASS_NUMBER}: the number is decimal, allowing
+ * a decimal point to provide fractional values.
+ */
+ TYPE_NUMBER_FLAG_DECIMAL = 0x00002000,
+
+ // ----------------------------------------------------------------------
+
+ /**
+ * Default variation of {@link #TYPE_CLASS_NUMBER}: plain normal
+ * numeric text. This was added in
+ * {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An IME must target
+ * this API version or later to see this input type; if it doesn't, a request
+ * for this type will be dropped when passed through
+ * {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
+ * EditorInfo.makeCompatible(int)}.
+ */
+ TYPE_NUMBER_VARIATION_NORMAL = 0x00000000,
+
+ /**
+ * Variation of {@link #TYPE_CLASS_NUMBER}: entering a numeric password.
+ * This was added in {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An
+ * IME must target this API version or later to see this input type; if it
+ * doesn't, a request for this type will be dropped when passed
+ * through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
+ * EditorInfo.makeCompatible(int)}.
+ */
+ TYPE_NUMBER_VARIATION_PASSWORD = 0x00000010,
+
+ // ----------------------------------------------------------------------
+ /**
+ * Class for a phone number. This class currently supports no variations
+ * or flags.
+ */
+ TYPE_CLASS_PHONE = 0x00000003,
+
+ // ----------------------------------------------------------------------
+
+ /**
+ * Class for dates and times. It supports the
+ * following variations:
+ * {@link #TYPE_DATETIME_VARIATION_NORMAL}
+ * {@link #TYPE_DATETIME_VARIATION_DATE}, and
+ * {@link #TYPE_DATETIME_VARIATION_TIME}.
+ */
+ TYPE_CLASS_DATETIME = 0x00000004,
+
+ /**
+ * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
+ * both a date and time.
+ */
+ TYPE_DATETIME_VARIATION_NORMAL = 0x00000000,
+
+ /**
+ * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
+ * only a date.
+ */
+ TYPE_DATETIME_VARIATION_DATE = 0x00000010,
+
+ /**
+ * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
+ * only a time.
+ */
+ TYPE_DATETIME_VARIATION_TIME = 0x00000020,
+};
+
+/**
+ * actionId and imeOptions argument of GameActivity_setImeEditorInfo().
+ *
+ *
+ * |-------|-------|-------|-------|
+ * 1111 IME_MASK_ACTION
+ * |-------|-------|-------|-------|
+ * IME_ACTION_UNSPECIFIED
+ * 1 IME_ACTION_NONE
+ * 1 IME_ACTION_GO
+ * 11 IME_ACTION_SEARCH
+ * 1 IME_ACTION_SEND
+ * 1 1 IME_ACTION_NEXT
+ * 11 IME_ACTION_DONE
+ * 111 IME_ACTION_PREVIOUS
+ * 1 IME_FLAG_NO_PERSONALIZED_LEARNING
+ * 1 IME_FLAG_NO_FULLSCREEN
+ * 1 IME_FLAG_NAVIGATE_PREVIOUS
+ * 1 IME_FLAG_NAVIGATE_NEXT
+ * 1 IME_FLAG_NO_EXTRACT_UI
+ * 1 IME_FLAG_NO_ACCESSORY_ACTION
+ * 1 IME_FLAG_NO_ENTER_ACTION
+ * 1 IME_FLAG_FORCE_ASCII
+ * |-------|-------|-------|-------|
+ */
+
+enum GameTextInputActionType : uint32_t {
+ /**
+ * Set of bits in {@link #imeOptions} that provide alternative actions
+ * associated with the "enter" key. This both helps the IME provide
+ * better feedback about what the enter key will do, and also allows it
+ * to provide alternative mechanisms for providing that command.
+ */
+ IME_MASK_ACTION = 0x000000ff,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: no specific action has been
+ * associated with this editor, let the editor come up with its own if
+ * it can.
+ */
+ IME_ACTION_UNSPECIFIED = 0x00000000,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: there is no available action.
+ */
+ IME_ACTION_NONE = 0x00000001,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: the action key performs a "go"
+ * operation to take the user to the target of the text they typed.
+ * Typically used, for example, when entering a URL.
+ */
+ IME_ACTION_GO = 0x00000002,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: the action key performs a "search"
+ * operation, taking the user to the results of searching for the text
+ * they have typed (in whatever context is appropriate).
+ */
+ IME_ACTION_SEARCH = 0x00000003,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: the action key performs a "send"
+ * operation, delivering the text to its target. This is typically used
+ * when composing a message in IM or SMS where sending is immediate.
+ */
+ IME_ACTION_SEND = 0x00000004,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: the action key performs a "next"
+ * operation, taking the user to the next field that will accept text.
+ */
+ IME_ACTION_NEXT = 0x00000005,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: the action key performs a "done"
+ * operation, typically meaning there is nothing more to input and the
+ * IME will be closed.
+ */
+ IME_ACTION_DONE = 0x00000006,
+
+ /**
+ * Bits of {@link #IME_MASK_ACTION}: like {@link #IME_ACTION_NEXT}, but
+ * for moving to the previous field. This will normally not be used to
+ * specify an action (since it precludes {@link #IME_ACTION_NEXT}), but
+ * can be returned to the app if it sets {@link #IME_FLAG_NAVIGATE_PREVIOUS}.
+ */
+ IME_ACTION_PREVIOUS = 0x00000007,
+};
+
+enum GameTextInputImeOptions : uint32_t {
+ /**
+ * Flag of {@link #imeOptions}: used to request that the IME should not update
+ * any personalized data such as typing history and personalized language
+ * model based on what the user typed on this text editing object. Typical
+ * use cases are: - When the application is in a special mode, where
+ * user's activities are expected to be not recorded in the application's
+ * history. Some web browsers and chat applications may have this kind of
+ * modes.
- When storing typing history does not make much sense.
+ * Specifying this flag in typing games may help to avoid typing history from
+ * being filled up with words that the user is less likely to type in their
+ * daily life. Another example is that when the application already knows
+ * that the expected input is not a valid word (e.g. a promotion code that is
+ * not a valid word in any natural language).
+ *
+ *
+ * Applications need to be aware that the flag is not a guarantee, and some
+ * IMEs may not respect it.
+ */
+ IME_FLAG_NO_PERSONALIZED_LEARNING = 0x1000000,
+
+ /**
+ * Flag of {@link #imeOptions}: used to request that the IME never go
+ * into fullscreen mode.
+ * By default, IMEs may go into full screen mode when they think
+ * it's appropriate, for example on small screens in landscape
+ * orientation where displaying a software keyboard may occlude
+ * such a large portion of the screen that the remaining part is
+ * too small to meaningfully display the application UI.
+ * If this flag is set, compliant IMEs will never go into full screen mode,
+ * and always leave some space to display the application UI.
+ * Applications need to be aware that the flag is not a guarantee, and
+ * some IMEs may ignore it.
+ */
+ IME_FLAG_NO_FULLSCREEN = 0x2000000,
+
+ /**
+ * Flag of {@link #imeOptions}: like {@link #IME_FLAG_NAVIGATE_NEXT}, but
+ * specifies there is something interesting that a backward navigation
+ * can focus on. If the user selects the IME's facility to backward
+ * navigate, this will show up in the application as an {@link
+ * #IME_ACTION_PREVIOUS} at {@link InputConnection#performEditorAction(int)
+ * InputConnection.performEditorAction(int)}.
+ */
+ IME_FLAG_NAVIGATE_PREVIOUS = 0x4000000,
+
+ /**
+ * Flag of {@link #imeOptions}: used to specify that there is something
+ * interesting that a forward navigation can focus on. This is like using
+ * {@link #IME_ACTION_NEXT}, except allows the IME to be multiline (with
+ * an enter key) as well as provide forward navigation. Note that some
+ * IMEs may not be able to do this, especially when running on a small
+ * screen where there is little space. In that case it does not need to
+ * present a UI for this option. Like {@link #IME_ACTION_NEXT}, if the
+ * user selects the IME's facility to forward navigate, this will show up
+ * in the application at {@link InputConnection#performEditorAction(int)
+ * InputConnection.performEditorAction(int)}.
+ */
+ IME_FLAG_NAVIGATE_NEXT = 0x8000000,
+
+ /**
+ * Flag of {@link #imeOptions}: used to specify that the IME does not need
+ * to show its extracted text UI. For input methods that may be fullscreen,
+ * often when in landscape mode, this allows them to be smaller and let part
+ * of the application be shown behind, through transparent UI parts in the
+ * fullscreen IME. The part of the UI visible to the user may not be
+ * responsive to touch because the IME will receive touch events, which may
+ * confuse the user; use {@link #IME_FLAG_NO_FULLSCREEN} instead for a better
+ * experience. Using this flag is discouraged and it may become deprecated in
+ * the future. Its meaning is unclear in some situations and it may not work
+ * appropriately on older versions of the platform.
+ */
+ IME_FLAG_NO_EXTRACT_UI = 0x10000000,
+
+ /**
+ * Flag of {@link #imeOptions}: used in conjunction with one of the actions
+ * masked by {@link #IME_MASK_ACTION}, this indicates that the action
+ * should not be available as an accessory button on the right of the
+ * extracted text when the input method is full-screen. Note that by setting
+ * this flag, there can be cases where the action is simply never available to
+ * the user. Setting this generally means that you think that in fullscreen
+ * mode, where there is little space to show the text, it's not worth taking
+ * some screen real estate to display the action and it should be used instead
+ * to show more text.
+ */
+ IME_FLAG_NO_ACCESSORY_ACTION = 0x20000000,
+
+ /**
+ * Flag of {@link #imeOptions}: used in conjunction with one of the actions
+ * masked by {@link #IME_MASK_ACTION}. If this flag is not set, IMEs will
+ * normally replace the "enter" key with the action supplied. This flag
+ * indicates that the action should not be available in-line as a replacement
+ * for the "enter" key. Typically this is because the action has such a
+ * significant impact or is not recoverable enough that accidentally hitting
+ * it should be avoided, such as sending a message. Note that
+ * {@link android.widget.TextView} will automatically set this flag for you
+ * on multi-line text views.
+ */
+ IME_FLAG_NO_ENTER_ACTION = 0x40000000,
+
+ /**
+ * Flag of {@link #imeOptions}: used to request an IME that is capable of
+ * inputting ASCII characters. The intention of this flag is to ensure that
+ * the user can type Roman alphabet characters in a {@link
+ * android.widget.TextView}. It is typically used for an account ID or
+ * password input. A lot of the time, IMEs are already able to input ASCII
+ * even without being told so (such IMEs already respect this flag in a
+ * sense), but there are cases when this is not the default. For instance,
+ * users of languages using a different script like Arabic, Greek, Hebrew or
+ * Russian typically have a keyboard that can't input ASCII characters by
+ * default. Applications need to be aware that the flag is not a guarantee,
+ * and some IMEs may not respect it. However, it is strongly recommended for
+ * IME authors to respect this flag especially when their IME could end up
+ * with a state where only languages using non-ASCII are enabled.
+ */
+ IME_FLAG_FORCE_ASCII = 0x80000000,
+
+ /**
+ * Flag of {@link #internalImeOptions}: flag is set when app window containing
+ * this
+ * {@link EditorInfo} is using {@link Configuration#ORIENTATION_PORTRAIT}
+ * mode.
+ * @hide
+ */
+ IME_INTERNAL_FLAG_APP_WINDOW_PORTRAIT = 0x00000001,
+
+ /**
+ * Generic unspecified type for {@link #imeOptions}.
+ */
+ IME_NULL = 0x00000000,
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
diff --git a/android-activity/android-games-sdk/game-text-input/prefab-src/modules/game-text-input/module.json b/android-activity/android-games-sdk/game-text-input/prefab-src/modules/game-text-input/module.json
new file mode 100644
index 0000000..1a64fcc
--- /dev/null
+++ b/android-activity/android-games-sdk/game-text-input/prefab-src/modules/game-text-input/module.json
@@ -0,0 +1,8 @@
+{
+ "export_libraries": [],
+ "library_name": null,
+ "android": {
+ "export_libraries": null,
+ "library_name": null
+ }
+}
diff --git a/android-activity/android-games-sdk/game-text-input/prefab-src/modules/game-text-input/src/game-text-input/gametextinput.cpp b/android-activity/android-games-sdk/game-text-input/prefab-src/modules/game-text-input/src/game-text-input/gametextinput.cpp
new file mode 100644
index 0000000..70a5938
--- /dev/null
+++ b/android-activity/android-games-sdk/game-text-input/prefab-src/modules/game-text-input/src/game-text-input/gametextinput.cpp
@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "game-text-input/gametextinput.h"
+
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+
+#define LOG_TAG "GameTextInput"
+
+static constexpr int32_t DEFAULT_MAX_STRING_SIZE = 1 << 16;
+
+// Cache of field ids in the Java GameTextInputState class
+struct StateClassInfo {
+ jfieldID text;
+ jfieldID selectionStart;
+ jfieldID selectionEnd;
+ jfieldID composingRegionStart;
+ jfieldID composingRegionEnd;
+};
+
+// Main GameTextInput object.
+struct GameTextInput {
+ public:
+ GameTextInput(JNIEnv *env, uint32_t max_string_size);
+ ~GameTextInput();
+ void setState(const GameTextInputState &state);
+ GameTextInputState getState() const {
+ std::lock_guard lock(currentStateMutex_);
+ return currentState_;
+ }
+ void setInputConnection(jobject inputConnection);
+ void processEvent(jobject textInputEvent);
+ void showIme(uint32_t flags);
+ void hideIme(uint32_t flags);
+ void restartInput();
+ void setEventCallback(GameTextInputEventCallback callback, void *context);
+ jobject stateToJava(const GameTextInputState &state) const;
+ void stateFromJava(jobject textInputEvent,
+ GameTextInputGetStateCallback callback,
+ void *context) const;
+ void setImeInsetsCallback(GameTextInputImeInsetsCallback callback,
+ void *context);
+ void processImeInsets(const ARect *insets);
+ const ARect &getImeInsets() const { return currentInsets_; }
+
+ private:
+ // Copy string and set other fields
+ void setStateInner(const GameTextInputState &state);
+ static void processCallback(void *context, const GameTextInputState *state);
+ JNIEnv *env_ = nullptr;
+ // Cached at initialization from
+ // com/google/androidgamesdk/gametextinput/State.
+ jclass stateJavaClass_ = nullptr;
+ // The latest text input update.
+ GameTextInputState currentState_ = {};
+ // A mutex to protect currentState_.
+ mutable std::mutex currentStateMutex_;
+ // An instance of gametextinput.InputConnection.
+ jclass inputConnectionClass_ = nullptr;
+ jobject inputConnection_ = nullptr;
+ jmethodID inputConnectionSetStateMethod_;
+ jmethodID setSoftKeyboardActiveMethod_;
+ jmethodID restartInputMethod_;
+ void (*eventCallback_)(void *context,
+ const struct GameTextInputState *state) = nullptr;
+ void *eventCallbackContext_ = nullptr;
+ void (*insetsCallback_)(void *context, const struct ARect *insets) = nullptr;
+ ARect currentInsets_ = {};
+ void *insetsCallbackContext_ = nullptr;
+ StateClassInfo stateClassInfo_ = {};
+ // Constant-sized buffer used to store state text.
+ std::vector stateStringBuffer_;
+};
+
+std::unique_ptr s_gameTextInput;
+
+extern "C" {
+
+///////////////////////////////////////////////////////////
+/// GameTextInputState C Functions
+///////////////////////////////////////////////////////////
+
+// Convert to a Java structure.
+jobject currentState_toJava(const GameTextInput *gameTextInput,
+ const GameTextInputState *state) {
+ if (state == nullptr) return NULL;
+ return gameTextInput->stateToJava(*state);
+}
+
+// Convert from Java structure.
+void currentState_fromJava(const GameTextInput *gameTextInput,
+ jobject textInputEvent,
+ GameTextInputGetStateCallback callback,
+ void *context) {
+ gameTextInput->stateFromJava(textInputEvent, callback, context);
+}
+
+///////////////////////////////////////////////////////////
+/// GameTextInput C Functions
+///////////////////////////////////////////////////////////
+
+struct GameTextInput *GameTextInput_init(JNIEnv *env,
+ uint32_t max_string_size) {
+ if (s_gameTextInput.get() != nullptr) {
+ __android_log_print(ANDROID_LOG_WARN, LOG_TAG,
+ "Warning: called GameTextInput_init twice without "
+ "calling GameTextInput_destroy");
+ return s_gameTextInput.get();
+ }
+ // Don't use make_unique, for C++11 compatibility
+ s_gameTextInput =
+ std::unique_ptr(new GameTextInput(env, max_string_size));
+ return s_gameTextInput.get();
+}
+
+void GameTextInput_destroy(GameTextInput *input) {
+ if (input == nullptr || s_gameTextInput.get() == nullptr) return;
+ s_gameTextInput.reset();
+}
+
+void GameTextInput_setState(GameTextInput *input,
+ const GameTextInputState *state) {
+ if (state == nullptr) return;
+ input->setState(*state);
+}
+
+void GameTextInput_getState(GameTextInput *input,
+ GameTextInputGetStateCallback callback,
+ void *context) {
+ GameTextInputState state = input->getState();
+ callback(context, &state);
+}
+
+void GameTextInput_setInputConnection(GameTextInput *input,
+ jobject inputConnection) {
+ input->setInputConnection(inputConnection);
+}
+
+void GameTextInput_processEvent(GameTextInput *input, jobject textInputEvent) {
+ input->processEvent(textInputEvent);
+}
+
+void GameTextInput_processImeInsets(GameTextInput *input, const ARect *insets) {
+ input->processImeInsets(insets);
+}
+
+void GameTextInput_showIme(struct GameTextInput *input, uint32_t flags) {
+ input->showIme(flags);
+}
+
+void GameTextInput_hideIme(struct GameTextInput *input, uint32_t flags) {
+ input->hideIme(flags);
+}
+
+void GameTextInput_restartInput(struct GameTextInput *input) {
+ input->restartInput();
+}
+
+void GameTextInput_setEventCallback(struct GameTextInput *input,
+ GameTextInputEventCallback callback,
+ void *context) {
+ input->setEventCallback(callback, context);
+}
+
+void GameTextInput_setImeInsetsCallback(struct GameTextInput *input,
+ GameTextInputImeInsetsCallback callback,
+ void *context) {
+ input->setImeInsetsCallback(callback, context);
+}
+
+void GameTextInput_getImeInsets(const GameTextInput *input, ARect *insets) {
+ *insets = input->getImeInsets();
+}
+
+} // extern "C"
+
+///////////////////////////////////////////////////////////
+/// GameTextInput C++ class Implementation
+///////////////////////////////////////////////////////////
+
+GameTextInput::GameTextInput(JNIEnv *env, uint32_t max_string_size)
+ : env_(env),
+ stateStringBuffer_(max_string_size == 0 ? DEFAULT_MAX_STRING_SIZE
+ : max_string_size) {
+ stateJavaClass_ = (jclass)env_->NewGlobalRef(
+ env_->FindClass("com/google/androidgamesdk/gametextinput/State"));
+ inputConnectionClass_ = (jclass)env_->NewGlobalRef(env_->FindClass(
+ "com/google/androidgamesdk/gametextinput/InputConnection"));
+ inputConnectionSetStateMethod_ =
+ env_->GetMethodID(inputConnectionClass_, "setState",
+ "(Lcom/google/androidgamesdk/gametextinput/State;)V");
+ setSoftKeyboardActiveMethod_ = env_->GetMethodID(
+ inputConnectionClass_, "setSoftKeyboardActive", "(ZI)V");
+ restartInputMethod_ =
+ env_->GetMethodID(inputConnectionClass_, "restartInput", "()V");
+
+ stateClassInfo_.text =
+ env_->GetFieldID(stateJavaClass_, "text", "Ljava/lang/String;");
+ stateClassInfo_.selectionStart =
+ env_->GetFieldID(stateJavaClass_, "selectionStart", "I");
+ stateClassInfo_.selectionEnd =
+ env_->GetFieldID(stateJavaClass_, "selectionEnd", "I");
+ stateClassInfo_.composingRegionStart =
+ env_->GetFieldID(stateJavaClass_, "composingRegionStart", "I");
+ stateClassInfo_.composingRegionEnd =
+ env_->GetFieldID(stateJavaClass_, "composingRegionEnd", "I");
+}
+
+GameTextInput::~GameTextInput() {
+ if (stateJavaClass_ != NULL) {
+ env_->DeleteGlobalRef(stateJavaClass_);
+ stateJavaClass_ = NULL;
+ }
+ if (inputConnectionClass_ != NULL) {
+ env_->DeleteGlobalRef(inputConnectionClass_);
+ inputConnectionClass_ = NULL;
+ }
+ if (inputConnection_ != NULL) {
+ env_->DeleteGlobalRef(inputConnection_);
+ inputConnection_ = NULL;
+ }
+}
+
+void GameTextInput::setState(const GameTextInputState &state) {
+ if (inputConnection_ == nullptr) return;
+ jobject jstate = stateToJava(state);
+ env_->CallVoidMethod(inputConnection_, inputConnectionSetStateMethod_,
+ jstate);
+ env_->DeleteLocalRef(jstate);
+ setStateInner(state);
+}
+
+void GameTextInput::setStateInner(const GameTextInputState &state) {
+ std::lock_guard lock(currentStateMutex_);
+
+ // Check if we're setting using our own string (other parts may be
+ // different)
+ if (state.text_UTF8 == currentState_.text_UTF8) {
+ currentState_ = state;
+ return;
+ }
+ // Otherwise, copy across the string.
+ auto bytes_needed =
+ std::min(static_cast(state.text_length + 1),
+ static_cast(stateStringBuffer_.size()));
+ currentState_.text_UTF8 = stateStringBuffer_.data();
+ std::copy(state.text_UTF8, state.text_UTF8 + bytes_needed - 1,
+ stateStringBuffer_.data());
+ currentState_.text_length = state.text_length;
+ currentState_.selection = state.selection;
+ currentState_.composingRegion = state.composingRegion;
+ stateStringBuffer_[bytes_needed - 1] = 0;
+}
+
+void GameTextInput::setInputConnection(jobject inputConnection) {
+ if (inputConnection_ != NULL) {
+ env_->DeleteGlobalRef(inputConnection_);
+ }
+ inputConnection_ = env_->NewGlobalRef(inputConnection);
+}
+
+/*static*/ void GameTextInput::processCallback(
+ void *context, const GameTextInputState *state) {
+ auto thiz = static_cast(context);
+ if (state != nullptr) thiz->setStateInner(*state);
+}
+
+void GameTextInput::processEvent(jobject textInputEvent) {
+ stateFromJava(textInputEvent, processCallback, this);
+ if (eventCallback_) {
+ std::lock_guard lock(currentStateMutex_);
+ eventCallback_(eventCallbackContext_, ¤tState_);
+ }
+}
+
+void GameTextInput::showIme(uint32_t flags) {
+ if (inputConnection_ == nullptr) return;
+ env_->CallVoidMethod(inputConnection_, setSoftKeyboardActiveMethod_, true,
+ static_cast(flags));
+}
+
+void GameTextInput::setEventCallback(GameTextInputEventCallback callback,
+ void *context) {
+ eventCallback_ = callback;
+ eventCallbackContext_ = context;
+}
+
+void GameTextInput::setImeInsetsCallback(
+ GameTextInputImeInsetsCallback callback, void *context) {
+ insetsCallback_ = callback;
+ insetsCallbackContext_ = context;
+}
+
+void GameTextInput::processImeInsets(const ARect *insets) {
+ currentInsets_ = *insets;
+ if (insetsCallback_) {
+ insetsCallback_(insetsCallbackContext_, ¤tInsets_);
+ }
+}
+
+void GameTextInput::hideIme(uint32_t flags) {
+ if (inputConnection_ == nullptr) return;
+ env_->CallVoidMethod(inputConnection_, setSoftKeyboardActiveMethod_, false,
+ static_cast(flags));
+}
+
+void GameTextInput::restartInput() {
+ if (inputConnection_ == nullptr) return;
+ env_->CallVoidMethod(inputConnection_, restartInputMethod_);
+}
+
+jobject GameTextInput::stateToJava(const GameTextInputState &state) const {
+ static jmethodID constructor = nullptr;
+ if (constructor == nullptr) {
+ constructor = env_->GetMethodID(stateJavaClass_, "",
+ "(Ljava/lang/String;IIII)V");
+ if (constructor == nullptr) {
+ __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
+ "Can't find gametextinput.State constructor");
+ return nullptr;
+ }
+ }
+ const char *text = state.text_UTF8;
+ if (text == nullptr) {
+ static char empty_string[] = "";
+ text = empty_string;
+ }
+ // Note that this expects 'modified' UTF-8 which is not the same as UTF-8
+ // https://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8
+ jstring jtext = env_->NewStringUTF(text);
+ jobject jobj =
+ env_->NewObject(stateJavaClass_, constructor, jtext,
+ state.selection.start, state.selection.end,
+ state.composingRegion.start, state.composingRegion.end);
+ env_->DeleteLocalRef(jtext);
+ return jobj;
+}
+
+void GameTextInput::stateFromJava(jobject textInputEvent,
+ GameTextInputGetStateCallback callback,
+ void *context) const {
+ jstring text =
+ (jstring)env_->GetObjectField(textInputEvent, stateClassInfo_.text);
+ // Note this is 'modified' UTF-8, not true UTF-8. It has no NULLs in it,
+ // except at the end. It's actually not specified whether the value returned
+ // by GetStringUTFChars includes a null at the end, but it *seems to* on
+ // Android.
+ const char *text_chars = env_->GetStringUTFChars(text, NULL);
+ int text_len = env_->GetStringUTFLength(
+ text); // Length in bytes, *not* including the null.
+ int selectionStart =
+ env_->GetIntField(textInputEvent, stateClassInfo_.selectionStart);
+ int selectionEnd =
+ env_->GetIntField(textInputEvent, stateClassInfo_.selectionEnd);
+ int composingRegionStart =
+ env_->GetIntField(textInputEvent, stateClassInfo_.composingRegionStart);
+ int composingRegionEnd =
+ env_->GetIntField(textInputEvent, stateClassInfo_.composingRegionEnd);
+ GameTextInputState state{text_chars,
+ text_len,
+ {selectionStart, selectionEnd},
+ {composingRegionStart, composingRegionEnd}};
+ callback(context, &state);
+ env_->ReleaseStringUTFChars(text, text_chars);
+ env_->DeleteLocalRef(text);
+}
diff --git a/android-activity/android-games-sdk/game-text-input/prefab-src/prefab.json b/android-activity/android-games-sdk/game-text-input/prefab-src/prefab.json
new file mode 100644
index 0000000..5b3ea1e
--- /dev/null
+++ b/android-activity/android-games-sdk/game-text-input/prefab-src/prefab.json
@@ -0,0 +1,9 @@
+{
+ "name": "game-text-input",
+ "schema_version": 1,
+ "dependencies": [],
+ "version": "0.0.1",
+ "cpp_files": [
+ "src/game-text-input/gametextinput.cpp"
+ ]
+}
diff --git a/android-activity/android-games-sdk/import-games-sdk.sh b/android-activity/android-games-sdk/import-games-sdk.sh
new file mode 100755
index 0000000..83bdf9f
--- /dev/null
+++ b/android-activity/android-games-sdk/import-games-sdk.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+set -xe
+
+# Copies the native, prefab-src for GameActivity + GameTextInput from the
+# upstream, android-games-sdk, including our android-activity integration
+# changes.
+#
+# This code is maintained out-of-tree, based on a fork of Google's AGDK repo, so
+# it's more practical to try and upstream changes we make, or to rebase on new
+# versions.
+
+if [ $# -ne 1 ]; then
+ echo "Usage: $0 "
+ exit 1
+fi
+
+SOURCE_DIR="$1"
+TOP_DIR=$(git rev-parse --show-toplevel)
+DEST_DIR="$TOP_DIR/android-activity/android-games-sdk"
+
+if [ ! -d "$SOURCE_DIR" ]; then
+ echo "Error: Source directory '$SOURCE_DIR' does not exist."
+ exit 1
+fi
+
+if [ ! -d "$DEST_DIR" ]; then
+ echo "Error: expected find destination directory $DEST_DIR"
+ exit 1
+fi
+
+rm -fr "$DEST_DIR/game-activity"
+rm -fr "$DEST_DIR/game-text-input"
+rm -fr "$DEST_DIR/src/common"
+rm -fr "$DEST_DIR/include/common"
+
+mkdir -p "$DEST_DIR/game-activity"
+mkdir -p "$DEST_DIR/game-text-input"
+mkdir -p "$DEST_DIR/include/common"
+mkdir -p "$DEST_DIR/src/common"
+
+cp -av "$SOURCE_DIR/game-activity/prefab-src" "$DEST_DIR/game-activity"
+cp -av "$SOURCE_DIR/game-text-input/prefab-src" "$DEST_DIR/game-text-input"
+cp -av "$SOURCE_DIR/include/common/gamesdk_common.h" "$DEST_DIR/include/common"
+cp -av "$SOURCE_DIR/src/common/system_utils.h" "$DEST_DIR/src/common"
+cp -av "$SOURCE_DIR/src/common/system_utils.cpp" "$DEST_DIR/src/common"
\ No newline at end of file
diff --git a/android-activity/game-activity-csrc/common/gamesdk_common.h b/android-activity/android-games-sdk/include/common/gamesdk_common.h
similarity index 86%
rename from android-activity/game-activity-csrc/common/gamesdk_common.h
rename to android-activity/android-games-sdk/include/common/gamesdk_common.h
index d29ac01..25ce813 100644
--- a/android-activity/game-activity-csrc/common/gamesdk_common.h
+++ b/android-activity/android-games-sdk/include/common/gamesdk_common.h
@@ -31,11 +31,12 @@
// There are separate versions for each GameSDK component that use this format:
#define ANDROID_GAMESDK_PACKED_VERSION(MAJOR, MINOR, BUGFIX) \
- ((MAJOR << 16) | (MINOR << 8) | (BUGFIX))
+ ((MAJOR << 16) | (MINOR << 8) | (BUGFIX))
// Accessors
#define ANDROID_GAMESDK_MAJOR_VERSION(PACKED) ((PACKED) >> 16)
#define ANDROID_GAMESDK_MINOR_VERSION(PACKED) (((PACKED) >> 8) & 0xff)
#define ANDROID_GAMESDK_BUGFIX_VERSION(PACKED) ((PACKED) & 0xff)
-#define AGDK_STRING_VERSION(MAJOR, MINOR, BUGFIX, GIT) \
-#MAJOR "." #MINOR "." #BUGFIX "." #GIT
+#define AGDK_STRINGIFY(NUMBER) #NUMBER
+#define AGDK_STRING_VERSION(MAJOR, MINOR, BUGFIX) \
+ AGDK_STRINGIFY(MAJOR) "." AGDK_STRINGIFY(MINOR) "." AGDK_STRINGIFY(BUGFIX)
diff --git a/android-activity/android-games-sdk/src/common/system_utils.cpp b/android-activity/android-games-sdk/src/common/system_utils.cpp
new file mode 100644
index 0000000..efc5b74
--- /dev/null
+++ b/android-activity/android-games-sdk/src/common/system_utils.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "system_utils.h"
+
+#include
+#include
+#include
+
+namespace gamesdk {
+
+#if __ANDROID_API__ >= 26
+std::string getSystemPropViaCallback(const char* key,
+ const char* default_value = "") {
+ const prop_info* prop = __system_property_find(key);
+ if (prop == nullptr) {
+ return default_value;
+ }
+ std::string return_value;
+ auto thunk = [](void* cookie, const char* /*name*/, const char* value,
+ uint32_t /*serial*/) {
+ if (value != nullptr) {
+ std::string* r = static_cast(cookie);
+ *r = value;
+ }
+ };
+ __system_property_read_callback(prop, thunk, &return_value);
+ return return_value;
+}
+#else
+std::string getSystemPropViaGet(const char* key,
+ const char* default_value = "") {
+ char buffer[PROP_VALUE_MAX + 1] = ""; // +1 for terminator
+ int bufferLen = __system_property_get(key, buffer);
+ if (bufferLen > 0)
+ return buffer;
+ else
+ return "";
+}
+#endif
+
+std::string GetSystemProp(const char* key, const char* default_value) {
+#if __ANDROID_API__ >= 26
+ return getSystemPropViaCallback(key, default_value);
+#else
+ return getSystemPropViaGet(key, default_value);
+#endif
+}
+
+int GetSystemPropAsInt(const char* key, int default_value) {
+ std::string prop = GetSystemProp(key);
+ return prop == "" ? default_value : strtoll(prop.c_str(), nullptr, 10);
+}
+
+bool GetSystemPropAsBool(const char* key, bool default_value) {
+ return GetSystemPropAsInt(key, default_value) != 0;
+}
+
+} // namespace gamesdk
\ No newline at end of file
diff --git a/android-activity/android-games-sdk/src/common/system_utils.h b/android-activity/android-games-sdk/src/common/system_utils.h
new file mode 100644
index 0000000..488374b
--- /dev/null
+++ b/android-activity/android-games-sdk/src/common/system_utils.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "string"
+
+namespace gamesdk {
+
+// Get the value of the given system property
+std::string GetSystemProp(const char* key, const char* default_value = "");
+
+// Get the value of the given system property as an integer
+int GetSystemPropAsInt(const char* key, int default_value = 0);
+
+// Get the value of the given system property as a bool
+bool GetSystemPropAsBool(const char* key, bool default_value = false);
+
+} // namespace gamesdk
\ No newline at end of file
diff --git a/android-activity/build.rs b/android-activity/build.rs
index 7fc92e7..833ecaa 100644
--- a/android-activity/build.rs
+++ b/android-activity/build.rs
@@ -1,41 +1,89 @@
#![allow(dead_code)]
fn build_glue_for_game_activity() {
+ let android_games_sdk =
+ std::env::var("ANDROID_GAMES_SDK").unwrap_or_else(|_err| "android-games-sdk".to_string());
+
+ let activity_path = |src_inc, name| {
+ format!("{android_games_sdk}/game-activity/prefab-src/modules/game-activity/{src_inc}/game-activity/{name}")
+ };
+ let textinput_path = |src_inc, name| {
+ format!("{android_games_sdk}/game-text-input/prefab-src/modules/game-text-input/{src_inc}/game-text-input/{name}")
+ };
+
+ for f in ["GameActivity.cpp", "GameActivityEvents.cpp"] {
+ println!("cargo:rerun-if-changed={}", activity_path("src", f));
+ }
+
for f in [
"GameActivity.h",
- "GameActivity.cpp",
"GameActivityEvents.h",
- "GameActivityEvents.cpp",
"GameActivityLog.h",
+ "GameActivityEvents_internal.h",
] {
- println!("cargo:rerun-if-changed=game-activity-csrc/game-activity/{f}");
+ println!("cargo:rerun-if-changed={}", activity_path("include", f));
}
+
cc::Build::new()
.cpp(true)
- .include("game-activity-csrc")
- .file("game-activity-csrc/game-activity/GameActivity.cpp")
- .file("game-activity-csrc/game-activity/GameActivityEvents.cpp")
+ .include("android-games-sdk/src/common")
+ .file("android-games-sdk/src/common/system_utils.cpp")
+ .extra_warnings(false)
+ .cpp_link_stdlib("c++_static")
+ .compile("libgame_common.a");
+
+ println!("cargo:rerun-if-changed=android-games-sdk/src/common/system_utils.cpp");
+ println!("cargo:rerun-if-changed=android-games-sdk/src/common/system_utils.h");
+
+ cc::Build::new()
+ .cpp(true)
+ .include("android-games-sdk/src/common")
+ .include("android-games-sdk/include")
+ .include("android-games-sdk/game-activity/prefab-src/modules/game-activity/include")
+ .include("android-games-sdk/game-text-input/prefab-src/modules/game-text-input/include")
+ .file(activity_path("src", "GameActivity.cpp"))
+ .file(activity_path("src", "GameActivityEvents.cpp"))
.extra_warnings(false)
.cpp_link_stdlib("c++_static")
.compile("libgame_activity.a");
- for f in ["gamecommon.h", "gametextinput.h", "gametextinput.cpp"] {
- println!("cargo:rerun-if-changed=game-activity-csrc/game-text-input/{f}");
- }
+ println!(
+ "cargo:rerun-if-changed={}",
+ textinput_path("include", "gametextinput.h")
+ );
+ println!(
+ "cargo:rerun-if-changed={}",
+ textinput_path("src", "gametextinput.cpp")
+ );
+
cc::Build::new()
.cpp(true)
- .include("game-activity-csrc")
- .file("game-activity-csrc/game-text-input/gametextinput.cpp")
+ .include("android-games-sdk/src/common")
+ .include("android-games-sdk/include")
+ .include("android-games-sdk/game-text-input/prefab-src/modules/game-text-input/include")
+ .file(textinput_path("src", "gametextinput.cpp"))
.cpp_link_stdlib("c++_static")
.compile("libgame_text_input.a");
- for f in ["android_native_app_glue.h", "android_native_app_glue.c"] {
- println!("cargo:rerun-if-changed=game-activity-csrc/native_app_glue/{f}");
- }
+ println!(
+ "cargo:rerun-if-changed={}",
+ activity_path("src", "native_app_glue/android_native_app_glue.c")
+ );
+ println!(
+ "cargo:rerun-if-changed={}",
+ activity_path("include", "native_app_glue/android_native_app_glue.h")
+ );
+
cc::Build::new()
- .include("game-activity-csrc")
- .include("game-activity-csrc/game-activity/native_app_glue")
- .file("game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.c")
+ .include("android-games-sdk/src/common")
+ .include("android-games-sdk/include")
+ .include("android-games-sdk/game-activity/prefab-src/modules/game-activity/include")
+ .include("android-games-sdk/game-text-input/prefab-src/modules/game-text-input/include")
+ .include(activity_path("include", ""))
+ .file(activity_path(
+ "src",
+ "native_app_glue/android_native_app_glue.c",
+ ))
.extra_warnings(false)
.cpp_link_stdlib("c++_static")
.compile("libnative_app_glue.a");
diff --git a/android-activity/game-activity-csrc/game-activity/GameActivity.cpp b/android-activity/game-activity-csrc/game-activity/GameActivity.cpp
deleted file mode 100644
index 4dbc9e8..0000000
--- a/android-activity/game-activity-csrc/game-activity/GameActivity.cpp
+++ /dev/null
@@ -1,1147 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "GameActivity.h"
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include
-#include
-#include
-
-#include "GameActivityLog.h"
-
-namespace {
-
-struct OwnedGameTextInputState {
- OwnedGameTextInputState &operator=(const GameTextInputState &rhs) {
- inner = rhs;
- owned_string = std::string(rhs.text_UTF8, rhs.text_length);
- inner.text_UTF8 = owned_string.data();
- return *this;
- }
- GameTextInputState inner;
- std::string owned_string;
-};
-
-} // anonymous namespace
-
-#ifndef NELEM
-#define NELEM(x) ((int)(sizeof(x) / sizeof((x)[0])))
-#endif
-
-/*
- * JNI methods of the GameActivity Java class.
- */
-static struct {
- jmethodID finish;
- jmethodID setWindowFlags;
- jmethodID getWindowInsets;
- jmethodID getWaterfallInsets;
- jmethodID setImeEditorInfoFields;
-} gGameActivityClassInfo;
-
-/*
- * JNI fields of the androidx.core.graphics.Insets Java class.
- */
-static struct {
- jfieldID left;
- jfieldID right;
- jfieldID top;
- jfieldID bottom;
-} gInsetsClassInfo;
-
-/*
- * JNI fields of the Configuration Java class.
- */
-static struct ConfigurationClassInfo {
- jfieldID colorMode;
- jfieldID densityDpi;
- jfieldID fontScale;
- jfieldID fontWeightAdjustment;
- jfieldID hardKeyboardHidden;
- jfieldID keyboard;
- jfieldID keyboardHidden;
- jfieldID mcc;
- jfieldID mnc;
- jfieldID navigation;
- jfieldID navigationHidden;
- jfieldID orientation;
- jfieldID screenHeightDp;
- jfieldID screenLayout;
- jfieldID screenWidthDp;
- jfieldID smallestScreenWidthDp;
- jfieldID touchscreen;
- jfieldID uiMode;
-} gConfigurationClassInfo;
-
-/*
- * JNI methods of the WindowInsetsCompat.Type Java class.
- */
-static struct {
- jmethodID methods[GAMECOMMON_INSETS_TYPE_COUNT];
- jclass clazz;
-} gWindowInsetsCompatTypeClassInfo;
-
-/*
- * Contains a command to be executed by the GameActivity
- * on the application main thread.
- */
-struct ActivityWork {
- int32_t cmd;
- int64_t arg1;
- int64_t arg2;
- int64_t arg3;
-};
-
-/*
- * The type of commands that can be passed to the GameActivity and that
- * are executed on the application main thread.
- */
-enum {
- CMD_FINISH = 1,
- CMD_SET_WINDOW_FORMAT,
- CMD_SET_WINDOW_FLAGS,
- CMD_SHOW_SOFT_INPUT,
- CMD_HIDE_SOFT_INPUT,
- CMD_SET_SOFT_INPUT_STATE,
- CMD_SET_IME_EDITOR_INFO
-};
-
-/*
- * Last known Configuration values. They may be accessed from the different
- * thread, this is why they are made atomic.
- */
-static struct Configuration {
- std::atomic_int colorMode;
- std::atomic_int densityDpi;
- std::atomic fontScale;
- std::atomic_int fontWeightAdjustment;
- std::atomic_int hardKeyboardHidden;
- std::atomic_int keyboard;
- std::atomic_int keyboardHidden;
- std::atomic_int mcc;
- std::atomic_int mnc;
- std::atomic_int navigation;
- std::atomic_int navigationHidden;
- std::atomic_int orientation;
- std::atomic_int screenHeightDp;
- std::atomic_int screenLayout;
- std::atomic_int screenWidthDp;
- std::atomic_int smallestScreenWidthDp;
- std::atomic_int touchscreen;
- std::atomic_int uiMode;
-} gConfiguration;
-
-/*
- * Write a command to be executed by the GameActivity on the application main
- * thread.
- */
-static void write_work(int fd, int32_t cmd, int64_t arg1 = 0, int64_t arg2 = 0,
- int64_t arg3 = 0) {
- ActivityWork work;
- work.cmd = cmd;
- work.arg1 = arg1;
- work.arg2 = arg2;
- work.arg3 = arg3;
-
- LOG_TRACE("write_work: cmd=%d", cmd);
-restart:
- int res = write(fd, &work, sizeof(work));
- if (res < 0 && errno == EINTR) {
- goto restart;
- }
-
- if (res == sizeof(work)) return;
-
- if (res < 0) {
- ALOGW("Failed writing to work fd: %s", strerror(errno));
- } else {
- ALOGW("Truncated writing to work fd: %d", res);
- }
-}
-
-/*
- * Read commands to be executed by the GameActivity on the application main
- * thread.
- */
-static bool read_work(int fd, ActivityWork *outWork) {
- int res = read(fd, outWork, sizeof(ActivityWork));
- // no need to worry about EINTR, poll loop will just come back again.
- if (res == sizeof(ActivityWork)) return true;
-
- if (res < 0) {
- ALOGW("Failed reading work fd: %s", strerror(errno));
- } else {
- ALOGW("Truncated reading work fd: %d", res);
- }
- return false;
-}
-
-/*
- * Native state for interacting with the GameActivity class.
- */
-struct NativeCode : public GameActivity {
- NativeCode() {
- memset((GameActivity *)this, 0, sizeof(GameActivity));
- memset(&callbacks, 0, sizeof(callbacks));
- memset(&insetsState, 0, sizeof(insetsState));
- nativeWindow = NULL;
- mainWorkRead = mainWorkWrite = -1;
- gameTextInput = NULL;
- }
-
- ~NativeCode() {
- if (callbacks.onDestroy != NULL) {
- callbacks.onDestroy(this);
- }
- if (env != NULL) {
- if (javaGameActivity != NULL) {
- env->DeleteGlobalRef(javaGameActivity);
- }
- if (javaAssetManager != NULL) {
- env->DeleteGlobalRef(javaAssetManager);
- }
- }
- GameTextInput_destroy(gameTextInput);
- if (looper != NULL && mainWorkRead >= 0) {
- ALooper_removeFd(looper, mainWorkRead);
- }
- ALooper_release(looper);
- looper = NULL;
-
- setSurface(NULL);
- if (mainWorkRead >= 0) close(mainWorkRead);
- if (mainWorkWrite >= 0) close(mainWorkWrite);
- }
-
- void setSurface(jobject _surface) {
- if (nativeWindow != NULL) {
- ANativeWindow_release(nativeWindow);
- }
- if (_surface != NULL) {
- nativeWindow = ANativeWindow_fromSurface(env, _surface);
- } else {
- nativeWindow = NULL;
- }
- }
-
- GameActivityCallbacks callbacks;
-
- std::string internalDataPathObj;
- std::string externalDataPathObj;
- std::string obbPathObj;
-
- ANativeWindow *nativeWindow;
- int32_t lastWindowWidth;
- int32_t lastWindowHeight;
-
- // These are used to wake up the main thread to process work.
- int mainWorkRead;
- int mainWorkWrite;
- ALooper *looper;
-
- // Need to hold on to a reference here in case the upper layers destroy our
- // AssetManager.
- jobject javaAssetManager;
-
- GameTextInput *gameTextInput;
- // Set by users in GameActivity_setTextInputState, then passed to
- // GameTextInput.
- OwnedGameTextInputState gameTextInputState;
- std::mutex gameTextInputStateMutex;
-
- ARect insetsState[GAMECOMMON_INSETS_TYPE_COUNT];
-};
-
-static void readConfigurationValues(NativeCode *code, jobject javaConfig);
-
-extern "C" void GameActivity_finish(GameActivity *activity) {
- NativeCode *code = static_cast(activity);
- write_work(code->mainWorkWrite, CMD_FINISH, 0);
-}
-
-extern "C" void GameActivity_setWindowFlags(GameActivity *activity,
- uint32_t values, uint32_t mask) {
- NativeCode *code = static_cast(activity);
- write_work(code->mainWorkWrite, CMD_SET_WINDOW_FLAGS, values, mask);
-}
-
-extern "C" void GameActivity_showSoftInput(GameActivity *activity,
- uint32_t flags) {
- NativeCode *code = static_cast(activity);
- write_work(code->mainWorkWrite, CMD_SHOW_SOFT_INPUT, flags);
-}
-
-extern "C" void GameActivity_setTextInputState(
- GameActivity *activity, const GameTextInputState *state) {
- NativeCode *code = static_cast(activity);
- std::lock_guard lock(code->gameTextInputStateMutex);
- code->gameTextInputState = *state;
- write_work(code->mainWorkWrite, CMD_SET_SOFT_INPUT_STATE);
-}
-
-extern "C" void GameActivity_getTextInputState(
- GameActivity *activity, GameTextInputGetStateCallback callback,
- void *context) {
- NativeCode *code = static_cast(activity);
- return GameTextInput_getState(code->gameTextInput, callback, context);
-}
-
-extern "C" void GameActivity_hideSoftInput(GameActivity *activity,
- uint32_t flags) {
- NativeCode *code = static_cast(activity);
- write_work(code->mainWorkWrite, CMD_HIDE_SOFT_INPUT, flags);
-}
-
-extern "C" void GameActivity_getWindowInsets(GameActivity *activity,
- GameCommonInsetsType type,
- ARect *insets) {
- if (type < 0 || type >= GAMECOMMON_INSETS_TYPE_COUNT) return;
- NativeCode *code = static_cast(activity);
- *insets = code->insetsState[type];
-}
-
-extern "C" GameTextInput *GameActivity_getTextInput(
- const GameActivity *activity) {
- const NativeCode *code = static_cast(activity);
- return code->gameTextInput;
-}
-
-/*
- * Log the JNI exception, if any.
- */
-static void checkAndClearException(JNIEnv *env, const char *methodName) {
- if (env->ExceptionCheck()) {
- ALOGE("Exception while running %s", methodName);
- env->ExceptionDescribe();
- env->ExceptionClear();
- }
-}
-
-/*
- * Callback for handling native events on the application's main thread.
- */
-static int mainWorkCallback(int fd, int events, void *data) {
- ALOGD("************** mainWorkCallback *********");
- NativeCode *code = (NativeCode *)data;
- if ((events & POLLIN) == 0) {
- return 1;
- }
-
- ActivityWork work;
- if (!read_work(code->mainWorkRead, &work)) {
- return 1;
- }
- LOG_TRACE("mainWorkCallback: cmd=%d", work.cmd);
- switch (work.cmd) {
- case CMD_FINISH: {
- code->env->CallVoidMethod(code->javaGameActivity,
- gGameActivityClassInfo.finish);
- checkAndClearException(code->env, "finish");
- } break;
- case CMD_SET_WINDOW_FLAGS: {
- code->env->CallVoidMethod(code->javaGameActivity,
- gGameActivityClassInfo.setWindowFlags,
- work.arg1, work.arg2);
- checkAndClearException(code->env, "setWindowFlags");
- } break;
- case CMD_SHOW_SOFT_INPUT: {
- GameTextInput_showIme(code->gameTextInput, work.arg1);
- } break;
- case CMD_SET_SOFT_INPUT_STATE: {
- std::lock_guard lock(code->gameTextInputStateMutex);
- GameTextInput_setState(code->gameTextInput,
- &code->gameTextInputState.inner);
- checkAndClearException(code->env, "setTextInputState");
- } break;
- case CMD_HIDE_SOFT_INPUT: {
- GameTextInput_hideIme(code->gameTextInput, work.arg1);
- } break;
- case CMD_SET_IME_EDITOR_INFO: {
- code->env->CallVoidMethod(
- code->javaGameActivity,
- gGameActivityClassInfo.setImeEditorInfoFields, work.arg1,
- work.arg2, work.arg3);
- checkAndClearException(code->env, "setImeEditorInfo");
- } break;
- default:
- ALOGW("Unknown work command: %d", work.cmd);
- break;
- }
-
- return 1;
-}
-
-// ------------------------------------------------------------------------
-static thread_local std::string g_error_msg;
-
-static jlong initializeNativeCode_native(
- JNIEnv *env, jobject javaGameActivity, jstring internalDataDir,
- jstring obbDir, jstring externalDataDir, jobject jAssetMgr,
- jbyteArray savedState, jobject javaConfig) {
- LOG_TRACE("initializeNativeCode_native");
- NativeCode *code = NULL;
-
- code = new NativeCode();
-
- code->looper = ALooper_forThread();
- if (code->looper == nullptr) {
- g_error_msg = "Unable to retrieve native ALooper";
- ALOGW("%s", g_error_msg.c_str());
- delete code;
- return 0;
- }
- ALooper_acquire(code->looper);
-
- int msgpipe[2];
- if (pipe(msgpipe)) {
- g_error_msg = "could not create pipe: ";
- g_error_msg += strerror(errno);
-
- ALOGW("%s", g_error_msg.c_str());
- delete code;
- return 0;
- }
- code->mainWorkRead = msgpipe[0];
- code->mainWorkWrite = msgpipe[1];
- int result = fcntl(code->mainWorkRead, F_SETFL, O_NONBLOCK);
- SLOGW_IF(result != 0,
- "Could not make main work read pipe "
- "non-blocking: %s",
- strerror(errno));
- result = fcntl(code->mainWorkWrite, F_SETFL, O_NONBLOCK);
- SLOGW_IF(result != 0,
- "Could not make main work write pipe "
- "non-blocking: %s",
- strerror(errno));
- ALooper_addFd(code->looper, code->mainWorkRead, 0, ALOOPER_EVENT_INPUT,
- mainWorkCallback, code);
-
- code->GameActivity::callbacks = &code->callbacks;
- if (env->GetJavaVM(&code->vm) < 0) {
- ALOGW("GameActivity GetJavaVM failed");
- delete code;
- return 0;
- }
- code->env = env;
- code->javaGameActivity = env->NewGlobalRef(javaGameActivity);
-
- const char *dirStr =
- internalDataDir ? env->GetStringUTFChars(internalDataDir, NULL) : "";
- code->internalDataPathObj = dirStr;
- code->internalDataPath = code->internalDataPathObj.c_str();
- if (internalDataDir) env->ReleaseStringUTFChars(internalDataDir, dirStr);
-
- dirStr =
- externalDataDir ? env->GetStringUTFChars(externalDataDir, NULL) : "";
- code->externalDataPathObj = dirStr;
- code->externalDataPath = code->externalDataPathObj.c_str();
- if (externalDataDir) env->ReleaseStringUTFChars(externalDataDir, dirStr);
-
- code->javaAssetManager = env->NewGlobalRef(jAssetMgr);
- code->assetManager = AAssetManager_fromJava(env, jAssetMgr);
-
- dirStr = obbDir ? env->GetStringUTFChars(obbDir, NULL) : "";
- code->obbPathObj = dirStr;
- code->obbPath = code->obbPathObj.c_str();
- if (obbDir) env->ReleaseStringUTFChars(obbDir, dirStr);
-
- jbyte *rawSavedState = NULL;
- jsize rawSavedSize = 0;
- if (savedState != NULL) {
- rawSavedState = env->GetByteArrayElements(savedState, NULL);
- rawSavedSize = env->GetArrayLength(savedState);
- }
-
- readConfigurationValues(code, javaConfig);
-
- GameActivity_onCreate_C(code, rawSavedState, rawSavedSize);
-
- code->gameTextInput = GameTextInput_init(env, 0);
- GameTextInput_setEventCallback(code->gameTextInput,
- reinterpret_cast(
- code->callbacks.onTextInputEvent),
- code);
-
- if (rawSavedState != NULL) {
- env->ReleaseByteArrayElements(savedState, rawSavedState, 0);
- }
-
- return reinterpret_cast(code);
-}
-
-static jstring getDlError_native(JNIEnv *env, jobject javaGameActivity) {
- jstring result = env->NewStringUTF(g_error_msg.c_str());
- g_error_msg.clear();
- return result;
-}
-
-static void terminateNativeCode_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle) {
- LOG_TRACE("terminateNativeCode_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- delete code;
- }
-}
-
-static void onStart_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle) {
- ALOGV("onStart_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onStart != NULL) {
- code->callbacks.onStart(code);
- }
- }
-}
-
-static void onResume_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle) {
- LOG_TRACE("onResume_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onResume != NULL) {
- code->callbacks.onResume(code);
- }
- }
-}
-
-struct SaveInstanceLocals {
- JNIEnv *env;
- jbyteArray array;
-};
-
-static jbyteArray onSaveInstanceState_native(JNIEnv *env,
- jobject javaGameActivity,
- jlong handle) {
- LOG_TRACE("onSaveInstanceState_native");
-
- SaveInstanceLocals locals{
- env, NULL}; // Passed through the user's state prep function.
-
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onSaveInstanceState != NULL) {
- code->callbacks.onSaveInstanceState(
- code,
- [](const char *bytes, int len, void *context) {
- auto locals = static_cast(context);
- if (len > 0) {
- locals->array = locals->env->NewByteArray(len);
- if (locals->array != NULL) {
- locals->env->SetByteArrayRegion(
- locals->array, 0, len, (const jbyte *)bytes);
- }
- }
- },
- &locals);
- }
- }
- return locals.array;
-}
-
-static void onPause_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle) {
- LOG_TRACE("onPause_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onPause != NULL) {
- code->callbacks.onPause(code);
- }
- }
-}
-
-static void onStop_native(JNIEnv *env, jobject javaGameActivity, jlong handle) {
- LOG_TRACE("onStop_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onStop != NULL) {
- code->callbacks.onStop(code);
- }
- }
-}
-
-static void readConfigurationValues(NativeCode *code, jobject javaConfig) {
- if (gConfigurationClassInfo.colorMode != NULL) {
- gConfiguration.colorMode = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.colorMode);
- }
-
- gConfiguration.densityDpi =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.densityDpi);
- gConfiguration.fontScale =
- code->env->GetFloatField(javaConfig, gConfigurationClassInfo.fontScale);
-
- if (gConfigurationClassInfo.fontWeightAdjustment != NULL) {
- gConfiguration.fontWeightAdjustment = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.fontWeightAdjustment);
- }
-
- gConfiguration.hardKeyboardHidden = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.hardKeyboardHidden);
- gConfiguration.mcc =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.mcc);
- gConfiguration.mnc =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.mnc);
- gConfiguration.navigation =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.navigation);
- gConfiguration.navigationHidden = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.navigationHidden);
- gConfiguration.orientation =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.orientation);
- gConfiguration.screenHeightDp = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.screenHeightDp);
- gConfiguration.screenLayout = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.screenLayout);
- gConfiguration.screenWidthDp = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.screenWidthDp);
- gConfiguration.smallestScreenWidthDp = code->env->GetIntField(
- javaConfig, gConfigurationClassInfo.smallestScreenWidthDp);
- gConfiguration.touchscreen =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.touchscreen);
- gConfiguration.uiMode =
- code->env->GetIntField(javaConfig, gConfigurationClassInfo.uiMode);
-
- checkAndClearException(code->env, "Configuration.get");
-}
-
-static void onConfigurationChanged_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jobject javaNewConfig) {
- LOG_TRACE("onConfigurationChanged_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- readConfigurationValues(code, javaNewConfig);
-
- if (code->callbacks.onConfigurationChanged != NULL) {
- code->callbacks.onConfigurationChanged(code);
- }
- }
-}
-
-static void onTrimMemory_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jint level) {
- LOG_TRACE("onTrimMemory_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onTrimMemory != NULL) {
- code->callbacks.onTrimMemory(code, level);
- }
- }
-}
-
-static void onWindowFocusChanged_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jboolean focused) {
- LOG_TRACE("onWindowFocusChanged_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onWindowFocusChanged != NULL) {
- code->callbacks.onWindowFocusChanged(code, focused ? 1 : 0);
- }
- }
-}
-
-static void onSurfaceCreated_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jobject surface) {
- ALOGV("onSurfaceCreated_native");
- LOG_TRACE("onSurfaceCreated_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- code->setSurface(surface);
-
- if (code->nativeWindow != NULL &&
- code->callbacks.onNativeWindowCreated != NULL) {
- code->callbacks.onNativeWindowCreated(code, code->nativeWindow);
- }
- }
-}
-
-static void onSurfaceChanged_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jobject surface, jint format,
- jint width, jint height) {
- LOG_TRACE("onSurfaceChanged_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- ANativeWindow *oldNativeWindow = code->nativeWindow;
- // Fix for window being destroyed behind the scenes on older Android
- // versions.
- if (oldNativeWindow != NULL) {
- ANativeWindow_acquire(oldNativeWindow);
- }
- code->setSurface(surface);
- if (oldNativeWindow != code->nativeWindow) {
- if (oldNativeWindow != NULL &&
- code->callbacks.onNativeWindowDestroyed != NULL) {
- code->callbacks.onNativeWindowDestroyed(code, oldNativeWindow);
- }
- if (code->nativeWindow != NULL) {
- if (code->callbacks.onNativeWindowCreated != NULL) {
- code->callbacks.onNativeWindowCreated(code,
- code->nativeWindow);
- }
-
- code->lastWindowWidth =
- ANativeWindow_getWidth(code->nativeWindow);
- code->lastWindowHeight =
- ANativeWindow_getHeight(code->nativeWindow);
- }
- } else {
- // Maybe it was resized?
- int32_t newWidth = ANativeWindow_getWidth(code->nativeWindow);
- int32_t newHeight = ANativeWindow_getHeight(code->nativeWindow);
-
- if (newWidth != code->lastWindowWidth ||
- newHeight != code->lastWindowHeight) {
- code->lastWindowWidth = newWidth;
- code->lastWindowHeight = newHeight;
-
- if (code->callbacks.onNativeWindowResized != NULL) {
- code->callbacks.onNativeWindowResized(
- code, code->nativeWindow, newWidth, newHeight);
- }
- }
- }
- // Release the window we acquired earlier.
- if (oldNativeWindow != NULL) {
- ANativeWindow_release(oldNativeWindow);
- }
- }
-}
-
-static void onSurfaceRedrawNeeded_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle) {
- LOG_TRACE("onSurfaceRedrawNeeded_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->nativeWindow != NULL &&
- code->callbacks.onNativeWindowRedrawNeeded != NULL) {
- code->callbacks.onNativeWindowRedrawNeeded(code,
- code->nativeWindow);
- }
- }
-}
-
-static void onSurfaceDestroyed_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle) {
- LOG_TRACE("onSurfaceDestroyed_native");
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
- if (code->nativeWindow != NULL &&
- code->callbacks.onNativeWindowDestroyed != NULL) {
- code->callbacks.onNativeWindowDestroyed(code, code->nativeWindow);
- }
- code->setSurface(NULL);
- }
-}
-
-extern "C" void GameActivity_setImeEditorInfo(GameActivity *activity,
- int inputType, int actionId,
- int imeOptions) {
- NativeCode *code = static_cast(activity);
- write_work(code->mainWorkWrite, CMD_SET_IME_EDITOR_INFO, inputType,
- actionId, imeOptions);
-}
-
-extern "C" int GameActivity_getColorMode(GameActivity *) {
- return gConfiguration.colorMode;
-}
-
-extern "C" int GameActivity_getDensityDpi(GameActivity *) {
- return gConfiguration.densityDpi;
-}
-
-extern "C" float GameActivity_getFontScale(GameActivity *) {
- return gConfiguration.fontScale;
-}
-
-extern "C" int GameActivity_getFontWeightAdjustment(GameActivity *) {
- return gConfiguration.fontWeightAdjustment;
-}
-
-extern "C" int GameActivity_getHardKeyboardHidden(GameActivity *) {
- return gConfiguration.hardKeyboardHidden;
-}
-
-extern "C" int GameActivity_getKeyboard(GameActivity *) {
- return gConfiguration.keyboard;
-}
-
-extern "C" int GameActivity_getKeyboardHidden(GameActivity *) {
- return gConfiguration.keyboardHidden;
-}
-
-extern "C" int GameActivity_getMcc(GameActivity *) {
- return gConfiguration.mcc;
-}
-
-extern "C" int GameActivity_getMnc(GameActivity *) {
- return gConfiguration.mnc;
-}
-
-extern "C" int GameActivity_getNavigation(GameActivity *) {
- return gConfiguration.navigation;
-}
-
-extern "C" int GameActivity_getNavigationHidden(GameActivity *) {
- return gConfiguration.navigationHidden;
-}
-
-extern "C" int GameActivity_getOrientation(GameActivity *) {
- return gConfiguration.orientation;
-}
-
-extern "C" int GameActivity_getScreenHeightDp(GameActivity *) {
- return gConfiguration.screenHeightDp;
-}
-
-extern "C" int GameActivity_getScreenLayout(GameActivity *) {
- return gConfiguration.screenLayout;
-}
-
-extern "C" int GameActivity_getScreenWidthDp(GameActivity *) {
- return gConfiguration.screenWidthDp;
-}
-
-extern "C" int GameActivity_getSmallestScreenWidthDp(GameActivity *) {
- return gConfiguration.smallestScreenWidthDp;
-}
-
-extern "C" int GameActivity_getTouchscreen(GameActivity *) {
- return gConfiguration.touchscreen;
-}
-
-extern "C" int GameActivity_getUIMode(GameActivity *) {
- return gConfiguration.uiMode;
-}
-
-static bool onTouchEvent_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jobject motionEvent) {
- if (handle == 0) return false;
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onTouchEvent == nullptr) return false;
-
- static GameActivityMotionEvent c_event;
- GameActivityMotionEvent_fromJava(env, motionEvent, &c_event);
- return code->callbacks.onTouchEvent(code, &c_event);
-
-}
-
-static bool onKeyUp_native(JNIEnv *env, jobject javaGameActivity, jlong handle,
- jobject keyEvent) {
- if (handle == 0) return false;
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onKeyUp == nullptr) return false;
-
- static GameActivityKeyEvent c_event;
- GameActivityKeyEvent_fromJava(env, keyEvent, &c_event);
- return code->callbacks.onKeyUp(code, &c_event);
-}
-
-static bool onKeyDown_native(JNIEnv *env, jobject javaGameActivity,
- jlong handle, jobject keyEvent) {
- if (handle == 0) return false;
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onKeyDown == nullptr) return false;
-
- static GameActivityKeyEvent c_event;
- GameActivityKeyEvent_fromJava(env, keyEvent, &c_event);
- return code->callbacks.onKeyDown(code, &c_event);
-}
-
-static void onTextInput_native(JNIEnv *env, jobject activity, jlong handle,
- jobject textInputEvent) {
- if (handle == 0) return;
- NativeCode *code = (NativeCode *)handle;
- GameTextInput_processEvent(code->gameTextInput, textInputEvent);
-}
-
-static void onWindowInsetsChanged_native(JNIEnv *env, jobject activity,
- jlong handle) {
- if (handle == 0) return;
- NativeCode *code = (NativeCode *)handle;
- if (code->callbacks.onWindowInsetsChanged == nullptr) return;
- for (int type = 0; type < GAMECOMMON_INSETS_TYPE_COUNT; ++type) {
- jobject jinsets;
- // Note that waterfall insets are handled differently on the Java side.
- if (type == GAMECOMMON_INSETS_TYPE_WATERFALL) {
- jinsets = env->CallObjectMethod(
- code->javaGameActivity,
- gGameActivityClassInfo.getWaterfallInsets);
- } else {
- jint jtype = env->CallStaticIntMethod(
- gWindowInsetsCompatTypeClassInfo.clazz,
- gWindowInsetsCompatTypeClassInfo.methods[type]);
- jinsets = env->CallObjectMethod(
- code->javaGameActivity, gGameActivityClassInfo.getWindowInsets,
- jtype);
- }
- ARect &insets = code->insetsState[type];
- if (jinsets == nullptr) {
- insets.left = 0;
- insets.right = 0;
- insets.top = 0;
- insets.bottom = 0;
- } else {
- insets.left = env->GetIntField(jinsets, gInsetsClassInfo.left);
- insets.right = env->GetIntField(jinsets, gInsetsClassInfo.right);
- insets.top = env->GetIntField(jinsets, gInsetsClassInfo.top);
- insets.bottom = env->GetIntField(jinsets, gInsetsClassInfo.bottom);
- }
- }
- GameTextInput_processImeInsets(
- code->gameTextInput, &code->insetsState[GAMECOMMON_INSETS_TYPE_IME]);
- code->callbacks.onWindowInsetsChanged(code);
-}
-
-static void setInputConnection_native(JNIEnv *env, jobject activity,
- jlong handle, jobject inputConnection) {
- NativeCode *code = (NativeCode *)handle;
- GameTextInput_setInputConnection(code->gameTextInput, inputConnection);
-}
-
-static void onContentRectChangedNative_native(JNIEnv *env, jobject activity,
- jlong handle, jint x, jint y,
- jint w, jint h) {
- if (handle != 0) {
- NativeCode *code = (NativeCode *)handle;
-
- if (code->callbacks.onContentRectChanged != nullptr) {
- ARect rect;
- rect.left = x;
- rect.top = y;
- rect.right = x+w;
- rect.bottom = y+h;
- code->callbacks.onContentRectChanged(code, &rect);
- }
- }
-}
-
-static const JNINativeMethod g_methods[] = {
- {"initializeNativeCode",
- "(Ljava/lang/String;Ljava/lang/String;"
- "Ljava/lang/String;Landroid/content/res/AssetManager;"
- "[BLandroid/content/res/Configuration;)J",
- (void *)initializeNativeCode_native},
- {"getDlError", "()Ljava/lang/String;", (void *)getDlError_native},
- {"terminateNativeCode", "(J)V", (void *)terminateNativeCode_native},
- {"onStartNative", "(J)V", (void *)onStart_native},
- {"onResumeNative", "(J)V", (void *)onResume_native},
- {"onSaveInstanceStateNative", "(J)[B", (void *)onSaveInstanceState_native},
- {"onPauseNative", "(J)V", (void *)onPause_native},
- {"onStopNative", "(J)V", (void *)onStop_native},
- {"onConfigurationChangedNative", "(JLandroid/content/res/Configuration;)V",
- (void *)onConfigurationChanged_native},
- {"onTrimMemoryNative", "(JI)V", (void *)onTrimMemory_native},
- {"onWindowFocusChangedNative", "(JZ)V",
- (void *)onWindowFocusChanged_native},
- {"onSurfaceCreatedNative", "(JLandroid/view/Surface;)V",
- (void *)onSurfaceCreated_native},
- {"onSurfaceChangedNative", "(JLandroid/view/Surface;III)V",
- (void *)onSurfaceChanged_native},
- {"onSurfaceRedrawNeededNative", "(JLandroid/view/Surface;)V",
- (void *)onSurfaceRedrawNeeded_native},
- {"onSurfaceDestroyedNative", "(J)V", (void *)onSurfaceDestroyed_native},
- {"onTouchEventNative", "(JLandroid/view/MotionEvent;)Z",
- (void *)onTouchEvent_native},
- {"onKeyDownNative", "(JLandroid/view/KeyEvent;)Z",
- (void *)onKeyDown_native},
- {"onKeyUpNative", "(JLandroid/view/KeyEvent;)Z", (void *)onKeyUp_native},
- {"onTextInputEventNative",
- "(JLcom/google/androidgamesdk/gametextinput/State;)V",
- (void *)onTextInput_native},
- {"onWindowInsetsChangedNative", "(J)V",
- (void *)onWindowInsetsChanged_native},
- {"setInputConnectionNative",
- "(JLcom/google/androidgamesdk/gametextinput/InputConnection;)V",
- (void *)setInputConnection_native},
- {"onContentRectChangedNative", "(JIIII)V",
- (void *)onContentRectChangedNative_native},
-};
-
-static const char *const kGameActivityPathName =
- "com/google/androidgamesdk/GameActivity";
-
-static const char *const kInsetsPathName = "androidx/core/graphics/Insets";
-static const char *const kConfigurationPathName =
- "android/content/res/Configuration";
-static const char *const kWindowInsetsCompatTypePathName =
- "androidx/core/view/WindowInsetsCompat$Type";
-
-#define FIND_CLASS(var, className) \
- var = env->FindClass(className); \
- LOG_FATAL_IF(!var, "Unable to find class %s", className);
-
-#define GET_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
- var = env->GetMethodID(clazz, methodName, fieldDescriptor); \
- LOG_FATAL_IF(!var, "Unable to find method %s", methodName);
-
-#define GET_STATIC_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
- var = env->GetStaticMethodID(clazz, methodName, fieldDescriptor); \
- LOG_FATAL_IF(!var, "Unable to find static method %s", methodName);
-
-#define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
- var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
- LOG_FATAL_IF(!var, "Unable to find field %s", fieldName);
-
-static int jniRegisterNativeMethods(JNIEnv *env, const char *className,
- const JNINativeMethod *methods,
- int numMethods) {
- ALOGV("Registering %s's %d native methods...", className, numMethods);
- jclass clazz = env->FindClass(className);
- LOG_FATAL_IF(clazz == nullptr,
- "Native registration unable to find class '%s'; aborting...",
- className);
- int result = env->RegisterNatives(clazz, methods, numMethods);
- env->DeleteLocalRef(clazz);
- if (result == 0) {
- return 0;
- }
-
- // Failure to register natives is fatal. Try to report the corresponding
- // exception, otherwise abort with generic failure message.
- jthrowable thrown = env->ExceptionOccurred();
- if (thrown != NULL) {
- env->ExceptionDescribe();
- env->DeleteLocalRef(thrown);
- }
- LOG_FATAL("RegisterNatives failed for '%s'; aborting...", className);
-}
-
-extern "C" int GameActivity_register(JNIEnv *env) {
- ALOGD("GameActivity_register");
- jclass activity_class;
- FIND_CLASS(activity_class, kGameActivityPathName);
- GET_METHOD_ID(gGameActivityClassInfo.finish, activity_class, "finish",
- "()V");
- GET_METHOD_ID(gGameActivityClassInfo.setWindowFlags, activity_class,
- "setWindowFlags", "(II)V");
- GET_METHOD_ID(gGameActivityClassInfo.getWindowInsets, activity_class,
- "getWindowInsets", "(I)Landroidx/core/graphics/Insets;");
- GET_METHOD_ID(gGameActivityClassInfo.getWaterfallInsets, activity_class,
- "getWaterfallInsets", "()Landroidx/core/graphics/Insets;");
- GET_METHOD_ID(gGameActivityClassInfo.setImeEditorInfoFields, activity_class,
- "setImeEditorInfoFields", "(III)V");
-
- jclass insets_class;
- FIND_CLASS(insets_class, kInsetsPathName);
- GET_FIELD_ID(gInsetsClassInfo.left, insets_class, "left", "I");
- GET_FIELD_ID(gInsetsClassInfo.right, insets_class, "right", "I");
- GET_FIELD_ID(gInsetsClassInfo.top, insets_class, "top", "I");
- GET_FIELD_ID(gInsetsClassInfo.bottom, insets_class, "bottom", "I");
-
- jclass configuration_class;
- FIND_CLASS(configuration_class, kConfigurationPathName);
-
- if (android_get_device_api_level() >= 26) {
- GET_FIELD_ID(gConfigurationClassInfo.colorMode, configuration_class,
- "colorMode", "I");
- }
-
- GET_FIELD_ID(gConfigurationClassInfo.densityDpi, configuration_class,
- "densityDpi", "I");
- GET_FIELD_ID(gConfigurationClassInfo.fontScale, configuration_class,
- "fontScale", "F");
-
- if (android_get_device_api_level() >= 31) {
- GET_FIELD_ID(gConfigurationClassInfo.fontWeightAdjustment,
- configuration_class, "fontWeightAdjustment", "I");
- }
-
- GET_FIELD_ID(gConfigurationClassInfo.hardKeyboardHidden,
- configuration_class, "hardKeyboardHidden", "I");
- GET_FIELD_ID(gConfigurationClassInfo.keyboard, configuration_class,
- "keyboard", "I");
- GET_FIELD_ID(gConfigurationClassInfo.keyboardHidden, configuration_class,
- "keyboardHidden", "I");
- GET_FIELD_ID(gConfigurationClassInfo.mcc, configuration_class, "mcc", "I");
- GET_FIELD_ID(gConfigurationClassInfo.mnc, configuration_class, "mnc", "I");
- GET_FIELD_ID(gConfigurationClassInfo.navigation, configuration_class,
- "navigation", "I");
- GET_FIELD_ID(gConfigurationClassInfo.navigationHidden, configuration_class,
- "navigationHidden", "I");
- GET_FIELD_ID(gConfigurationClassInfo.orientation, configuration_class,
- "orientation", "I");
- GET_FIELD_ID(gConfigurationClassInfo.screenHeightDp, configuration_class,
- "screenHeightDp", "I");
- GET_FIELD_ID(gConfigurationClassInfo.screenLayout, configuration_class,
- "screenLayout", "I");
- GET_FIELD_ID(gConfigurationClassInfo.screenWidthDp, configuration_class,
- "screenWidthDp", "I");
- GET_FIELD_ID(gConfigurationClassInfo.smallestScreenWidthDp,
- configuration_class, "smallestScreenWidthDp", "I");
- GET_FIELD_ID(gConfigurationClassInfo.touchscreen, configuration_class,
- "touchscreen", "I");
- GET_FIELD_ID(gConfigurationClassInfo.uiMode, configuration_class, "uiMode",
- "I");
-
- jclass windowInsetsCompatType_class;
- FIND_CLASS(windowInsetsCompatType_class, kWindowInsetsCompatTypePathName);
- gWindowInsetsCompatTypeClassInfo.clazz =
- (jclass)env->NewGlobalRef(windowInsetsCompatType_class);
- // These names must match, in order, the GameCommonInsetsType enum fields
- // Note that waterfall is handled differently by the insets API, so we
- // exclude it here.
- const char *methodNames[GAMECOMMON_INSETS_TYPE_WATERFALL] = {
- "captionBar",
- "displayCutout",
- "ime",
- "mandatorySystemGestures",
- "navigationBars",
- "statusBars",
- "systemBars",
- "systemGestures",
- "tappableElement"};
- for (int i = 0; i < GAMECOMMON_INSETS_TYPE_WATERFALL; ++i) {
- GET_STATIC_METHOD_ID(gWindowInsetsCompatTypeClassInfo.methods[i],
- windowInsetsCompatType_class, methodNames[i],
- "()I");
- }
- return jniRegisterNativeMethods(env, kGameActivityPathName, g_methods,
- NELEM(g_methods));
-}
-
-// XXX: This symbol is renamed with a _C suffix and then re-exported from
-// Rust because Rust/Cargo don't give us a way to directly export symbols
-// from C/C++ code: https://github.com/rust-lang/rfcs/issues/2771
-//
-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_androidgamesdk_GameActivity_initializeNativeCode_C(
- JNIEnv *env, jobject javaGameActivity, jstring internalDataDir,
- jstring obbDir, jstring externalDataDir, jobject jAssetMgr,
- jbyteArray savedState, jobject javaConfig) {
- GameActivity_register(env);
- jlong nativeCode = initializeNativeCode_native(
- env, javaGameActivity, internalDataDir, obbDir, externalDataDir,
- jAssetMgr, savedState, javaConfig);
- return nativeCode;
-}
diff --git a/android-activity/game-activity-csrc/game-activity/GameActivity.h b/android-activity/game-activity-csrc/game-activity/GameActivity.h
deleted file mode 100644
index b945069..0000000
--- a/android-activity/game-activity-csrc/game-activity/GameActivity.h
+++ /dev/null
@@ -1,636 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @addtogroup GameActivity Game Activity
- * The interface to use GameActivity.
- * @{
- */
-
-/**
- * @file GameActivity.h
- */
-
-#ifndef ANDROID_GAME_SDK_GAME_ACTIVITY_H
-#define ANDROID_GAME_SDK_GAME_ACTIVITY_H
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include "common/gamesdk_common.h"
-#include "game-activity/GameActivityEvents.h"
-#include "game-text-input/gametextinput.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define GAMEACTIVITY_MAJOR_VERSION 2
-#define GAMEACTIVITY_MINOR_VERSION 0
-#define GAMEACTIVITY_BUGFIX_VERSION 2
-#define GAMEACTIVITY_PACKED_VERSION \
- ANDROID_GAMESDK_PACKED_VERSION(GAMEACTIVITY_MAJOR_VERSION, \
- GAMEACTIVITY_MINOR_VERSION, \
- GAMEACTIVITY_BUGFIX_VERSION)
-
-/**
- * {@link GameActivityCallbacks}
- */
-struct GameActivityCallbacks;
-
-/**
- * This structure defines the native side of an android.app.GameActivity.
- * It is created by the framework, and handed to the application's native
- * code as it is being launched.
- */
-typedef struct GameActivity {
- /**
- * Pointer to the callback function table of the native application.
- * You can set the functions here to your own callbacks. The callbacks
- * pointer itself here should not be changed; it is allocated and managed
- * for you by the framework.
- */
- struct GameActivityCallbacks* callbacks;
-
- /**
- * The global handle on the process's Java VM.
- */
- JavaVM* vm;
-
- /**
- * JNI context for the main thread of the app. Note that this field
- * can ONLY be used from the main thread of the process; that is, the
- * thread that calls into the GameActivityCallbacks.
- */
- JNIEnv* env;
-
- /**
- * The GameActivity object handle.
- */
- jobject javaGameActivity;
-
- /**
- * Path to this application's internal data directory.
- */
- const char* internalDataPath;
-
- /**
- * Path to this application's external (removable/mountable) data directory.
- */
- const char* externalDataPath;
-
- /**
- * The platform's SDK version code.
- */
- int32_t sdkVersion;
-
- /**
- * This is the native instance of the application. It is not used by
- * the framework, but can be set by the application to its own instance
- * state.
- */
- void* instance;
-
- /**
- * Pointer to the Asset Manager instance for the application. The
- * application uses this to access binary assets bundled inside its own .apk
- * file.
- */
- AAssetManager* assetManager;
-
- /**
- * Available starting with Honeycomb: path to the directory containing
- * the application's OBB files (if any). If the app doesn't have any
- * OBB files, this directory may not exist.
- */
- const char* obbPath;
-} GameActivity;
-
-/**
- * A function the user should call from their callback with the data, its length
- * and the library- supplied context.
- */
-typedef void (*SaveInstanceStateRecallback)(const char* bytes, int len,
- void* context);
-
-/**
- * These are the callbacks the framework makes into a native application.
- * All of these callbacks happen on the main thread of the application.
- * By default, all callbacks are NULL; set to a pointer to your own function
- * to have it called.
- */
-typedef struct GameActivityCallbacks {
- /**
- * GameActivity has started. See Java documentation for Activity.onStart()
- * for more information.
- */
- void (*onStart)(GameActivity* activity);
-
- /**
- * GameActivity has resumed. See Java documentation for Activity.onResume()
- * for more information.
- */
- void (*onResume)(GameActivity* activity);
-
- /**
- * The framework is asking GameActivity to save its current instance state.
- * See the Java documentation for Activity.onSaveInstanceState() for more
- * information. The user should call the recallback with their data, its
- * length and the provided context; they retain ownership of the data. Note
- * that the saved state will be persisted, so it can not contain any active
- * entities (pointers to memory, file descriptors, etc).
- */
- void (*onSaveInstanceState)(GameActivity* activity,
- SaveInstanceStateRecallback recallback,
- void* context);
-
- /**
- * GameActivity has paused. See Java documentation for Activity.onPause()
- * for more information.
- */
- void (*onPause)(GameActivity* activity);
-
- /**
- * GameActivity has stopped. See Java documentation for Activity.onStop()
- * for more information.
- */
- void (*onStop)(GameActivity* activity);
-
- /**
- * GameActivity is being destroyed. See Java documentation for
- * Activity.onDestroy() for more information.
- */
- void (*onDestroy)(GameActivity* activity);
-
- /**
- * Focus has changed in this GameActivity's window. This is often used,
- * for example, to pause a game when it loses input focus.
- */
- void (*onWindowFocusChanged)(GameActivity* activity, bool hasFocus);
-
- /**
- * The drawing window for this native activity has been created. You
- * can use the given native window object to start drawing.
- */
- void (*onNativeWindowCreated)(GameActivity* activity,
- ANativeWindow* window);
-
- /**
- * The drawing window for this native activity has been resized. You should
- * retrieve the new size from the window and ensure that your rendering in
- * it now matches.
- */
- void (*onNativeWindowResized)(GameActivity* activity, ANativeWindow* window,
- int32_t newWidth, int32_t newHeight);
-
- /**
- * The drawing window for this native activity needs to be redrawn. To
- * avoid transient artifacts during screen changes (such resizing after
- * rotation), applications should not return from this function until they
- * have finished drawing their window in its current state.
- */
- void (*onNativeWindowRedrawNeeded)(GameActivity* activity,
- ANativeWindow* window);
-
- /**
- * The drawing window for this native activity is going to be destroyed.
- * You MUST ensure that you do not touch the window object after returning
- * from this function: in the common case of drawing to the window from
- * another thread, that means the implementation of this callback must
- * properly synchronize with the other thread to stop its drawing before
- * returning from here.
- */
- void (*onNativeWindowDestroyed)(GameActivity* activity,
- ANativeWindow* window);
-
- /**
- * The current device AConfiguration has changed. The new configuration can
- * be retrieved from assetManager.
- */
- void (*onConfigurationChanged)(GameActivity* activity);
-
- /**
- * The system is running low on memory. Use this callback to release
- * resources you do not need, to help the system avoid killing more
- * important processes.
- */
- void (*onTrimMemory)(GameActivity* activity, int level);
-
- /**
- * Callback called for every MotionEvent done on the GameActivity
- * SurfaceView. Ownership of `event` is maintained by the library and it is
- * only valid during the callback.
- */
- bool (*onTouchEvent)(GameActivity* activity,
- const GameActivityMotionEvent* event);
-
- /**
- * Callback called for every key down event on the GameActivity SurfaceView.
- * Ownership of `event` is maintained by the library and it is only valid
- * during the callback.
- */
- bool (*onKeyDown)(GameActivity* activity,
- const GameActivityKeyEvent* event);
-
- /**
- * Callback called for every key up event on the GameActivity SurfaceView.
- * Ownership of `event` is maintained by the library and it is only valid
- * during the callback.
- */
- bool (*onKeyUp)(GameActivity* activity, const GameActivityKeyEvent* event);
-
- /**
- * Callback called for every soft-keyboard text input event.
- * Ownership of `state` is maintained by the library and it is only valid
- * during the callback.
- */
- void (*onTextInputEvent)(GameActivity* activity,
- const GameTextInputState* state);
-
- /**
- * Callback called when WindowInsets of the main app window have changed.
- * Call GameActivity_getWindowInsets to retrieve the insets themselves.
- */
- void (*onWindowInsetsChanged)(GameActivity* activity);
-
- /**
- * Callback called when the rectangle in the window where the content
- * should be placed has changed.
- */
- void (*onContentRectChanged)(GameActivity *activity, const ARect *rect);
-} GameActivityCallbacks;
-
-/**
- * This is the function that must be in the native code to instantiate the
- * application's native activity. It is called with the activity instance (see
- * above); if the code is being instantiated from a previously saved instance,
- * the savedState will be non-NULL and point to the saved data. You must make
- * any copy of this data you need -- it will be released after you return from
- * this function.
- */
-typedef void GameActivity_createFunc(GameActivity* activity, void* savedState,
- size_t savedStateSize);
-
-/**
- * The name of the function that NativeInstance looks for when launching its
- * native code. This is the default function that is used, you can specify
- * "android.app.func_name" string meta-data in your manifest to use a different
- * function.
- */
-extern GameActivity_createFunc GameActivity_onCreate_C;
-
-/**
- * Finish the given activity. Its finish() method will be called, causing it
- * to be stopped and destroyed. Note that this method can be called from
- * *any* thread; it will send a message to the main thread of the process
- * where the Java finish call will take place.
- */
-void GameActivity_finish(GameActivity* activity);
-
-/**
- * Flags for GameActivity_setWindowFlags,
- * as per the Java API at android.view.WindowManager.LayoutParams.
- */
-enum GameActivitySetWindowFlags {
- /**
- * As long as this window is visible to the user, allow the lock
- * screen to activate while the screen is on. This can be used
- * independently, or in combination with {@link
- * GAMEACTIVITY_FLAG_KEEP_SCREEN_ON} and/or {@link
- * GAMEACTIVITY_FLAG_SHOW_WHEN_LOCKED}
- */
- GAMEACTIVITY_FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001,
- /** Everything behind this window will be dimmed. */
- GAMEACTIVITY_FLAG_DIM_BEHIND = 0x00000002,
- /**
- * Blur everything behind this window.
- * @deprecated Blurring is no longer supported.
- */
- GAMEACTIVITY_FLAG_BLUR_BEHIND = 0x00000004,
- /**
- * This window won't ever get key input focus, so the
- * user can not send key or other button events to it. Those will
- * instead go to whatever focusable window is behind it. This flag
- * will also enable {@link GAMEACTIVITY_FLAG_NOT_TOUCH_MODAL} whether or not
- * that is explicitly set.
- *
- * Setting this flag also implies that the window will not need to
- * interact with
- * a soft input method, so it will be Z-ordered and positioned
- * independently of any active input method (typically this means it
- * gets Z-ordered on top of the input method, so it can use the full
- * screen for its content and cover the input method if needed. You
- * can use {@link GAMEACTIVITY_FLAG_ALT_FOCUSABLE_IM} to modify this
- * behavior.
- */
- GAMEACTIVITY_FLAG_NOT_FOCUSABLE = 0x00000008,
- /** This window can never receive touch events. */
- GAMEACTIVITY_FLAG_NOT_TOUCHABLE = 0x00000010,
- /**
- * Even when this window is focusable (its
- * {@link GAMEACTIVITY_FLAG_NOT_FOCUSABLE} is not set), allow any pointer
- * events outside of the window to be sent to the windows behind it.
- * Otherwise it will consume all pointer events itself, regardless of
- * whether they are inside of the window.
- */
- GAMEACTIVITY_FLAG_NOT_TOUCH_MODAL = 0x00000020,
- /**
- * When set, if the device is asleep when the touch
- * screen is pressed, you will receive this first touch event. Usually
- * the first touch event is consumed by the system since the user can
- * not see what they are pressing on.
- *
- * @deprecated This flag has no effect.
- */
- GAMEACTIVITY_FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040,
- /**
- * As long as this window is visible to the user, keep
- * the device's screen turned on and bright.
- */
- GAMEACTIVITY_FLAG_KEEP_SCREEN_ON = 0x00000080,
- /**
- * Place the window within the entire screen, ignoring
- * decorations around the border (such as the status bar). The
- * window must correctly position its contents to take the screen
- * decoration into account.
- */
- GAMEACTIVITY_FLAG_LAYOUT_IN_SCREEN = 0x00000100,
- /** Allows the window to extend outside of the screen. */
- GAMEACTIVITY_FLAG_LAYOUT_NO_LIMITS = 0x00000200,
- /**
- * Hide all screen decorations (such as the status
- * bar) while this window is displayed. This allows the window to
- * use the entire display space for itself -- the status bar will
- * be hidden when an app window with this flag set is on the top
- * layer. A fullscreen window will ignore a value of {@link
- * GAMEACTIVITY_SOFT_INPUT_ADJUST_RESIZE}; the window will stay
- * fullscreen and will not resize.
- */
- GAMEACTIVITY_FLAG_FULLSCREEN = 0x00000400,
- /**
- * Override {@link GAMEACTIVITY_FLAG_FULLSCREEN} and force the
- * screen decorations (such as the status bar) to be shown.
- */
- GAMEACTIVITY_FLAG_FORCE_NOT_FULLSCREEN = 0x00000800,
- /**
- * Turn on dithering when compositing this window to
- * the screen.
- * @deprecated This flag is no longer used.
- */
- GAMEACTIVITY_FLAG_DITHER = 0x00001000,
- /**
- * Treat the content of the window as secure, preventing
- * it from appearing in screenshots or from being viewed on non-secure
- * displays.
- */
- GAMEACTIVITY_FLAG_SECURE = 0x00002000,
- /**
- * A special mode where the layout parameters are used
- * to perform scaling of the surface when it is composited to the
- * screen.
- */
- GAMEACTIVITY_FLAG_SCALED = 0x00004000,
- /**
- * Intended for windows that will often be used when the user is
- * holding the screen against their face, it will aggressively
- * filter the event stream to prevent unintended presses in this
- * situation that may not be desired for a particular window, when
- * such an event stream is detected, the application will receive
- * a {@link AMOTION_EVENT_ACTION_CANCEL} to indicate this so
- * applications can handle this accordingly by taking no action on
- * the event until the finger is released.
- */
- GAMEACTIVITY_FLAG_IGNORE_CHEEK_PRESSES = 0x00008000,
- /**
- * A special option only for use in combination with
- * {@link GAMEACTIVITY_FLAG_LAYOUT_IN_SCREEN}. When requesting layout in
- * the screen your window may appear on top of or behind screen decorations
- * such as the status bar. By also including this flag, the window
- * manager will report the inset rectangle needed to ensure your
- * content is not covered by screen decorations.
- */
- GAMEACTIVITY_FLAG_LAYOUT_INSET_DECOR = 0x00010000,
- /**
- * Invert the state of {@link GAMEACTIVITY_FLAG_NOT_FOCUSABLE} with
- * respect to how this window interacts with the current method.
- * That is, if FLAG_NOT_FOCUSABLE is set and this flag is set,
- * then the window will behave as if it needs to interact with the
- * input method and thus be placed behind/away from it; if {@link
- * GAMEACTIVITY_FLAG_NOT_FOCUSABLE} is not set and this flag is set,
- * then the window will behave as if it doesn't need to interact
- * with the input method and can be placed to use more space and
- * cover the input method.
- */
- GAMEACTIVITY_FLAG_ALT_FOCUSABLE_IM = 0x00020000,
- /**
- * If you have set {@link GAMEACTIVITY_FLAG_NOT_TOUCH_MODAL}, you
- * can set this flag to receive a single special MotionEvent with
- * the action
- * {@link AMOTION_EVENT_ACTION_OUTSIDE} for
- * touches that occur outside of your window. Note that you will not
- * receive the full down/move/up gesture, only the location of the
- * first down as an {@link AMOTION_EVENT_ACTION_OUTSIDE}.
- */
- GAMEACTIVITY_FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000,
- /**
- * Special flag to let windows be shown when the screen
- * is locked. This will let application windows take precedence over
- * key guard or any other lock screens. Can be used with
- * {@link GAMEACTIVITY_FLAG_KEEP_SCREEN_ON} to turn screen on and display
- * windows directly before showing the key guard window. Can be used with
- * {@link GAMEACTIVITY_FLAG_DISMISS_KEYGUARD} to automatically fully
- * dismisss non-secure keyguards. This flag only applies to the top-most
- * full-screen window.
- */
- GAMEACTIVITY_FLAG_SHOW_WHEN_LOCKED = 0x00080000,
- /**
- * Ask that the system wallpaper be shown behind
- * your window. The window surface must be translucent to be able
- * to actually see the wallpaper behind it; this flag just ensures
- * that the wallpaper surface will be there if this window actually
- * has translucent regions.
- */
- GAMEACTIVITY_FLAG_SHOW_WALLPAPER = 0x00100000,
- /**
- * When set as a window is being added or made
- * visible, once the window has been shown then the system will
- * poke the power manager's user activity (as if the user had woken
- * up the device) to turn the screen on.
- */
- GAMEACTIVITY_FLAG_TURN_SCREEN_ON = 0x00200000,
- /**
- * When set the window will cause the keyguard to
- * be dismissed, only if it is not a secure lock keyguard. Because such
- * a keyguard is not needed for security, it will never re-appear if
- * the user navigates to another window (in contrast to
- * {@link GAMEACTIVITY_FLAG_SHOW_WHEN_LOCKED}, which will only temporarily
- * hide both secure and non-secure keyguards but ensure they reappear
- * when the user moves to another UI that doesn't hide them).
- * If the keyguard is currently active and is secure (requires an
- * unlock pattern) than the user will still need to confirm it before
- * seeing this window, unless {@link GAMEACTIVITY_FLAG_SHOW_WHEN_LOCKED} has
- * also been set.
- */
- GAMEACTIVITY_FLAG_DISMISS_KEYGUARD = 0x00400000,
-};
-
-/**
- * Change the window flags of the given activity. Calls getWindow().setFlags()
- * of the given activity.
- * Note that some flags must be set before the window decoration is created,
- * see
- * https://developer.android.com/reference/android/view/Window#setFlags(int,%20int).
- * Note also that this method can be called from
- * *any* thread; it will send a message to the main thread of the process
- * where the Java finish call will take place.
- */
-void GameActivity_setWindowFlags(GameActivity* activity, uint32_t addFlags,
- uint32_t removeFlags);
-
-/**
- * Flags for GameActivity_showSoftInput; see the Java InputMethodManager
- * API for documentation.
- */
-enum GameActivityShowSoftInputFlags {
- /**
- * Implicit request to show the input window, not as the result
- * of a direct request by the user.
- */
- GAMEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT = 0x0001,
-
- /**
- * The user has forced the input method open (such as by
- * long-pressing menu) so it should not be closed until they
- * explicitly do so.
- */
- GAMEACTIVITY_SHOW_SOFT_INPUT_FORCED = 0x0002,
-};
-
-/**
- * Show the IME while in the given activity. Calls
- * InputMethodManager.showSoftInput() for the given activity. Note that this
- * method can be called from *any* thread; it will send a message to the main
- * thread of the process where the Java call will take place.
- */
-void GameActivity_showSoftInput(GameActivity* activity, uint32_t flags);
-
-/**
- * Set the text entry state (see documentation of the GameTextInputState struct
- * in the Game Text Input library reference).
- *
- * Ownership of the state is maintained by the caller.
- */
-void GameActivity_setTextInputState(GameActivity* activity,
- const GameTextInputState* state);
-
-/**
- * Get the last-received text entry state (see documentation of the
- * GameTextInputState struct in the Game Text Input library reference).
- *
- */
-void GameActivity_getTextInputState(GameActivity* activity,
- GameTextInputGetStateCallback callback,
- void* context);
-
-/**
- * Get a pointer to the GameTextInput library instance.
- */
-GameTextInput* GameActivity_getTextInput(const GameActivity* activity);
-
-/**
- * Flags for GameActivity_hideSoftInput; see the Java InputMethodManager
- * API for documentation.
- */
-enum GameActivityHideSoftInputFlags {
- /**
- * The soft input window should only be hidden if it was not
- * explicitly shown by the user.
- */
- GAMEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY = 0x0001,
- /**
- * The soft input window should normally be hidden, unless it was
- * originally shown with {@link GAMEACTIVITY_SHOW_SOFT_INPUT_FORCED}.
- */
- GAMEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS = 0x0002,
-};
-
-/**
- * Hide the IME while in the given activity. Calls
- * InputMethodManager.hideSoftInput() for the given activity. Note that this
- * method can be called from *any* thread; it will send a message to the main
- * thread of the process where the Java finish call will take place.
- */
-void GameActivity_hideSoftInput(GameActivity* activity, uint32_t flags);
-
-/**
- * Get the current window insets of the particular component. See
- * https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat.Type
- * for more details.
- * You can use these insets to influence what you show on the screen.
- */
-void GameActivity_getWindowInsets(GameActivity* activity,
- GameCommonInsetsType type, ARect* insets);
-
-/**
- * Set options on how the IME behaves when it is requested for text input.
- * See
- * https://developer.android.com/reference/android/view/inputmethod/EditorInfo
- * for the meaning of inputType, actionId and imeOptions.
- *
- * Note that this function will attach the current thread to the JVM if it is
- * not already attached, so the caller must detach the thread from the JVM
- * before the thread is destroyed using DetachCurrentThread.
- */
-void GameActivity_setImeEditorInfo(GameActivity* activity, int inputType,
- int actionId, int imeOptions);
-
-/**
- * These are getters for Configuration class members. They may be called from
- * any thread.
- */
-int GameActivity_getOrientation(GameActivity* activity);
-int GameActivity_getColorMode(GameActivity* activity);
-int GameActivity_getDensityDpi(GameActivity* activity);
-float GameActivity_getFontScale(GameActivity* activity);
-int GameActivity_getFontWeightAdjustment(GameActivity* activity);
-int GameActivity_getHardKeyboardHidden(GameActivity* activity);
-int GameActivity_getKeyboard(GameActivity* activity);
-int GameActivity_getKeyboardHidden(GameActivity* activity);
-int GameActivity_getMcc(GameActivity* activity);
-int GameActivity_getMnc(GameActivity* activity);
-int GameActivity_getNavigation(GameActivity* activity);
-int GameActivity_getNavigationHidden(GameActivity* activity);
-int GameActivity_getOrientation(GameActivity* activity);
-int GameActivity_getScreenHeightDp(GameActivity* activity);
-int GameActivity_getScreenLayout(GameActivity* activity);
-int GameActivity_getScreenWidthDp(GameActivity* activity);
-int GameActivity_getSmallestScreenWidthDp(GameActivity* activity);
-int GameActivity_getTouchscreen(GameActivity* activity);
-int GameActivity_getUIMode(GameActivity* activity);
-
-#ifdef __cplusplus
-}
-#endif
-
-/** @} */
-
-#endif // ANDROID_GAME_SDK_GAME_ACTIVITY_H
diff --git a/android-activity/game-activity-csrc/game-activity/GameActivityEvents.cpp b/android-activity/game-activity-csrc/game-activity/GameActivityEvents.cpp
deleted file mode 100644
index 028b55e..0000000
--- a/android-activity/game-activity-csrc/game-activity/GameActivityEvents.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "GameActivityEvents.h"
-
-#include
-
-#include
-
-#include "GameActivityLog.h"
-
-// TODO(b/187147166): these functions were extracted from the Game SDK
-// (gamesdk/src/common/system_utils.h). system_utils.h/cpp should be used
-// instead.
-namespace {
-
-std::string getSystemPropViaGet(const char *key,
- const char *default_value = "") {
- char buffer[PROP_VALUE_MAX + 1] = ""; // +1 for terminator
- int bufferLen = __system_property_get(key, buffer);
- if (bufferLen > 0)
- return buffer;
- else
- return "";
-}
-
-std::string GetSystemProp(const char *key, const char *default_value = "") {
- return getSystemPropViaGet(key, default_value);
-}
-
-int GetSystemPropAsInt(const char *key, int default_value = 0) {
- std::string prop = GetSystemProp(key);
- return prop == "" ? default_value : strtoll(prop.c_str(), nullptr, 10);
-}
-
-} // anonymous namespace
-
-#ifndef NELEM
-#define NELEM(x) ((int)(sizeof(x) / sizeof((x)[0])))
-#endif
-
-static bool enabledAxes[GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT] = {
- /* AMOTION_EVENT_AXIS_X */ true,
- /* AMOTION_EVENT_AXIS_Y */ true,
- // Disable all other axes by default (they can be enabled using
- // `GameActivityPointerAxes_enableAxis`).
- false};
-
-extern "C" void GameActivityPointerAxes_enableAxis(int32_t axis) {
- if (axis < 0 || axis >= GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT) {
- return;
- }
-
- enabledAxes[axis] = true;
-}
-
-float GameActivityPointerAxes_getAxisValue(
- const GameActivityPointerAxes *pointerInfo, int32_t axis) {
- if (axis < 0 || axis >= GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT) {
- return 0;
- }
-
- if (!enabledAxes[axis]) {
- ALOGW("Axis %d must be enabled before it can be accessed.", axis);
- return 0;
- }
-
- return pointerInfo->axisValues[axis];
-}
-
-extern "C" void GameActivityPointerAxes_disableAxis(int32_t axis) {
- if (axis < 0 || axis >= GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT) {
- return;
- }
-
- enabledAxes[axis] = false;
-}
-
-float GameActivityMotionEvent_getHistoricalAxisValue(
- const GameActivityMotionEvent *event, int axis, int pointerIndex,
- int historyPos) {
- if (axis < 0 || axis >= GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT) {
- ALOGE("Invalid axis %d", axis);
- return -1;
- }
- if (pointerIndex < 0 || pointerIndex >= event->pointerCount) {
- ALOGE("Invalid pointer index %d", pointerIndex);
- return -1;
- }
- if (historyPos < 0 || historyPos >= event->historySize) {
- ALOGE("Invalid history index %d", historyPos);
- return -1;
- }
- if (!enabledAxes[axis]) {
- ALOGW("Axis %d must be enabled before it can be accessed.", axis);
- return 0;
- }
-
- int pointerOffset = pointerIndex * GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
- int historyValuesOffset = historyPos * event->pointerCount *
- GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
- return event
- ->historicalAxisValues[historyValuesOffset + pointerOffset + axis];
-}
-
-static struct {
- jmethodID getDeviceId;
- jmethodID getSource;
- jmethodID getAction;
-
- jmethodID getEventTime;
- jmethodID getDownTime;
-
- jmethodID getFlags;
- jmethodID getMetaState;
-
- jmethodID getActionButton;
- jmethodID getButtonState;
- jmethodID getClassification;
- jmethodID getEdgeFlags;
-
- jmethodID getHistorySize;
- jmethodID getHistoricalEventTime;
-
- jmethodID getPointerCount;
- jmethodID getPointerId;
-
- jmethodID getToolType;
-
- jmethodID getRawX;
- jmethodID getRawY;
- jmethodID getXPrecision;
- jmethodID getYPrecision;
- jmethodID getAxisValue;
-
- jmethodID getHistoricalAxisValue;
-} gMotionEventClassInfo;
-
-extern "C" void GameActivityMotionEvent_destroy(
- GameActivityMotionEvent *c_event) {
- delete c_event->historicalAxisValues;
- delete c_event->historicalEventTimesMillis;
- delete c_event->historicalEventTimesNanos;
-}
-
-extern "C" void GameActivityMotionEvent_fromJava(
- JNIEnv *env, jobject motionEvent, GameActivityMotionEvent *out_event) {
- static bool gMotionEventClassInfoInitialized = false;
- if (!gMotionEventClassInfoInitialized) {
- int sdkVersion = GetSystemPropAsInt("ro.build.version.sdk");
- gMotionEventClassInfo = {0};
- jclass motionEventClass = env->FindClass("android/view/MotionEvent");
- gMotionEventClassInfo.getDeviceId =
- env->GetMethodID(motionEventClass, "getDeviceId", "()I");
- gMotionEventClassInfo.getSource =
- env->GetMethodID(motionEventClass, "getSource", "()I");
- gMotionEventClassInfo.getAction =
- env->GetMethodID(motionEventClass, "getAction", "()I");
- gMotionEventClassInfo.getEventTime =
- env->GetMethodID(motionEventClass, "getEventTime", "()J");
- gMotionEventClassInfo.getDownTime =
- env->GetMethodID(motionEventClass, "getDownTime", "()J");
- gMotionEventClassInfo.getFlags =
- env->GetMethodID(motionEventClass, "getFlags", "()I");
- gMotionEventClassInfo.getMetaState =
- env->GetMethodID(motionEventClass, "getMetaState", "()I");
- if (sdkVersion >= 23) {
- gMotionEventClassInfo.getActionButton =
- env->GetMethodID(motionEventClass, "getActionButton", "()I");
- }
- if (sdkVersion >= 14) {
- gMotionEventClassInfo.getButtonState =
- env->GetMethodID(motionEventClass, "getButtonState", "()I");
- }
- if (sdkVersion >= 29) {
- gMotionEventClassInfo.getClassification =
- env->GetMethodID(motionEventClass, "getClassification", "()I");
- }
- gMotionEventClassInfo.getEdgeFlags =
- env->GetMethodID(motionEventClass, "getEdgeFlags", "()I");
-
- gMotionEventClassInfo.getHistorySize =
- env->GetMethodID(motionEventClass, "getHistorySize", "()I");
- gMotionEventClassInfo.getHistoricalEventTime = env->GetMethodID(
- motionEventClass, "getHistoricalEventTime", "(I)J");
-
- gMotionEventClassInfo.getPointerCount =
- env->GetMethodID(motionEventClass, "getPointerCount", "()I");
- gMotionEventClassInfo.getPointerId =
- env->GetMethodID(motionEventClass, "getPointerId", "(I)I");
- gMotionEventClassInfo.getToolType =
- env->GetMethodID(motionEventClass, "getToolType", "(I)I");
- if (sdkVersion >= 29) {
- gMotionEventClassInfo.getRawX =
- env->GetMethodID(motionEventClass, "getRawX", "(I)F");
- gMotionEventClassInfo.getRawY =
- env->GetMethodID(motionEventClass, "getRawY", "(I)F");
- }
- gMotionEventClassInfo.getXPrecision =
- env->GetMethodID(motionEventClass, "getXPrecision", "()F");
- gMotionEventClassInfo.getYPrecision =
- env->GetMethodID(motionEventClass, "getYPrecision", "()F");
- gMotionEventClassInfo.getAxisValue =
- env->GetMethodID(motionEventClass, "getAxisValue", "(II)F");
-
- gMotionEventClassInfo.getHistoricalAxisValue = env->GetMethodID(
- motionEventClass, "getHistoricalAxisValue", "(III)F");
- gMotionEventClassInfoInitialized = true;
- }
-
- int pointerCount =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getPointerCount);
- pointerCount =
- std::min(pointerCount, GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT);
- out_event->pointerCount = pointerCount;
- for (int i = 0; i < pointerCount; ++i) {
- out_event->pointers[i] = {
- /*id=*/env->CallIntMethod(motionEvent,
- gMotionEventClassInfo.getPointerId, i),
- /*toolType=*/
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getToolType,
- i),
- /*axisValues=*/{0},
- /*rawX=*/gMotionEventClassInfo.getRawX
- ? env->CallFloatMethod(motionEvent,
- gMotionEventClassInfo.getRawX, i)
- : 0,
- /*rawY=*/gMotionEventClassInfo.getRawY
- ? env->CallFloatMethod(motionEvent,
- gMotionEventClassInfo.getRawY, i)
- : 0,
- };
-
- for (int axisIndex = 0;
- axisIndex < GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT; ++axisIndex) {
- if (enabledAxes[axisIndex]) {
- out_event->pointers[i].axisValues[axisIndex] =
- env->CallFloatMethod(motionEvent,
- gMotionEventClassInfo.getAxisValue,
- axisIndex, i);
- }
- }
- }
-
- int historySize =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getHistorySize);
- out_event->historySize = historySize;
- out_event->historicalAxisValues =
- new float[historySize * pointerCount *
- GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT];
- out_event->historicalEventTimesMillis = new int64_t[historySize];
- out_event->historicalEventTimesNanos = new int64_t[historySize];
-
- for (int historyIndex = 0; historyIndex < historySize; historyIndex++) {
- out_event->historicalEventTimesMillis[historyIndex] =
- env->CallLongMethod(motionEvent,
- gMotionEventClassInfo.getHistoricalEventTime,
- historyIndex);
- out_event->historicalEventTimesNanos[historyIndex] =
- out_event->historicalEventTimesMillis[historyIndex] * 1000000;
- for (int i = 0; i < pointerCount; ++i) {
- int pointerOffset = i * GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
- int historyAxisOffset = historyIndex * pointerCount *
- GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
- float *axisValues =
- &out_event
- ->historicalAxisValues[historyAxisOffset + pointerOffset];
- for (int axisIndex = 0;
- axisIndex < GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT;
- ++axisIndex) {
- if (enabledAxes[axisIndex]) {
- axisValues[axisIndex] = env->CallFloatMethod(
- motionEvent,
- gMotionEventClassInfo.getHistoricalAxisValue, axisIndex,
- i, historyIndex);
- }
- }
- }
- }
-
- out_event->deviceId =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getDeviceId);
- out_event->source =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getSource);
- out_event->action =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getAction);
- out_event->eventTime =
- env->CallLongMethod(motionEvent, gMotionEventClassInfo.getEventTime) *
- 1000000;
- out_event->downTime =
- env->CallLongMethod(motionEvent, gMotionEventClassInfo.getDownTime) *
- 1000000;
- out_event->flags =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getFlags);
- out_event->metaState =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getMetaState);
- out_event->actionButton =
- gMotionEventClassInfo.getActionButton
- ? env->CallIntMethod(motionEvent,
- gMotionEventClassInfo.getActionButton)
- : 0;
- out_event->buttonState =
- gMotionEventClassInfo.getButtonState
- ? env->CallIntMethod(motionEvent,
- gMotionEventClassInfo.getButtonState)
- : 0;
- out_event->classification =
- gMotionEventClassInfo.getClassification
- ? env->CallIntMethod(motionEvent,
- gMotionEventClassInfo.getClassification)
- : 0;
- out_event->edgeFlags =
- env->CallIntMethod(motionEvent, gMotionEventClassInfo.getEdgeFlags);
- out_event->precisionX =
- env->CallFloatMethod(motionEvent, gMotionEventClassInfo.getXPrecision);
- out_event->precisionY =
- env->CallFloatMethod(motionEvent, gMotionEventClassInfo.getYPrecision);
-}
-
-static struct {
- jmethodID getDeviceId;
- jmethodID getSource;
- jmethodID getAction;
-
- jmethodID getEventTime;
- jmethodID getDownTime;
-
- jmethodID getFlags;
- jmethodID getMetaState;
-
- jmethodID getModifiers;
- jmethodID getRepeatCount;
- jmethodID getKeyCode;
- jmethodID getScanCode;
- //jmethodID getUnicodeChar;
-} gKeyEventClassInfo;
-
-extern "C" void GameActivityKeyEvent_fromJava(JNIEnv *env, jobject keyEvent,
- GameActivityKeyEvent *out_event) {
- static bool gKeyEventClassInfoInitialized = false;
- if (!gKeyEventClassInfoInitialized) {
- int sdkVersion = GetSystemPropAsInt("ro.build.version.sdk");
- gKeyEventClassInfo = {0};
- jclass keyEventClass = env->FindClass("android/view/KeyEvent");
- gKeyEventClassInfo.getDeviceId =
- env->GetMethodID(keyEventClass, "getDeviceId", "()I");
- gKeyEventClassInfo.getSource =
- env->GetMethodID(keyEventClass, "getSource", "()I");
- gKeyEventClassInfo.getAction =
- env->GetMethodID(keyEventClass, "getAction", "()I");
- gKeyEventClassInfo.getEventTime =
- env->GetMethodID(keyEventClass, "getEventTime", "()J");
- gKeyEventClassInfo.getDownTime =
- env->GetMethodID(keyEventClass, "getDownTime", "()J");
- gKeyEventClassInfo.getFlags =
- env->GetMethodID(keyEventClass, "getFlags", "()I");
- gKeyEventClassInfo.getMetaState =
- env->GetMethodID(keyEventClass, "getMetaState", "()I");
- if (sdkVersion >= 13) {
- gKeyEventClassInfo.getModifiers =
- env->GetMethodID(keyEventClass, "getModifiers", "()I");
- }
- gKeyEventClassInfo.getRepeatCount =
- env->GetMethodID(keyEventClass, "getRepeatCount", "()I");
- gKeyEventClassInfo.getKeyCode =
- env->GetMethodID(keyEventClass, "getKeyCode", "()I");
- gKeyEventClassInfo.getScanCode =
- env->GetMethodID(keyEventClass, "getScanCode", "()I");
- //gKeyEventClassInfo.getUnicodeChar =
- // env->GetMethodID(keyEventClass, "getUnicodeChar", "()I");
-
- gKeyEventClassInfoInitialized = true;
- }
-
- *out_event = {
- /*deviceId=*/env->CallIntMethod(keyEvent,
- gKeyEventClassInfo.getDeviceId),
- /*source=*/env->CallIntMethod(keyEvent, gKeyEventClassInfo.getSource),
- /*action=*/env->CallIntMethod(keyEvent, gKeyEventClassInfo.getAction),
- // TODO: introduce a millisecondsToNanoseconds helper:
- /*eventTime=*/
- env->CallLongMethod(keyEvent, gKeyEventClassInfo.getEventTime) *
- 1000000,
- /*downTime=*/
- env->CallLongMethod(keyEvent, gKeyEventClassInfo.getDownTime) * 1000000,
- /*flags=*/env->CallIntMethod(keyEvent, gKeyEventClassInfo.getFlags),
- /*metaState=*/
- env->CallIntMethod(keyEvent, gKeyEventClassInfo.getMetaState),
- /*modifiers=*/gKeyEventClassInfo.getModifiers
- ? env->CallIntMethod(keyEvent, gKeyEventClassInfo.getModifiers)
- : 0,
- /*repeatCount=*/
- env->CallIntMethod(keyEvent, gKeyEventClassInfo.getRepeatCount),
- /*keyCode=*/
- env->CallIntMethod(keyEvent, gKeyEventClassInfo.getKeyCode),
- /*scanCode=*/
- env->CallIntMethod(keyEvent, gKeyEventClassInfo.getScanCode)
- /*unicodeChar=*/
- //env->CallIntMethod(keyEvent, gKeyEventClassInfo.getUnicodeChar)
- };
-}
diff --git a/android-activity/game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.c b/android-activity/game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.c
deleted file mode 100644
index a7bcb85..0000000
--- a/android-activity/game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.c
+++ /dev/null
@@ -1,732 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "android_native_app_glue.h"
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#define NATIVE_APP_GLUE_MOTION_EVENTS_DEFAULT_BUF_SIZE 16
-#define NATIVE_APP_GLUE_KEY_EVENTS_DEFAULT_BUF_SIZE 4
-
-#define LOGI(...) \
- ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
-#define LOGE(...) \
- ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
-#define LOGW(...) \
- ((void)__android_log_print(ANDROID_LOG_WARN, "threaded_app", __VA_ARGS__))
-#define LOGW_ONCE(...) \
- do { \
- static bool alogw_once##__FILE__##__LINE__##__ = true; \
- if (alogw_once##__FILE__##__LINE__##__) { \
- alogw_once##__FILE__##__LINE__##__ = false; \
- LOGW(__VA_ARGS__); \
- } \
- } while (0)
-
-/* For debug builds, always enable the debug traces in this library */
-#ifndef NDEBUG
-#define LOGV(...) \
- ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", \
- __VA_ARGS__))
-#else
-#define LOGV(...) ((void)0)
-#endif
-
-static void free_saved_state(struct android_app* android_app) {
- pthread_mutex_lock(&android_app->mutex);
- if (android_app->savedState != NULL) {
- free(android_app->savedState);
- android_app->savedState = NULL;
- android_app->savedStateSize = 0;
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-int8_t android_app_read_cmd(struct android_app* android_app) {
- int8_t cmd;
- if (read(android_app->msgread, &cmd, sizeof(cmd)) != sizeof(cmd)) {
- LOGE("No data on command pipe!");
- return -1;
- }
- if (cmd == APP_CMD_SAVE_STATE) free_saved_state(android_app);
- return cmd;
-}
-
-static void print_cur_config(struct android_app* android_app) {
- char lang[2], country[2];
- AConfiguration_getLanguage(android_app->config, lang);
- AConfiguration_getCountry(android_app->config, country);
-
- LOGV(
- "Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
- "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
- "modetype=%d modenight=%d",
- AConfiguration_getMcc(android_app->config),
- AConfiguration_getMnc(android_app->config), lang[0], lang[1],
- country[0], country[1],
- AConfiguration_getOrientation(android_app->config),
- AConfiguration_getTouchscreen(android_app->config),
- AConfiguration_getDensity(android_app->config),
- AConfiguration_getKeyboard(android_app->config),
- AConfiguration_getNavigation(android_app->config),
- AConfiguration_getKeysHidden(android_app->config),
- AConfiguration_getNavHidden(android_app->config),
- AConfiguration_getSdkVersion(android_app->config),
- AConfiguration_getScreenSize(android_app->config),
- AConfiguration_getScreenLong(android_app->config),
- AConfiguration_getUiModeType(android_app->config),
- AConfiguration_getUiModeNight(android_app->config));
-}
-
-void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
- switch (cmd) {
- case UNUSED_APP_CMD_INPUT_CHANGED:
- LOGV("UNUSED_APP_CMD_INPUT_CHANGED");
- // Do nothing. This can be used in the future to handle AInputQueue
- // natively, like done in NativeActivity.
- break;
-
- case APP_CMD_INIT_WINDOW:
- LOGV("APP_CMD_INIT_WINDOW");
- pthread_mutex_lock(&android_app->mutex);
- android_app->window = android_app->pendingWindow;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_TERM_WINDOW:
- LOGV("APP_CMD_TERM_WINDOW");
- pthread_cond_broadcast(&android_app->cond);
- break;
-
- case APP_CMD_RESUME:
- case APP_CMD_START:
- case APP_CMD_PAUSE:
- case APP_CMD_STOP:
- LOGV("activityState=%d", cmd);
- pthread_mutex_lock(&android_app->mutex);
- android_app->activityState = cmd;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_CONFIG_CHANGED:
- LOGV("APP_CMD_CONFIG_CHANGED");
- AConfiguration_fromAssetManager(
- android_app->config, android_app->activity->assetManager);
- print_cur_config(android_app);
- break;
-
- case APP_CMD_DESTROY:
- LOGV("APP_CMD_DESTROY");
- android_app->destroyRequested = 1;
- break;
- }
-}
-
-void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
- switch (cmd) {
- case APP_CMD_TERM_WINDOW:
- LOGV("APP_CMD_TERM_WINDOW");
- pthread_mutex_lock(&android_app->mutex);
- android_app->window = NULL;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_SAVE_STATE:
- LOGV("APP_CMD_SAVE_STATE");
- pthread_mutex_lock(&android_app->mutex);
- android_app->stateSaved = 1;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_RESUME:
- free_saved_state(android_app);
- break;
- }
-}
-
-void app_dummy() {}
-
-static void android_app_destroy(struct android_app* android_app) {
- LOGV("android_app_destroy!");
- free_saved_state(android_app);
- pthread_mutex_lock(&android_app->mutex);
-
- AConfiguration_delete(android_app->config);
- android_app->destroyed = 1;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- // Can't touch android_app object after this.
-}
-
-static void process_cmd(struct android_app* app,
- struct android_poll_source* source) {
- int8_t cmd = android_app_read_cmd(app);
- android_app_pre_exec_cmd(app, cmd);
- if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
- android_app_post_exec_cmd(app, cmd);
-}
-
-// This is run on a separate thread (i.e: not the main thread).
-static void* android_app_entry(void* param) {
- struct android_app* android_app = (struct android_app*)param;
- int input_buf_idx = 0;
-
- LOGV("android_app_entry called");
- android_app->config = AConfiguration_new();
- LOGV("android_app = %p", android_app);
- LOGV("config = %p", android_app->config);
- LOGV("activity = %p", android_app->activity);
- LOGV("assetmanager = %p", android_app->activity->assetManager);
- AConfiguration_fromAssetManager(android_app->config,
- android_app->activity->assetManager);
-
- print_cur_config(android_app);
-
- /* initialize event buffers */
- for (input_buf_idx = 0; input_buf_idx < NATIVE_APP_GLUE_MAX_INPUT_BUFFERS; input_buf_idx++) {
- struct android_input_buffer *buf = &android_app->inputBuffers[input_buf_idx];
-
- buf->motionEventsBufferSize = NATIVE_APP_GLUE_MOTION_EVENTS_DEFAULT_BUF_SIZE;
- buf->motionEvents = (GameActivityMotionEvent *) malloc(sizeof(GameActivityMotionEvent) *
- buf->motionEventsBufferSize);
-
- buf->keyEventsBufferSize = NATIVE_APP_GLUE_KEY_EVENTS_DEFAULT_BUF_SIZE;
- buf->keyEvents = (GameActivityKeyEvent *) malloc(sizeof(GameActivityKeyEvent) *
- buf->keyEventsBufferSize);
- }
-
- android_app->cmdPollSource.id = LOOPER_ID_MAIN;
- android_app->cmdPollSource.app = android_app;
- android_app->cmdPollSource.process = process_cmd;
-
- ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
- ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN,
- ALOOPER_EVENT_INPUT, NULL, &android_app->cmdPollSource);
- android_app->looper = looper;
-
- pthread_mutex_lock(&android_app->mutex);
- android_app->running = 1;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
-
- _rust_glue_entry(android_app);
-
- android_app_destroy(android_app);
- return NULL;
-}
-
-// Codes from https://developer.android.com/reference/android/view/KeyEvent
-#define KEY_EVENT_KEYCODE_VOLUME_DOWN 25
-#define KEY_EVENT_KEYCODE_VOLUME_MUTE 164
-#define KEY_EVENT_KEYCODE_VOLUME_UP 24
-#define KEY_EVENT_KEYCODE_CAMERA 27
-#define KEY_EVENT_KEYCODE_ZOOM_IN 168
-#define KEY_EVENT_KEYCODE_ZOOM_OUT 169
-
-// Double-buffer the key event filter to avoid race condition.
-static bool default_key_filter(const GameActivityKeyEvent* event) {
- // Ignore camera, volume, etc. buttons
- return !(event->keyCode == KEY_EVENT_KEYCODE_VOLUME_DOWN ||
- event->keyCode == KEY_EVENT_KEYCODE_VOLUME_MUTE ||
- event->keyCode == KEY_EVENT_KEYCODE_VOLUME_UP ||
- event->keyCode == KEY_EVENT_KEYCODE_CAMERA ||
- event->keyCode == KEY_EVENT_KEYCODE_ZOOM_IN ||
- event->keyCode == KEY_EVENT_KEYCODE_ZOOM_OUT);
-}
-
-// See
-// https://developer.android.com/reference/android/view/InputDevice#SOURCE_TOUCHSCREEN
-#define SOURCE_TOUCHSCREEN 0x00001002
-
-static bool default_motion_filter(const GameActivityMotionEvent* event) {
- // Ignore any non-touch events.
- return event->source == SOURCE_TOUCHSCREEN;
-}
-
-// --------------------------------------------------------------------
-// Native activity interaction (called from main thread)
-// --------------------------------------------------------------------
-
-static struct android_app* android_app_create(GameActivity* activity,
- void* savedState,
- size_t savedStateSize) {
- // struct android_app* android_app = calloc(1, sizeof(struct android_app));
- struct android_app* android_app =
- (struct android_app*)malloc(sizeof(struct android_app));
- memset(android_app, 0, sizeof(struct android_app));
- android_app->activity = activity;
-
- pthread_mutex_init(&android_app->mutex, NULL);
- pthread_cond_init(&android_app->cond, NULL);
-
- if (savedState != NULL) {
- android_app->savedState = malloc(savedStateSize);
- android_app->savedStateSize = savedStateSize;
- memcpy(android_app->savedState, savedState, savedStateSize);
- }
-
- int msgpipe[2];
- if (pipe(msgpipe)) {
- LOGE("could not create pipe: %s", strerror(errno));
- return NULL;
- }
- android_app->msgread = msgpipe[0];
- android_app->msgwrite = msgpipe[1];
-
- android_app->keyEventFilter = default_key_filter;
- android_app->motionEventFilter = default_motion_filter;
-
- LOGV("Launching android_app_entry in a thread");
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
-
- // Wait for thread to start.
- pthread_mutex_lock(&android_app->mutex);
- while (!android_app->running) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-
- return android_app;
-}
-
-static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
- if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
- LOGE("Failure writing android_app cmd: %s", strerror(errno));
- }
-}
-
-static void android_app_set_window(struct android_app* android_app,
- ANativeWindow* window) {
- LOGV("android_app_set_window called");
- pthread_mutex_lock(&android_app->mutex);
-
- // NB: we have to consider that the native thread could have already
- // (gracefully) exit (setting android_app->destroyed) and so we need
- // to be careful to avoid a deadlock waiting for a thread that's
- // already exit.
- if (android_app->destroyed) {
- pthread_mutex_unlock(&android_app->mutex);
- return;
- }
- if (android_app->pendingWindow != NULL) {
- android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
- }
- android_app->pendingWindow = window;
- if (window != NULL) {
- android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
- }
- while (android_app->window != android_app->pendingWindow) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void android_app_set_activity_state(struct android_app* android_app,
- int8_t cmd) {
- pthread_mutex_lock(&android_app->mutex);
-
- // NB: we have to consider that the native thread could have already
- // (gracefully) exit (setting android_app->destroyed) and so we need
- // to be careful to avoid a deadlock waiting for a thread that's
- // already exit.
- if (!android_app->destroyed) {
- android_app_write_cmd(android_app, cmd);
- while (android_app->activityState != cmd) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void android_app_free(struct android_app* android_app) {
- int input_buf_idx = 0;
-
- pthread_mutex_lock(&android_app->mutex);
-
- // It's possible that onDestroy is called after we have already 'destroyed'
- // the app (via `android_app_destroy` due to `android_main` returning.
- //
- // In this case `->destroyed` will already be set (so we won't deadlock in
- // the loop below) but we still need to close the messaging fds and finish
- // freeing the android_app
-
- android_app_write_cmd(android_app, APP_CMD_DESTROY);
- while (!android_app->destroyed) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-
- for (input_buf_idx = 0; input_buf_idx < NATIVE_APP_GLUE_MAX_INPUT_BUFFERS; input_buf_idx++) {
- struct android_input_buffer *buf = &android_app->inputBuffers[input_buf_idx];
-
- android_app_clear_motion_events(buf);
- free(buf->motionEvents);
- free(buf->keyEvents);
- }
-
- close(android_app->msgread);
- close(android_app->msgwrite);
- pthread_cond_destroy(&android_app->cond);
- pthread_mutex_destroy(&android_app->mutex);
- free(android_app);
-}
-
-static inline struct android_app* ToApp(GameActivity* activity) {
- return (struct android_app*)activity->instance;
-}
-
-static void onDestroy(GameActivity* activity) {
- LOGV("Destroy: %p", activity);
- android_app_free(ToApp(activity));
-}
-
-static void onStart(GameActivity* activity) {
- LOGV("Start: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_START);
-}
-
-static void onResume(GameActivity* activity) {
- LOGV("Resume: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_RESUME);
-}
-
-static void onSaveInstanceState(GameActivity* activity,
- SaveInstanceStateRecallback recallback,
- void* context) {
- LOGV("SaveInstanceState: %p", activity);
-
- struct android_app* android_app = ToApp(activity);
- pthread_mutex_lock(&android_app->mutex);
-
- // NB: we have to consider that the native thread could have already
- // (gracefully) exit (setting android_app->destroyed) and so we need
- // to be careful to avoid a deadlock waiting for a thread that's
- // already exit.
- if (android_app->destroyed) {
- pthread_mutex_unlock(&android_app->mutex);
- return;
- }
-
- android_app->stateSaved = 0;
- android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
- while (!android_app->stateSaved) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
-
- if (android_app->savedState != NULL) {
- // Tell the Java side about our state.
- recallback((const char*)android_app->savedState,
- android_app->savedStateSize, context);
- // Now we can free it.
- free(android_app->savedState);
- android_app->savedState = NULL;
- android_app->savedStateSize = 0;
- }
-
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void onPause(GameActivity* activity) {
- LOGV("Pause: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_PAUSE);
-}
-
-static void onStop(GameActivity* activity) {
- LOGV("Stop: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_STOP);
-}
-
-static void onConfigurationChanged(GameActivity* activity) {
- LOGV("ConfigurationChanged: %p", activity);
- android_app_write_cmd(ToApp(activity), APP_CMD_CONFIG_CHANGED);
-}
-
-static void onTrimMemory(GameActivity* activity, int level) {
- LOGV("TrimMemory: %p %d", activity, level);
- android_app_write_cmd(ToApp(activity), APP_CMD_LOW_MEMORY);
-}
-
-static void onWindowFocusChanged(GameActivity* activity, bool focused) {
- LOGV("WindowFocusChanged: %p -- %d", activity, focused);
- android_app_write_cmd(ToApp(activity),
- focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
-}
-
-static void onNativeWindowCreated(GameActivity* activity,
- ANativeWindow* window) {
- LOGV("NativeWindowCreated: %p -- %p", activity, window);
- android_app_set_window(ToApp(activity), window);
-}
-
-static void onNativeWindowDestroyed(GameActivity* activity,
- ANativeWindow* window) {
- LOGV("NativeWindowDestroyed: %p -- %p", activity, window);
- android_app_set_window(ToApp(activity), NULL);
-}
-
-static void onNativeWindowRedrawNeeded(GameActivity* activity,
- ANativeWindow* window) {
- LOGV("NativeWindowRedrawNeeded: %p -- %p", activity, window);
- android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_REDRAW_NEEDED);
-}
-
-static void onNativeWindowResized(GameActivity* activity, ANativeWindow* window,
- int32_t width, int32_t height) {
- LOGV("NativeWindowResized: %p -- %p ( %d x %d )", activity, window, width,
- height);
- android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_RESIZED);
-}
-
-void android_app_set_motion_event_filter(struct android_app* app,
- android_motion_event_filter filter) {
- pthread_mutex_lock(&app->mutex);
- app->motionEventFilter = filter;
- pthread_mutex_unlock(&app->mutex);
-}
-
-bool android_app_input_available_wake_up(struct android_app* app) {
- pthread_mutex_lock(&app->mutex);
- bool available = app->inputAvailableWakeUp;
- app->inputAvailableWakeUp = false;
- pthread_mutex_unlock(&app->mutex);
- return available;
-}
-
-// NB: should be called with the android_app->mutex held already
-static void notifyInput(struct android_app* android_app) {
- // Don't spam the mainloop with wake ups if we've already sent one
- if (android_app->inputSwapPending) {
- return;
- }
-
- if (android_app->looper != NULL) {
- // for the app thread to know why it received the wake() up
- android_app->inputAvailableWakeUp = true;
- android_app->inputSwapPending = true;
- ALooper_wake(android_app->looper);
- }
-}
-
-static bool onTouchEvent(GameActivity* activity,
- const GameActivityMotionEvent* event) {
- struct android_app* android_app = ToApp(activity);
- pthread_mutex_lock(&android_app->mutex);
-
- // NB: we have to consider that the native thread could have already
- // (gracefully) exit (setting android_app->destroyed) and so we need
- // to be careful to avoid a deadlock waiting for a thread that's
- // already exit.
- if (android_app->destroyed) {
- pthread_mutex_unlock(&android_app->mutex);
- return false;
- }
-
- if (android_app->motionEventFilter != NULL &&
- !android_app->motionEventFilter(event)) {
- pthread_mutex_unlock(&android_app->mutex);
- return false;
- }
-
- struct android_input_buffer* inputBuffer =
- &android_app->inputBuffers[android_app->currentInputBuffer];
-
- // Add to the list of active motion events
- if (inputBuffer->motionEventsCount >= inputBuffer->motionEventsBufferSize) {
- inputBuffer->motionEventsBufferSize *= 2;
- inputBuffer->motionEvents = (GameActivityMotionEvent *) realloc(inputBuffer->motionEvents,
- sizeof(GameActivityMotionEvent) * inputBuffer->motionEventsBufferSize);
-
- if (inputBuffer->motionEvents == NULL) {
- LOGE("onTouchEvent: out of memory");
- abort();
- }
- }
-
- int new_ix = inputBuffer->motionEventsCount;
- memcpy(&inputBuffer->motionEvents[new_ix], event, sizeof(GameActivityMotionEvent));
- ++inputBuffer->motionEventsCount;
- notifyInput(android_app);
-
- pthread_mutex_unlock(&android_app->mutex);
- return true;
-}
-
-struct android_input_buffer* android_app_swap_input_buffers(
- struct android_app* android_app) {
- pthread_mutex_lock(&android_app->mutex);
-
- struct android_input_buffer* inputBuffer =
- &android_app->inputBuffers[android_app->currentInputBuffer];
-
- if (inputBuffer->motionEventsCount == 0 &&
- inputBuffer->keyEventsCount == 0) {
- inputBuffer = NULL;
- } else {
- android_app->currentInputBuffer =
- (android_app->currentInputBuffer + 1) %
- NATIVE_APP_GLUE_MAX_INPUT_BUFFERS;
- }
-
- android_app->inputSwapPending = false;
- android_app->inputAvailableWakeUp = false;
-
- pthread_mutex_unlock(&android_app->mutex);
-
- return inputBuffer;
-}
-
-void android_app_clear_motion_events(struct android_input_buffer* inputBuffer) {
- // We do not need to lock here if the inputBuffer has already been swapped
- // as is handled by the game loop thread
- while (inputBuffer->motionEventsCount > 0) {
- GameActivityMotionEvent_destroy(
- &inputBuffer->motionEvents[inputBuffer->motionEventsCount - 1]);
-
- inputBuffer->motionEventsCount--;
- }
- assert(inputBuffer->motionEventsCount == 0);
-}
-
-void android_app_set_key_event_filter(struct android_app* app,
- android_key_event_filter filter) {
- pthread_mutex_lock(&app->mutex);
- app->keyEventFilter = filter;
- pthread_mutex_unlock(&app->mutex);
-}
-
-static bool onKey(GameActivity* activity, const GameActivityKeyEvent* event) {
- struct android_app* android_app = ToApp(activity);
- pthread_mutex_lock(&android_app->mutex);
-
- // NB: we have to consider that the native thread could have already
- // (gracefully) exit (setting android_app->destroyed) and so we need
- // to be careful to avoid a deadlock waiting for a thread that's
- // already exit.
- if (android_app->destroyed) {
- pthread_mutex_unlock(&android_app->mutex);
- return false;
- }
-
- if (android_app->keyEventFilter != NULL &&
- !android_app->keyEventFilter(event)) {
- pthread_mutex_unlock(&android_app->mutex);
- return false;
- }
-
- struct android_input_buffer* inputBuffer =
- &android_app->inputBuffers[android_app->currentInputBuffer];
-
- // Add to the list of active key down events
- if (inputBuffer->keyEventsCount >= inputBuffer->keyEventsBufferSize) {
- inputBuffer->keyEventsBufferSize = inputBuffer->keyEventsBufferSize * 2;
- inputBuffer->keyEvents = (GameActivityKeyEvent *) realloc(inputBuffer->keyEvents,
- sizeof(GameActivityKeyEvent) * inputBuffer->keyEventsBufferSize);
-
- if (inputBuffer->keyEvents == NULL) {
- LOGE("onKey: out of memory");
- abort();
- }
- }
-
- int new_ix = inputBuffer->keyEventsCount;
- memcpy(&inputBuffer->keyEvents[new_ix], event, sizeof(GameActivityKeyEvent));
- ++inputBuffer->keyEventsCount;
- notifyInput(android_app);
-
- pthread_mutex_unlock(&android_app->mutex);
- return true;
-}
-
-void android_app_clear_key_events(struct android_input_buffer* inputBuffer) {
- inputBuffer->keyEventsCount = 0;
-}
-
-static void onTextInputEvent(GameActivity* activity,
- const GameTextInputState* state) {
- struct android_app* android_app = ToApp(activity);
- pthread_mutex_lock(&android_app->mutex);
- if (!android_app->destroyed) {
- android_app->textInputState = 1;
- notifyInput(android_app);
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void onWindowInsetsChanged(GameActivity* activity) {
- LOGV("WindowInsetsChanged: %p", activity);
- android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_INSETS_CHANGED);
-}
-
-static void onContentRectChanged(GameActivity* activity, const ARect *rect) {
- LOGV("ContentRectChanged: %p -- (%d %d) (%d %d)", activity, rect->left, rect->top,
- rect->right, rect->bottom);
-
- struct android_app* android_app = ToApp(activity);
-
- pthread_mutex_lock(&android_app->mutex);
- android_app->contentRect = *rect;
-
- android_app_write_cmd(android_app, APP_CMD_CONTENT_RECT_CHANGED);
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-// XXX: This symbol is renamed with a _C suffix and then re-exported from
-// Rust because Rust/Cargo don't give us a way to directly export symbols
-// from C/C++ code: https://github.com/rust-lang/rfcs/issues/2771
-//
-JNIEXPORT
-void GameActivity_onCreate_C(GameActivity* activity, void* savedState,
- size_t savedStateSize) {
- LOGV("Creating: %p", activity);
- activity->callbacks->onDestroy = onDestroy;
- activity->callbacks->onStart = onStart;
- activity->callbacks->onResume = onResume;
- activity->callbacks->onSaveInstanceState = onSaveInstanceState;
- activity->callbacks->onPause = onPause;
- activity->callbacks->onStop = onStop;
- activity->callbacks->onTouchEvent = onTouchEvent;
- activity->callbacks->onKeyDown = onKey;
- activity->callbacks->onKeyUp = onKey;
- activity->callbacks->onTextInputEvent = onTextInputEvent;
- activity->callbacks->onConfigurationChanged = onConfigurationChanged;
- activity->callbacks->onTrimMemory = onTrimMemory;
- activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
- activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
- activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
- activity->callbacks->onNativeWindowRedrawNeeded =
- onNativeWindowRedrawNeeded;
- activity->callbacks->onNativeWindowResized = onNativeWindowResized;
- activity->callbacks->onWindowInsetsChanged = onWindowInsetsChanged;
- activity->callbacks->onContentRectChanged = onContentRectChanged;
- LOGV("Callbacks set: %p", activity->callbacks);
-
- activity->instance =
- android_app_create(activity, savedState, savedStateSize);
-}
diff --git a/android-activity/game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.h b/android-activity/game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.h
deleted file mode 100644
index 6fa5721..0000000
--- a/android-activity/game-activity-csrc/game-activity/native_app_glue/android_native_app_glue.h
+++ /dev/null
@@ -1,507 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-/**
- * @addtogroup android_native_app_glue Native App Glue library
- * The glue library to interface your game loop with GameActivity.
- * @{
- */
-
-#include
-#include
-#include
-#include
-#include
-
-#include "game-activity/GameActivity.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * The GameActivity interface provided by
- * is based on a set of application-provided callbacks that will be called
- * by the Activity's main thread when certain events occur.
- *
- * This means that each one of this callbacks _should_ _not_ block, or they
- * risk having the system force-close the application. This programming
- * model is direct, lightweight, but constraining.
- *
- * The 'android_native_app_glue' static library is used to provide a different
- * execution model where the application can implement its own main event
- * loop in a different thread instead. Here's how it works:
- *
- * 1/ The application must provide a function named "android_main()" that
- * will be called when the activity is created, in a new thread that is
- * distinct from the activity's main thread.
- *
- * 2/ android_main() receives a pointer to a valid "android_app" structure
- * that contains references to other important objects, e.g. the
- * GameActivity obejct instance the application is running in.
- *
- * 3/ the "android_app" object holds an ALooper instance that already
- * listens to activity lifecycle events (e.g. "pause", "resume").
- * See APP_CMD_XXX declarations below.
- *
- * This corresponds to an ALooper identifier returned by
- * ALooper_pollOnce with value LOOPER_ID_MAIN.
- *
- * Your application can use the same ALooper to listen to additional
- * file-descriptors. They can either be callback based, or with return
- * identifiers starting with LOOPER_ID_USER.
- *
- * 4/ Whenever you receive a LOOPER_ID_MAIN event,
- * the returned data will point to an android_poll_source structure. You
- * can call the process() function on it, and fill in android_app->onAppCmd
- * to be called for your own processing of the event.
- *
- * Alternatively, you can call the low-level functions to read and process
- * the data directly... look at the process_cmd() and process_input()
- * implementations in the glue to see how to do this.
- *
- * See the sample named "native-activity" that comes with the NDK with a
- * full usage example. Also look at the documentation of GameActivity.
- */
-
-struct android_app;
-
-/**
- * Data associated with an ALooper fd that will be returned as the "outData"
- * when that source has data ready.
- */
-struct android_poll_source {
- /**
- * The identifier of this source. May be LOOPER_ID_MAIN or
- * LOOPER_ID_INPUT.
- */
- int32_t id;
-
- /** The android_app this ident is associated with. */
- struct android_app* app;
-
- /**
- * Function to call to perform the standard processing of data from
- * this source.
- */
- void (*process)(struct android_app* app,
- struct android_poll_source* source);
-};
-
-struct android_input_buffer {
- /**
- * Pointer to a read-only array of GameActivityMotionEvent.
- * Only the first motionEventsCount events are valid.
- */
- GameActivityMotionEvent *motionEvents;
-
- /**
- * The number of valid motion events in `motionEvents`.
- */
- uint64_t motionEventsCount;
-
- /**
- * The size of the `motionEvents` buffer.
- */
- uint64_t motionEventsBufferSize;
-
- /**
- * Pointer to a read-only array of GameActivityKeyEvent.
- * Only the first keyEventsCount events are valid.
- */
- GameActivityKeyEvent *keyEvents;
-
- /**
- * The number of valid "Key" events in `keyEvents`.
- */
- uint64_t keyEventsCount;
-
- /**
- * The size of the `keyEvents` buffer.
- */
- uint64_t keyEventsBufferSize;
-};
-
-/**
- * Function pointer declaration for the filtering of key events.
- * A function with this signature should be passed to
- * android_app_set_key_event_filter and return false for any events that should
- * not be handled by android_native_app_glue. These events will be handled by
- * the system instead.
- */
-typedef bool (*android_key_event_filter)(const GameActivityKeyEvent*);
-
-/**
- * Function pointer definition for the filtering of motion events.
- * A function with this signature should be passed to
- * android_app_set_motion_event_filter and return false for any events that
- * should not be handled by android_native_app_glue. These events will be
- * handled by the system instead.
- */
-typedef bool (*android_motion_event_filter)(const GameActivityMotionEvent*);
-
-/**
- * This is the interface for the standard glue code of a threaded
- * application. In this model, the application's code is running
- * in its own thread separate from the main thread of the process.
- * It is not required that this thread be associated with the Java
- * VM, although it will need to be in order to make JNI calls any
- * Java objects.
- */
-struct android_app {
- /**
- * An optional pointer to application-defined state.
- */
- void* userData;
-
- /**
- * A required callback for processing main app commands (`APP_CMD_*`).
- * This is called each frame if there are app commands that need processing.
- */
- void (*onAppCmd)(struct android_app* app, int32_t cmd);
-
- /** The GameActivity object instance that this app is running in. */
- GameActivity* activity;
-
- /** The current configuration the app is running in. */
- AConfiguration* config;
-
- /**
- * The last activity saved state, as provided at creation time.
- * It is NULL if there was no state. You can use this as you need; the
- * memory will remain around until you call android_app_exec_cmd() for
- * APP_CMD_RESUME, at which point it will be freed and savedState set to
- * NULL. These variables should only be changed when processing a
- * APP_CMD_SAVE_STATE, at which point they will be initialized to NULL and
- * you can malloc your state and place the information here. In that case
- * the memory will be freed for you later.
- */
- void* savedState;
-
- /**
- * The size of the activity saved state. It is 0 if `savedState` is NULL.
- */
- size_t savedStateSize;
-
- /** The ALooper associated with the app's thread. */
- ALooper* looper;
-
- /** When non-NULL, this is the window surface that the app can draw in. */
- ANativeWindow* window;
-
- /**
- * Current content rectangle of the window; this is the area where the
- * window's content should be placed to be seen by the user.
- */
- ARect contentRect;
-
- /**
- * Current state of the app's activity. May be either APP_CMD_START,
- * APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP.
- */
- int activityState;
-
- /**
- * This is non-zero when the application's GameActivity is being
- * destroyed and waiting for the app thread to complete.
- */
- int destroyRequested;
-
-#define NATIVE_APP_GLUE_MAX_INPUT_BUFFERS 2
-
- /**
- * This is used for buffering input from GameActivity. Once ready, the
- * application thread switches the buffers and processes what was
- * accumulated.
- */
- struct android_input_buffer inputBuffers[NATIVE_APP_GLUE_MAX_INPUT_BUFFERS];
-
- int currentInputBuffer;
-
- /**
- * 0 if no text input event is outstanding, 1 if it is.
- * Use `GameActivity_getTextInputState` to get information
- * about the text entered by the user.
- */
- int textInputState;
-
- // Below are "private" implementation of the glue code.
- /** @cond INTERNAL */
-
- pthread_mutex_t mutex;
- pthread_cond_t cond;
-
- int msgread;
- int msgwrite;
-
- pthread_t thread;
-
- struct android_poll_source cmdPollSource;
-
- int running;
- int stateSaved;
- int destroyed;
- int redrawNeeded;
- ANativeWindow* pendingWindow;
- ARect pendingContentRect;
-
- android_key_event_filter keyEventFilter;
- android_motion_event_filter motionEventFilter;
-
- // When new input is received we set both of these flags and use the looper to
- // wake up the application mainloop.
- //
- // To avoid spamming the mainloop with wake ups from lots of input though we
- // don't sent a wake up if the inputSwapPending flag is already set. (i.e.
- // we already expect input to be processed in a finite amount of time due to
- // our previous wake up)
- //
- // When a wake up is received then we will check this flag (clearing it
- // at the same time). If it was set then an InputAvailable event is sent to
- // the application - which should lead to all input being processed within
- // a finite amount of time.
- //
- // The next time android_app_swap_input_buffers is called, both flags will be
- // cleared.
- //
- // NB: both of these should only be read with the app mutex held
- bool inputAvailableWakeUp;
- bool inputSwapPending;
-
- /** @endcond */
-};
-
-/**
- * Looper ID of commands coming from the app's main thread, an AInputQueue or
- * user-defined sources.
- */
-enum NativeAppGlueLooperId {
- /**
- * Looper data ID of commands coming from the app's main thread, which
- * is returned as an identifier from ALooper_pollOnce(). The data for this
- * identifier is a pointer to an android_poll_source structure.
- * These can be retrieved and processed with android_app_read_cmd()
- * and android_app_exec_cmd().
- */
- LOOPER_ID_MAIN = 1,
-
- /**
- * Unused. Reserved for future use when usage of AInputQueue will be
- * supported.
- */
- LOOPER_ID_INPUT = 2,
-
- /**
- * Start of user-defined ALooper identifiers.
- */
- LOOPER_ID_USER = 3,
-};
-
-/**
- * Commands passed from the application's main Java thread to the game's thread.
- */
-enum NativeAppGlueAppCmd {
- /**
- * Unused. Reserved for future use when usage of AInputQueue will be
- * supported.
- */
- UNUSED_APP_CMD_INPUT_CHANGED,
-
- /**
- * Command from main thread: a new ANativeWindow is ready for use. Upon
- * receiving this command, android_app->window will contain the new window
- * surface.
- */
- APP_CMD_INIT_WINDOW,
-
- /**
- * Command from main thread: the existing ANativeWindow needs to be
- * terminated. Upon receiving this command, android_app->window still
- * contains the existing window; after calling android_app_exec_cmd
- * it will be set to NULL.
- */
- APP_CMD_TERM_WINDOW,
-
- /**
- * Command from main thread: the current ANativeWindow has been resized.
- * Please redraw with its new size.
- */
- APP_CMD_WINDOW_RESIZED,
-
- /**
- * Command from main thread: the system needs that the current ANativeWindow
- * be redrawn. You should redraw the window before handing this to
- * android_app_exec_cmd() in order to avoid transient drawing glitches.
- */
- APP_CMD_WINDOW_REDRAW_NEEDED,
-
- /**
- * Command from main thread: the content area of the window has changed,
- * such as from the soft input window being shown or hidden. You can
- * find the new content rect in android_app::contentRect.
- */
- APP_CMD_CONTENT_RECT_CHANGED,
-
- /**
- * Command from main thread: the app's activity window has gained
- * input focus.
- */
- APP_CMD_GAINED_FOCUS,
-
- /**
- * Command from main thread: the app's activity window has lost
- * input focus.
- */
- APP_CMD_LOST_FOCUS,
-
- /**
- * Command from main thread: the current device configuration has changed.
- */
- APP_CMD_CONFIG_CHANGED,
-
- /**
- * Command from main thread: the system is running low on memory.
- * Try to reduce your memory use.
- */
- APP_CMD_LOW_MEMORY,
-
- /**
- * Command from main thread: the app's activity has been started.
- */
- APP_CMD_START,
-
- /**
- * Command from main thread: the app's activity has been resumed.
- */
- APP_CMD_RESUME,
-
- /**
- * Command from main thread: the app should generate a new saved state
- * for itself, to restore from later if needed. If you have saved state,
- * allocate it with malloc and place it in android_app.savedState with
- * the size in android_app.savedStateSize. The will be freed for you
- * later.
- */
- APP_CMD_SAVE_STATE,
-
- /**
- * Command from main thread: the app's activity has been paused.
- */
- APP_CMD_PAUSE,
-
- /**
- * Command from main thread: the app's activity has been stopped.
- */
- APP_CMD_STOP,
-
- /**
- * Command from main thread: the app's activity is being destroyed,
- * and waiting for the app thread to clean up and exit before proceeding.
- */
- APP_CMD_DESTROY,
-
- /**
- * Command from main thread: the app's insets have changed.
- */
- APP_CMD_WINDOW_INSETS_CHANGED,
-
-};
-
-/**
- * Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
- * app command message.
- */
-int8_t android_app_read_cmd(struct android_app* android_app);
-
-/**
- * Call with the command returned by android_app_read_cmd() to do the
- * initial pre-processing of the given command. You can perform your own
- * actions for the command after calling this function.
- */
-void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
-
-/**
- * Call with the command returned by android_app_read_cmd() to do the
- * final post-processing of the given command. You must have done your own
- * actions for the command before calling this function.
- */
-void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
-
-/**
- * Call this before processing input events to get the events buffer.
- * The function returns NULL if there are no events to process.
- */
-struct android_input_buffer* android_app_swap_input_buffers(
- struct android_app* android_app);
-
-/**
- * Clear the array of motion events that were waiting to be handled, and release
- * each of them.
- *
- * This method should be called after you have processed the motion events in
- * your game loop. You should handle events at each iteration of your game loop.
- */
-void android_app_clear_motion_events(struct android_input_buffer* inputBuffer);
-
-/**
- * Clear the array of key events that were waiting to be handled, and release
- * each of them.
- *
- * This method should be called after you have processed the key up events in
- * your game loop. You should handle events at each iteration of your game loop.
- */
-void android_app_clear_key_events(struct android_input_buffer* inputBuffer);
-
-/**
- * This is a springboard into the Rust glue layer that wraps calling the
- * main entry for the app itself.
- */
-extern void _rust_glue_entry(struct android_app* app);
-
-/**
- * Set the filter to use when processing key events.
- * Any events for which the filter returns false will be ignored by
- * android_native_app_glue. If filter is set to NULL, no filtering is done.
- *
- * The default key filter will filter out volume and camera button presses.
- */
-void android_app_set_key_event_filter(struct android_app* app,
- android_key_event_filter filter);
-
-/**
- * Set the filter to use when processing touch and motion events.
- * Any events for which the filter returns false will be ignored by
- * android_native_app_glue. If filter is set to NULL, no filtering is done.
- *
- * Note that the default motion event filter will only allow touchscreen events
- * through, in order to mimic NativeActivity's behaviour, so for controller
- * events to be passed to the app, set the filter to NULL.
- */
-void android_app_set_motion_event_filter(struct android_app* app,
- android_motion_event_filter filter);
-
-/**
- * Determines if a looper wake up was due to new input becoming available
- */
-bool android_app_input_available_wake_up(struct android_app* app);
-
-#ifdef __cplusplus
-}
-#endif
-
-/** @} */
diff --git a/android-activity/game-activity-csrc/game-text-input/gamecommon.h b/android-activity/game-activity-csrc/game-text-input/gamecommon.h
deleted file mode 100755
index 38bffff..0000000
--- a/android-activity/game-activity-csrc/game-text-input/gamecommon.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @defgroup game_common Game Common
- * Common structures and functions used within AGDK
- * @{
- */
-
-#pragma once
-
-/**
- * The type of a component for which to retrieve insets. See
- * https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat.Type
- */
-typedef enum GameCommonInsetsType {
- GAMECOMMON_INSETS_TYPE_CAPTION_BAR = 0,
- GAMECOMMON_INSETS_TYPE_DISPLAY_CUTOUT,
- GAMECOMMON_INSETS_TYPE_IME,
- GAMECOMMON_INSETS_TYPE_MANDATORY_SYSTEM_GESTURES,
- GAMECOMMON_INSETS_TYPE_NAVIGATION_BARS,
- GAMECOMMON_INSETS_TYPE_STATUS_BARS,
- GAMECOMMON_INSETS_TYPE_SYSTEM_BARS,
- GAMECOMMON_INSETS_TYPE_SYSTEM_GESTURES,
- GAMECOMMON_INSETS_TYPE_TAPABLE_ELEMENT,
- GAMECOMMON_INSETS_TYPE_WATERFALL,
- GAMECOMMON_INSETS_TYPE_COUNT
-} GameCommonInsetsType;
diff --git a/android-activity/game-activity-csrc/game-text-input/gametextinput.cpp b/android-activity/game-activity-csrc/game-text-input/gametextinput.cpp
deleted file mode 100755
index b8244fb..0000000
--- a/android-activity/game-activity-csrc/game-text-input/gametextinput.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "game-text-input/gametextinput.h"
-
-#include
-#include
-#include
-#include
-
-#include
-#include
-#include
-
-#define LOG_TAG "GameTextInput"
-
-static constexpr int32_t DEFAULT_MAX_STRING_SIZE = 1 << 16;
-
-// Cache of field ids in the Java GameTextInputState class
-struct StateClassInfo {
- jfieldID text;
- jfieldID selectionStart;
- jfieldID selectionEnd;
- jfieldID composingRegionStart;
- jfieldID composingRegionEnd;
-};
-
-// Main GameTextInput object.
-struct GameTextInput {
- public:
- GameTextInput(JNIEnv *env, uint32_t max_string_size);
- ~GameTextInput();
- void setState(const GameTextInputState &state);
- const GameTextInputState &getState() const { return currentState_; }
- void setInputConnection(jobject inputConnection);
- void processEvent(jobject textInputEvent);
- void showIme(uint32_t flags);
- void hideIme(uint32_t flags);
- void restartInput();
- void setEventCallback(GameTextInputEventCallback callback, void *context);
- jobject stateToJava(const GameTextInputState &state) const;
- void stateFromJava(jobject textInputEvent,
- GameTextInputGetStateCallback callback,
- void *context) const;
- void setImeInsetsCallback(GameTextInputImeInsetsCallback callback,
- void *context);
- void processImeInsets(const ARect *insets);
- const ARect &getImeInsets() const { return currentInsets_; }
-
- private:
- // Copy string and set other fields
- void setStateInner(const GameTextInputState &state);
- static void processCallback(void *context, const GameTextInputState *state);
- JNIEnv *env_ = nullptr;
- // Cached at initialization from
- // com/google/androidgamesdk/gametextinput/State.
- jclass stateJavaClass_ = nullptr;
- // The latest text input update.
- GameTextInputState currentState_ = {};
- // An instance of gametextinput.InputConnection.
- jclass inputConnectionClass_ = nullptr;
- jobject inputConnection_ = nullptr;
- jmethodID inputConnectionSetStateMethod_;
- jmethodID setSoftKeyboardActiveMethod_;
- jmethodID restartInputMethod_;
- void (*eventCallback_)(void *context,
- const struct GameTextInputState *state) = nullptr;
- void *eventCallbackContext_ = nullptr;
- void (*insetsCallback_)(void *context,
- const struct ARect *insets) = nullptr;
- ARect currentInsets_ = {};
- void *insetsCallbackContext_ = nullptr;
- StateClassInfo stateClassInfo_ = {};
- // Constant-sized buffer used to store state text.
- std::vector stateStringBuffer_;
-};
-
-std::unique_ptr s_gameTextInput;
-
-extern "C" {
-
-///////////////////////////////////////////////////////////
-/// GameTextInputState C Functions
-///////////////////////////////////////////////////////////
-
-// Convert to a Java structure.
-jobject currentState_toJava(const GameTextInput *gameTextInput,
- const GameTextInputState *state) {
- if (state == nullptr) return NULL;
- return gameTextInput->stateToJava(*state);
-}
-
-// Convert from Java structure.
-void currentState_fromJava(const GameTextInput *gameTextInput,
- jobject textInputEvent,
- GameTextInputGetStateCallback callback,
- void *context) {
- gameTextInput->stateFromJava(textInputEvent, callback, context);
-}
-
-///////////////////////////////////////////////////////////
-/// GameTextInput C Functions
-///////////////////////////////////////////////////////////
-
-struct GameTextInput *GameTextInput_init(JNIEnv *env,
- uint32_t max_string_size) {
- if (s_gameTextInput.get() != nullptr) {
- __android_log_print(ANDROID_LOG_WARN, LOG_TAG,
- "Warning: called GameTextInput_init twice without "
- "calling GameTextInput_destroy");
- return s_gameTextInput.get();
- }
- // Don't use make_unique, for C++11 compatibility
- s_gameTextInput =
- std::unique_ptr(new GameTextInput(env, max_string_size));
- return s_gameTextInput.get();
-}
-
-void GameTextInput_destroy(GameTextInput *input) {
- if (input == nullptr || s_gameTextInput.get() == nullptr) return;
- s_gameTextInput.reset();
-}
-
-void GameTextInput_setState(GameTextInput *input,
- const GameTextInputState *state) {
- if (state == nullptr) return;
- input->setState(*state);
-}
-
-void GameTextInput_getState(GameTextInput *input,
- GameTextInputGetStateCallback callback,
- void *context) {
- callback(context, &input->getState());
-}
-
-void GameTextInput_setInputConnection(GameTextInput *input,
- jobject inputConnection) {
- input->setInputConnection(inputConnection);
-}
-
-void GameTextInput_processEvent(GameTextInput *input, jobject textInputEvent) {
- input->processEvent(textInputEvent);
-}
-
-void GameTextInput_processImeInsets(GameTextInput *input, const ARect *insets) {
- input->processImeInsets(insets);
-}
-
-void GameTextInput_showIme(struct GameTextInput *input, uint32_t flags) {
- input->showIme(flags);
-}
-
-void GameTextInput_hideIme(struct GameTextInput *input, uint32_t flags) {
- input->hideIme(flags);
-}
-
-void GameTextInput_restartInput(struct GameTextInput *input) {
- input->restartInput();
-}
-
-void GameTextInput_setEventCallback(struct GameTextInput *input,
- GameTextInputEventCallback callback,
- void *context) {
- input->setEventCallback(callback, context);
-}
-
-void GameTextInput_setImeInsetsCallback(struct GameTextInput *input,
- GameTextInputImeInsetsCallback callback,
- void *context) {
- input->setImeInsetsCallback(callback, context);
-}
-
-void GameTextInput_getImeInsets(const GameTextInput *input, ARect *insets) {
- *insets = input->getImeInsets();
-}
-
-} // extern "C"
-
-///////////////////////////////////////////////////////////
-/// GameTextInput C++ class Implementation
-///////////////////////////////////////////////////////////
-
-GameTextInput::GameTextInput(JNIEnv *env, uint32_t max_string_size)
- : env_(env),
- stateStringBuffer_(max_string_size == 0 ? DEFAULT_MAX_STRING_SIZE
- : max_string_size) {
- stateJavaClass_ = (jclass)env_->NewGlobalRef(
- env_->FindClass("com/google/androidgamesdk/gametextinput/State"));
- inputConnectionClass_ = (jclass)env_->NewGlobalRef(env_->FindClass(
- "com/google/androidgamesdk/gametextinput/InputConnection"));
- inputConnectionSetStateMethod_ =
- env_->GetMethodID(inputConnectionClass_, "setState",
- "(Lcom/google/androidgamesdk/gametextinput/State;)V");
- setSoftKeyboardActiveMethod_ = env_->GetMethodID(
- inputConnectionClass_, "setSoftKeyboardActive", "(ZI)V");
- restartInputMethod_ =
- env_->GetMethodID(inputConnectionClass_, "restartInput", "()V");
-
- stateClassInfo_.text =
- env_->GetFieldID(stateJavaClass_, "text", "Ljava/lang/String;");
- stateClassInfo_.selectionStart =
- env_->GetFieldID(stateJavaClass_, "selectionStart", "I");
- stateClassInfo_.selectionEnd =
- env_->GetFieldID(stateJavaClass_, "selectionEnd", "I");
- stateClassInfo_.composingRegionStart =
- env_->GetFieldID(stateJavaClass_, "composingRegionStart", "I");
- stateClassInfo_.composingRegionEnd =
- env_->GetFieldID(stateJavaClass_, "composingRegionEnd", "I");
-}
-
-GameTextInput::~GameTextInput() {
- if (stateJavaClass_ != NULL) {
- env_->DeleteGlobalRef(stateJavaClass_);
- stateJavaClass_ = NULL;
- }
- if (inputConnectionClass_ != NULL) {
- env_->DeleteGlobalRef(inputConnectionClass_);
- inputConnectionClass_ = NULL;
- }
- if (inputConnection_ != NULL) {
- env_->DeleteGlobalRef(inputConnection_);
- inputConnection_ = NULL;
- }
-}
-
-void GameTextInput::setState(const GameTextInputState &state) {
- if (inputConnection_ == nullptr) return;
- jobject jstate = stateToJava(state);
- env_->CallVoidMethod(inputConnection_, inputConnectionSetStateMethod_,
- jstate);
- env_->DeleteLocalRef(jstate);
- setStateInner(state);
-}
-
-void GameTextInput::setStateInner(const GameTextInputState &state) {
- // Check if we're setting using our own string (other parts may be
- // different)
- if (state.text_UTF8 == currentState_.text_UTF8) {
- currentState_ = state;
- return;
- }
- // Otherwise, copy across the string.
- auto bytes_needed =
- std::min(static_cast(state.text_length + 1),
- static_cast(stateStringBuffer_.size()));
- currentState_.text_UTF8 = stateStringBuffer_.data();
- std::copy(state.text_UTF8, state.text_UTF8 + bytes_needed - 1,
- stateStringBuffer_.data());
- currentState_.text_length = state.text_length;
- currentState_.selection = state.selection;
- currentState_.composingRegion = state.composingRegion;
- stateStringBuffer_[bytes_needed - 1] = 0;
-}
-
-void GameTextInput::setInputConnection(jobject inputConnection) {
- if (inputConnection_ != NULL) {
- env_->DeleteGlobalRef(inputConnection_);
- }
- inputConnection_ = env_->NewGlobalRef(inputConnection);
-}
-
-/*static*/ void GameTextInput::processCallback(
- void *context, const GameTextInputState *state) {
- auto thiz = static_cast(context);
- if (state != nullptr) thiz->setStateInner(*state);
-}
-
-void GameTextInput::processEvent(jobject textInputEvent) {
- stateFromJava(textInputEvent, processCallback, this);
- if (eventCallback_) {
- eventCallback_(eventCallbackContext_, ¤tState_);
- }
-}
-
-void GameTextInput::showIme(uint32_t flags) {
- if (inputConnection_ == nullptr) return;
- env_->CallVoidMethod(inputConnection_, setSoftKeyboardActiveMethod_, true,
- flags);
-}
-
-void GameTextInput::setEventCallback(GameTextInputEventCallback callback,
- void *context) {
- eventCallback_ = callback;
- eventCallbackContext_ = context;
-}
-
-void GameTextInput::setImeInsetsCallback(
- GameTextInputImeInsetsCallback callback, void *context) {
- insetsCallback_ = callback;
- insetsCallbackContext_ = context;
-}
-
-void GameTextInput::processImeInsets(const ARect *insets) {
- currentInsets_ = *insets;
- if (insetsCallback_) {
- insetsCallback_(insetsCallbackContext_, ¤tInsets_);
- }
-}
-
-void GameTextInput::hideIme(uint32_t flags) {
- if (inputConnection_ == nullptr) return;
- env_->CallVoidMethod(inputConnection_, setSoftKeyboardActiveMethod_, false,
- flags);
-}
-
-void GameTextInput::restartInput() {
- if (inputConnection_ == nullptr) return;
- env_->CallVoidMethod(inputConnection_, restartInputMethod_, false);
-}
-
-jobject GameTextInput::stateToJava(const GameTextInputState &state) const {
- static jmethodID constructor = nullptr;
- if (constructor == nullptr) {
- constructor = env_->GetMethodID(stateJavaClass_, "",
- "(Ljava/lang/String;IIII)V");
- if (constructor == nullptr) {
- __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
- "Can't find gametextinput.State constructor");
- return nullptr;
- }
- }
- const char *text = state.text_UTF8;
- if (text == nullptr) {
- static char empty_string[] = "";
- text = empty_string;
- }
- // Note that this expects 'modified' UTF-8 which is not the same as UTF-8
- // https://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8
- jstring jtext = env_->NewStringUTF(text);
- jobject jobj =
- env_->NewObject(stateJavaClass_, constructor, jtext,
- state.selection.start, state.selection.end,
- state.composingRegion.start, state.composingRegion.end);
- env_->DeleteLocalRef(jtext);
- return jobj;
-}
-
-void GameTextInput::stateFromJava(jobject textInputEvent,
- GameTextInputGetStateCallback callback,
- void *context) const {
- jstring text =
- (jstring)env_->GetObjectField(textInputEvent, stateClassInfo_.text);
- // Note this is 'modified' UTF-8, not true UTF-8. It has no NULLs in it,
- // except at the end. It's actually not specified whether the value returned
- // by GetStringUTFChars includes a null at the end, but it *seems to* on
- // Android.
- const char *text_chars = env_->GetStringUTFChars(text, NULL);
- int text_len = env_->GetStringUTFLength(
- text); // Length in bytes, *not* including the null.
- int selectionStart =
- env_->GetIntField(textInputEvent, stateClassInfo_.selectionStart);
- int selectionEnd =
- env_->GetIntField(textInputEvent, stateClassInfo_.selectionEnd);
- int composingRegionStart =
- env_->GetIntField(textInputEvent, stateClassInfo_.composingRegionStart);
- int composingRegionEnd =
- env_->GetIntField(textInputEvent, stateClassInfo_.composingRegionEnd);
- GameTextInputState state{text_chars,
- text_len,
- {selectionStart, selectionEnd},
- {composingRegionStart, composingRegionEnd}};
- callback(context, &state);
- env_->ReleaseStringUTFChars(text, text_chars);
- env_->DeleteLocalRef(text);
-}
diff --git a/android-activity/game-activity-csrc/game-text-input/gametextinput.h b/android-activity/game-activity-csrc/game-text-input/gametextinput.h
deleted file mode 100755
index 8c33da5..0000000
--- a/android-activity/game-activity-csrc/game-text-input/gametextinput.h
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @defgroup game_text_input Game Text Input
- * The interface to use GameTextInput.
- * @{
- */
-
-#pragma once
-
-#include
-#include
-#include
-
-#include "common/gamesdk_common.h"
-#include "gamecommon.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define GAMETEXTINPUT_MAJOR_VERSION 2
-#define GAMETEXTINPUT_MINOR_VERSION 0
-#define GAMETEXTINPUT_BUGFIX_VERSION 0
-#define GAMETEXTINPUT_PACKED_VERSION \
- ANDROID_GAMESDK_PACKED_VERSION(GAMETEXTINPUT_MAJOR_VERSION, \
- GAMETEXTINPUT_MINOR_VERSION, \
- GAMETEXTINPUT_BUGFIX_VERSION)
-
-/**
- * This struct holds a span within a region of text from start (inclusive) to
- * end (exclusive). An empty span or cursor position is specified with
- * start==end. An undefined span is specified with start = end = SPAN_UNDEFINED.
- */
-typedef struct GameTextInputSpan {
- /** The start of the region (inclusive). */
- int32_t start;
- /** The end of the region (exclusive). */
- int32_t end;
-} GameTextInputSpan;
-
-/**
- * Values with special meaning in a GameTextInputSpan.
- */
-enum GameTextInputSpanFlag { SPAN_UNDEFINED = -1 };
-
-/**
- * This struct holds the state of an editable section of text.
- * The text can have a selection and a composing region defined on it.
- * A composing region is used by IMEs that allow input using multiple steps to
- * compose a glyph or word. Use functions GameTextInput_getState and
- * GameTextInput_setState to read and modify the state that an IME is editing.
- */
-typedef struct GameTextInputState {
- /**
- * Text owned by the state, as a modified UTF-8 string. Null-terminated.
- * https://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8
- */
- const char *text_UTF8;
- /**
- * Length in bytes of text_UTF8, *not* including the null at end.
- */
- int32_t text_length;
- /**
- * A selection defined on the text.
- */
- GameTextInputSpan selection;
- /**
- * A composing region defined on the text.
- */
- GameTextInputSpan composingRegion;
-} GameTextInputState;
-
-/**
- * A callback called by GameTextInput_getState.
- * @param context User-defined context.
- * @param state State, owned by the library, that will be valid for the duration
- * of the callback.
- */
-typedef void (*GameTextInputGetStateCallback)(
- void *context, const struct GameTextInputState *state);
-
-/**
- * Opaque handle to the GameTextInput API.
- */
-typedef struct GameTextInput GameTextInput;
-
-/**
- * Initialize the GameTextInput library.
- * If called twice without GameTextInput_destroy being called, the same pointer
- * will be returned and a warning will be issued.
- * @param env A JNI env valid on the calling thread.
- * @param max_string_size The maximum length of a string that can be edited. If
- * zero, the maximum defaults to 65536 bytes. A buffer of this size is allocated
- * at initialization.
- * @return A handle to the library.
- */
-GameTextInput *GameTextInput_init(JNIEnv *env, uint32_t max_string_size);
-
-/**
- * When using GameTextInput, you need to create a gametextinput.InputConnection
- * on the Java side and pass it using this function to the library, unless using
- * GameActivity in which case this will be done for you. See the GameActivity
- * source code or GameTextInput samples for examples of usage.
- * @param input A valid GameTextInput library handle.
- * @param inputConnection A gametextinput.InputConnection object.
- */
-void GameTextInput_setInputConnection(GameTextInput *input,
- jobject inputConnection);
-
-/**
- * Unless using GameActivity, it is required to call this function from your
- * Java gametextinput.Listener.stateChanged method to convert eventState and
- * trigger any event callbacks. When using GameActivity, this does not need to
- * be called as event processing is handled by the Activity.
- * @param input A valid GameTextInput library handle.
- * @param eventState A Java gametextinput.State object.
- */
-void GameTextInput_processEvent(GameTextInput *input, jobject eventState);
-
-/**
- * Free any resources owned by the GameTextInput library.
- * Any subsequent calls to the library will fail until GameTextInput_init is
- * called again.
- * @param input A valid GameTextInput library handle.
- */
-void GameTextInput_destroy(GameTextInput *input);
-
-/**
- * Flags to be passed to GameTextInput_showIme.
- */
-enum ShowImeFlags {
- SHOW_IME_UNDEFINED = 0, // Default value.
- SHOW_IMPLICIT =
- 1, // Indicates that the user has forced the input method open so it
- // should not be closed until they explicitly do so.
- SHOW_FORCED = 2 // Indicates that this is an implicit request to show the
- // input window, not as the result of a direct request by
- // the user. The window may not be shown in this case.
-};
-
-/**
- * Show the IME. Calls InputMethodManager.showSoftInput().
- * @param input A valid GameTextInput library handle.
- * @param flags Defined in ShowImeFlags above. For more information see:
- * https://developer.android.com/reference/android/view/inputmethod/InputMethodManager
- */
-void GameTextInput_showIme(GameTextInput *input, uint32_t flags);
-
-/**
- * Flags to be passed to GameTextInput_hideIme.
- */
-enum HideImeFlags {
- HIDE_IME_UNDEFINED = 0, // Default value.
- HIDE_IMPLICIT_ONLY =
- 1, // Indicates that the soft input window should only be hidden if it
- // was not explicitly shown by the user.
- HIDE_NOT_ALWAYS =
- 2, // Indicates that the soft input window should normally be hidden,
- // unless it was originally shown with SHOW_FORCED.
-};
-
-/**
- * Show the IME. Calls InputMethodManager.hideSoftInputFromWindow().
- * @param input A valid GameTextInput library handle.
- * @param flags Defined in HideImeFlags above. For more information see:
- * https://developer.android.com/reference/android/view/inputmethod/InputMethodManager
- */
-void GameTextInput_hideIme(GameTextInput *input, uint32_t flags);
-
-/**
- * Restarts the input method. Calls InputMethodManager.restartInput().
- * @param input A valid GameTextInput library handle.
- */
-void GameTextInput_restartInput(GameTextInput *input);
-
-/**
- * Call a callback with the current GameTextInput state, which may have been
- * modified by changes in the IME and calls to GameTextInput_setState. We use a
- * callback rather than returning the state in order to simplify ownership of
- * text_UTF8 strings. These strings are only valid during the calling of the
- * callback.
- * @param input A valid GameTextInput library handle.
- * @param callback A function that will be called with valid state.
- * @param context Context used by the callback.
- */
-void GameTextInput_getState(GameTextInput *input,
- GameTextInputGetStateCallback callback,
- void *context);
-
-/**
- * Set the current GameTextInput state. This state is reflected to any active
- * IME.
- * @param input A valid GameTextInput library handle.
- * @param state The state to set. Ownership is maintained by the caller and must
- * remain valid for the duration of the call.
- */
-void GameTextInput_setState(GameTextInput *input,
- const GameTextInputState *state);
-
-/**
- * Type of the callback needed by GameTextInput_setEventCallback that will be
- * called every time the IME state changes.
- * @param context User-defined context set in GameTextInput_setEventCallback.
- * @param current_state Current IME state, owned by the library and valid during
- * the callback.
- */
-typedef void (*GameTextInputEventCallback)(
- void *context, const GameTextInputState *current_state);
-
-/**
- * Optionally set a callback to be called whenever the IME state changes.
- * Not necessary if you are using GameActivity, which handles these callbacks
- * for you.
- * @param input A valid GameTextInput library handle.
- * @param callback Called by the library when the IME state changes.
- * @param context Context passed as first argument to the callback.
- */
-void GameTextInput_setEventCallback(GameTextInput *input,
- GameTextInputEventCallback callback,
- void *context);
-
-/**
- * Type of the callback needed by GameTextInput_setImeInsetsCallback that will
- * be called every time the IME window insets change.
- * @param context User-defined context set in
- * GameTextInput_setImeWIndowInsetsCallback.
- * @param current_insets Current IME insets, owned by the library and valid
- * during the callback.
- */
-typedef void (*GameTextInputImeInsetsCallback)(void *context,
- const ARect *current_insets);
-
-/**
- * Optionally set a callback to be called whenever the IME insets change.
- * Not necessary if you are using GameActivity, which handles these callbacks
- * for you.
- * @param input A valid GameTextInput library handle.
- * @param callback Called by the library when the IME insets change.
- * @param context Context passed as first argument to the callback.
- */
-void GameTextInput_setImeInsetsCallback(GameTextInput *input,
- GameTextInputImeInsetsCallback callback,
- void *context);
-
-/**
- * Get the current window insets for the IME.
- * @param input A valid GameTextInput library handle.
- * @param insets Filled with the current insets by this function.
- */
-void GameTextInput_getImeInsets(const GameTextInput *input, ARect *insets);
-
-/**
- * Unless using GameActivity, it is required to call this function from your
- * Java gametextinput.Listener.onImeInsetsChanged method to
- * trigger any event callbacks. When using GameActivity, this does not need to
- * be called as insets processing is handled by the Activity.
- * @param input A valid GameTextInput library handle.
- * @param eventState A Java gametextinput.State object.
- */
-void GameTextInput_processImeInsets(GameTextInput *input, const ARect *insets);
-
-/**
- * Convert a GameTextInputState struct to a Java gametextinput.State object.
- * Don't forget to delete the returned Java local ref when you're done.
- * @param input A valid GameTextInput library handle.
- * @param state Input state to convert.
- * @return A Java object of class gametextinput.State. The caller is required to
- * delete this local reference.
- */
-jobject GameTextInputState_toJava(const GameTextInput *input,
- const GameTextInputState *state);
-
-/**
- * Convert from a Java gametextinput.State object into a C GameTextInputState
- * struct.
- * @param input A valid GameTextInput library handle.
- * @param state A Java gametextinput.State object.
- * @param callback A function called with the C struct, valid for the duration
- * of the call.
- * @param context Context passed to the callback.
- */
-void GameTextInputState_fromJava(const GameTextInput *input, jobject state,
- GameTextInputGetStateCallback callback,
- void *context);
-
-#ifdef __cplusplus
-}
-#endif
-
-/** @} */
diff --git a/android-activity/generate-bindings.sh b/android-activity/generate-bindings.sh
old mode 100644
new mode 100755
index 690bfbd..8c1a4e9
--- a/android-activity/generate-bindings.sh
+++ b/android-activity/generate-bindings.sh
@@ -2,6 +2,7 @@
# First install bindgen-cli via `cargo install bindgen-cli`
+SDK_DIR="${ANDROID_GAMES_SDK:-android-games-sdk}"
if test -z "${ANDROID_NDK_ROOT}"; then
export ANDROID_NDK_ROOT=${ANDROID_NDK_HOME}
fi
@@ -37,7 +38,9 @@ while read ARCH && read TARGET ; do
--blocklist-function 'GameActivity_onCreate_C' \
--newtype-enum '\w+_(result|status)_t' \
-- \
- -Igame-activity-csrc \
+ "-I$SDK_DIR/game-activity/prefab-src/modules/game-activity/include" \
+ "-I$SDK_DIR/game-text-input/prefab-src/modules/game-text-input/include" \
+ "-I$SDK_DIR/include" \
--sysroot="$SYSROOT" --target=$TARGET
done << EOF
diff --git a/android-activity/src/game_activity/ffi_aarch64.rs b/android-activity/src/game_activity/ffi_aarch64.rs
index cd3fabd..461f377 100644
--- a/android-activity/src/game_activity/ffi_aarch64.rs
+++ b/android-activity/src/game_activity/ffi_aarch64.rs
@@ -1,5 +1,15 @@
-/* automatically generated by rust-bindgen 0.66.1 */
+/* automatically generated by rust-bindgen 0.71.1 */
+#[doc = r" If Bindgen could only determine the size and alignment of a"]
+#[doc = r" type, it is represented like this."]
+#[derive(PartialEq, Copy, Clone, Debug, Hash)]
+#[repr(C)]
+pub struct __BindgenOpaqueArray(pub [T; N]);
+impl Default for __BindgenOpaqueArray {
+ fn default() -> Self {
+ Self([::default(); N])
+ }
+}
pub const __BIONIC__: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __bos_level: u32 = 0;
@@ -24,11 +34,12 @@ pub const __ANDROID_API_R__: u32 = 30;
pub const __ANDROID_API_S__: u32 = 31;
pub const __ANDROID_API_T__: u32 = 33;
pub const __ANDROID_API_U__: u32 = 34;
+pub const __ANDROID_API_V__: u32 = 35;
pub const __ANDROID_NDK__: u32 = 1;
-pub const __NDK_MAJOR__: u32 = 25;
-pub const __NDK_MINOR__: u32 = 2;
+pub const __NDK_MAJOR__: u32 = 26;
+pub const __NDK_MINOR__: u32 = 1;
pub const __NDK_BETA__: u32 = 0;
-pub const __NDK_BUILD__: u32 = 9519653;
+pub const __NDK_BUILD__: u32 = 10909125;
pub const __NDK_CANARY__: u32 = 0;
pub const WCHAR_MIN: u8 = 0u8;
pub const INT8_MIN: i32 = -128;
@@ -61,11 +72,10 @@ pub const WINT_MAX: u32 = 4294967295;
pub const WINT_MIN: u32 = 0;
pub const __BITS_PER_LONG: u32 = 64;
pub const __FD_SETSIZE: u32 = 1024;
-pub const __GNUC_VA_LIST: u32 = 1;
pub const AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT: u32 = 8;
+pub const __bool_true_false_are_defined: u32 = 1;
pub const true_: u32 = 1;
pub const false_: u32 = 0;
-pub const __bool_true_false_are_defined: u32 = 1;
pub const __PRI_64_prefix: &[u8; 2] = b"l\0";
pub const __PRI_PTR_prefix: &[u8; 2] = b"l\0";
pub const __PRI_FAST_prefix: &[u8; 2] = b"l\0";
@@ -97,6 +107,34 @@ pub const PRIiFAST32: &[u8; 3] = b"li\0";
pub const PRIiFAST64: &[u8; 3] = b"li\0";
pub const PRIiMAX: &[u8; 3] = b"ji\0";
pub const PRIiPTR: &[u8; 3] = b"li\0";
+pub const PRIb8: &[u8; 2] = b"b\0";
+pub const PRIb16: &[u8; 2] = b"b\0";
+pub const PRIb32: &[u8; 2] = b"b\0";
+pub const PRIb64: &[u8; 3] = b"lb\0";
+pub const PRIbLEAST8: &[u8; 2] = b"b\0";
+pub const PRIbLEAST16: &[u8; 2] = b"b\0";
+pub const PRIbLEAST32: &[u8; 2] = b"b\0";
+pub const PRIbLEAST64: &[u8; 3] = b"lb\0";
+pub const PRIbFAST8: &[u8; 2] = b"b\0";
+pub const PRIbFAST16: &[u8; 3] = b"lb\0";
+pub const PRIbFAST32: &[u8; 3] = b"lb\0";
+pub const PRIbFAST64: &[u8; 3] = b"lb\0";
+pub const PRIbMAX: &[u8; 3] = b"jb\0";
+pub const PRIbPTR: &[u8; 3] = b"lb\0";
+pub const PRIB8: &[u8; 2] = b"B\0";
+pub const PRIB16: &[u8; 2] = b"B\0";
+pub const PRIB32: &[u8; 2] = b"B\0";
+pub const PRIB64: &[u8; 3] = b"lB\0";
+pub const PRIBLEAST8: &[u8; 2] = b"B\0";
+pub const PRIBLEAST16: &[u8; 2] = b"B\0";
+pub const PRIBLEAST32: &[u8; 2] = b"B\0";
+pub const PRIBLEAST64: &[u8; 3] = b"lB\0";
+pub const PRIBFAST8: &[u8; 2] = b"B\0";
+pub const PRIBFAST16: &[u8; 3] = b"lB\0";
+pub const PRIBFAST32: &[u8; 3] = b"lB\0";
+pub const PRIBFAST64: &[u8; 3] = b"lB\0";
+pub const PRIBMAX: &[u8; 3] = b"jB\0";
+pub const PRIBPTR: &[u8; 3] = b"lB\0";
pub const PRIo8: &[u8; 2] = b"o\0";
pub const PRIo16: &[u8; 2] = b"o\0";
pub const PRIo32: &[u8; 2] = b"o\0";
@@ -181,6 +219,34 @@ pub const SCNiFAST32: &[u8; 3] = b"li\0";
pub const SCNiFAST64: &[u8; 3] = b"li\0";
pub const SCNiMAX: &[u8; 3] = b"ji\0";
pub const SCNiPTR: &[u8; 3] = b"li\0";
+pub const SCNb8: &[u8; 4] = b"hhb\0";
+pub const SCNb16: &[u8; 3] = b"hb\0";
+pub const SCNb32: &[u8; 2] = b"b\0";
+pub const SCNb64: &[u8; 3] = b"lb\0";
+pub const SCNbLEAST8: &[u8; 4] = b"hhb\0";
+pub const SCNbLEAST16: &[u8; 3] = b"hb\0";
+pub const SCNbLEAST32: &[u8; 2] = b"b\0";
+pub const SCNbLEAST64: &[u8; 3] = b"lb\0";
+pub const SCNbFAST8: &[u8; 4] = b"hhb\0";
+pub const SCNbFAST16: &[u8; 3] = b"lb\0";
+pub const SCNbFAST32: &[u8; 3] = b"lb\0";
+pub const SCNbFAST64: &[u8; 3] = b"lb\0";
+pub const SCNbMAX: &[u8; 3] = b"jb\0";
+pub const SCNbPTR: &[u8; 3] = b"lb\0";
+pub const SCNB8: &[u8; 4] = b"hhB\0";
+pub const SCNB16: &[u8; 3] = b"hB\0";
+pub const SCNB32: &[u8; 2] = b"B\0";
+pub const SCNB64: &[u8; 3] = b"lB\0";
+pub const SCNBLEAST8: &[u8; 4] = b"hhB\0";
+pub const SCNBLEAST16: &[u8; 3] = b"hB\0";
+pub const SCNBLEAST32: &[u8; 2] = b"B\0";
+pub const SCNBLEAST64: &[u8; 3] = b"lB\0";
+pub const SCNBFAST8: &[u8; 4] = b"hhB\0";
+pub const SCNBFAST16: &[u8; 3] = b"lB\0";
+pub const SCNBFAST32: &[u8; 3] = b"lB\0";
+pub const SCNBFAST64: &[u8; 3] = b"lB\0";
+pub const SCNBMAX: &[u8; 3] = b"jB\0";
+pub const SCNBPTR: &[u8; 3] = b"lB\0";
pub const SCNo8: &[u8; 4] = b"hho\0";
pub const SCNo16: &[u8; 3] = b"ho\0";
pub const SCNo32: &[u8; 2] = b"o\0";
@@ -225,12 +291,12 @@ pub const SCNxMAX: &[u8; 3] = b"jx\0";
pub const SCNxPTR: &[u8; 3] = b"lx\0";
pub const GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT: u32 = 48;
pub const GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT: u32 = 8;
-pub const GAMETEXTINPUT_MAJOR_VERSION: u32 = 2;
+pub const GAMETEXTINPUT_MAJOR_VERSION: u32 = 4;
pub const GAMETEXTINPUT_MINOR_VERSION: u32 = 0;
pub const GAMETEXTINPUT_BUGFIX_VERSION: u32 = 0;
-pub const GAMEACTIVITY_MAJOR_VERSION: u32 = 2;
+pub const GAMEACTIVITY_MAJOR_VERSION: u32 = 4;
pub const GAMEACTIVITY_MINOR_VERSION: u32 = 0;
-pub const GAMEACTIVITY_BUGFIX_VERSION: u32 = 2;
+pub const GAMEACTIVITY_BUGFIX_VERSION: u32 = 0;
pub const POLLIN: u32 = 1;
pub const POLLPRI: u32 = 2;
pub const POLLOUT: u32 = 4;
@@ -248,6 +314,10 @@ pub const FPSIMD_MAGIC: u32 = 1179680769;
pub const ESR_MAGIC: u32 = 1163088385;
pub const EXTRA_MAGIC: u32 = 1163416577;
pub const SVE_MAGIC: u32 = 1398162689;
+pub const SVE_SIG_FLAG_SM: u32 = 1;
+pub const TPIDR2_MAGIC: u32 = 1414547714;
+pub const ZA_MAGIC: u32 = 1412850501;
+pub const ZT_MAGIC: u32 = 1515474433;
pub const __SVE_VQ_BYTES: u32 = 16;
pub const __SVE_VQ_MIN: u32 = 1;
pub const __SVE_VQ_MAX: u32 = 512;
@@ -263,6 +333,8 @@ pub const SVE_VL_MIN: u32 = 16;
pub const SVE_VL_MAX: u32 = 8192;
pub const SVE_NUM_ZREGS: u32 = 32;
pub const SVE_NUM_PREGS: u32 = 16;
+pub const ZT_SIG_REG_SIZE: u32 = 512;
+pub const ZT_SIG_REG_BYTES: u32 = 64;
pub const NR_OPEN: u32 = 1024;
pub const NGROUPS_MAX: u32 = 65536;
pub const ARG_MAX: u32 = 131072;
@@ -553,6 +625,7 @@ pub const TRAP_HWBKPT: u32 = 4;
pub const TRAP_UNK: u32 = 5;
pub const TRAP_PERF: u32 = 6;
pub const NSIGTRAP: u32 = 6;
+pub const TRAP_PERF_FLAG_ASYNC: u32 = 1;
pub const CLD_EXITED: u32 = 1;
pub const CLD_KILLED: u32 = 2;
pub const CLD_DUMPED: u32 = 3;
@@ -608,6 +681,9 @@ pub const TIMER_ABSTIME: u32 = 1;
pub const FD_SETSIZE: u32 = 1024;
pub const CLOCKS_PER_SEC: u32 = 1000000;
pub const TIME_UTC: u32 = 1;
+pub const TIME_MONOTONIC: u32 = 2;
+pub const TIME_ACTIVE: u32 = 3;
+pub const TIME_THREAD_ACTIVE: u32 = 4;
pub const CSIGNAL: u32 = 255;
pub const CLONE_VM: u32 = 256;
pub const CLONE_FS: u32 = 512;
@@ -693,32 +769,22 @@ fn bindgen_test_layout_max_align_t() {
assert_eq!(
::std::mem::size_of::(),
32usize,
- concat!("Size of: ", stringify!(max_align_t))
+ "Size of max_align_t"
);
assert_eq!(
::std::mem::align_of::(),
16usize,
- concat!("Alignment of ", stringify!(max_align_t))
+ "Alignment of max_align_t"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(max_align_t),
- "::",
- stringify!(__clang_max_align_nonce1)
- )
+ "Offset of field: max_align_t::__clang_max_align_nonce1"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(max_align_t),
- "::",
- stringify!(__clang_max_align_nonce2)
- )
+ "Offset of field: max_align_t::__clang_max_align_nonce2"
);
}
pub type __int8_t = ::std::os::raw::c_schar;
@@ -769,22 +835,17 @@ fn bindgen_test_layout___kernel_fd_set() {
assert_eq!(
::std::mem::size_of::<__kernel_fd_set>(),
128usize,
- concat!("Size of: ", stringify!(__kernel_fd_set))
+ "Size of __kernel_fd_set"
);
assert_eq!(
::std::mem::align_of::<__kernel_fd_set>(),
8usize,
- concat!("Alignment of ", stringify!(__kernel_fd_set))
+ "Alignment of __kernel_fd_set"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fds_bits) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(__kernel_fd_set),
- "::",
- stringify!(fds_bits)
- )
+ "Offset of field: __kernel_fd_set::fds_bits"
);
}
pub type __kernel_sighandler_t =
@@ -821,22 +882,17 @@ fn bindgen_test_layout___kernel_fsid_t() {
assert_eq!(
::std::mem::size_of::<__kernel_fsid_t>(),
8usize,
- concat!("Size of: ", stringify!(__kernel_fsid_t))
+ "Size of __kernel_fsid_t"
);
assert_eq!(
::std::mem::align_of::<__kernel_fsid_t>(),
4usize,
- concat!("Alignment of ", stringify!(__kernel_fsid_t))
+ "Alignment of __kernel_fsid_t"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(__kernel_fsid_t),
- "::",
- stringify!(val)
- )
+ "Offset of field: __kernel_fsid_t::val"
);
}
pub type __kernel_off_t = __kernel_long_t;
@@ -899,7 +955,7 @@ pub type loff_t = off_t;
pub type off64_t = loff_t;
pub type __socklen_t = u32;
pub type socklen_t = __socklen_t;
-pub type __va_list = [u64; 4usize];
+pub type __va_list = __BindgenOpaqueArray;
pub type uint_t = ::std::os::raw::c_uint;
pub type uint = ::std::os::raw::c_uint;
pub type u_char = ::std::os::raw::c_uchar;
@@ -1204,6 +1260,22 @@ pub const AKEYCODE_REFRESH: _bindgen_ty_2 = 285;
pub const AKEYCODE_THUMBS_UP: _bindgen_ty_2 = 286;
pub const AKEYCODE_THUMBS_DOWN: _bindgen_ty_2 = 287;
pub const AKEYCODE_PROFILE_SWITCH: _bindgen_ty_2 = 288;
+pub const AKEYCODE_VIDEO_APP_1: _bindgen_ty_2 = 289;
+pub const AKEYCODE_VIDEO_APP_2: _bindgen_ty_2 = 290;
+pub const AKEYCODE_VIDEO_APP_3: _bindgen_ty_2 = 291;
+pub const AKEYCODE_VIDEO_APP_4: _bindgen_ty_2 = 292;
+pub const AKEYCODE_VIDEO_APP_5: _bindgen_ty_2 = 293;
+pub const AKEYCODE_VIDEO_APP_6: _bindgen_ty_2 = 294;
+pub const AKEYCODE_VIDEO_APP_7: _bindgen_ty_2 = 295;
+pub const AKEYCODE_VIDEO_APP_8: _bindgen_ty_2 = 296;
+pub const AKEYCODE_FEATURED_APP_1: _bindgen_ty_2 = 297;
+pub const AKEYCODE_FEATURED_APP_2: _bindgen_ty_2 = 298;
+pub const AKEYCODE_FEATURED_APP_3: _bindgen_ty_2 = 299;
+pub const AKEYCODE_FEATURED_APP_4: _bindgen_ty_2 = 300;
+pub const AKEYCODE_DEMO_APP_1: _bindgen_ty_2 = 301;
+pub const AKEYCODE_DEMO_APP_2: _bindgen_ty_2 = 302;
+pub const AKEYCODE_DEMO_APP_3: _bindgen_ty_2 = 303;
+pub const AKEYCODE_DEMO_APP_4: _bindgen_ty_2 = 304;
pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
pub const ALOOPER_PREPARE_ALLOW_NON_CALLBACKS: _bindgen_ty_3 = 1;
pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
@@ -1218,8 +1290,8 @@ pub const ALOOPER_EVENT_ERROR: _bindgen_ty_5 = 4;
pub const ALOOPER_EVENT_HANGUP: _bindgen_ty_5 = 8;
pub const ALOOPER_EVENT_INVALID: _bindgen_ty_5 = 16;
pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
-pub type va_list = [u64; 4usize];
-pub type __gnuc_va_list = [u64; 4usize];
+pub type __gnuc_va_list = __BindgenOpaqueArray;
+pub type va_list = __BindgenOpaqueArray;
#[repr(C)]
pub struct JavaVMAttachArgs {
pub version: jint,
@@ -1233,42 +1305,27 @@ fn bindgen_test_layout_JavaVMAttachArgs() {
assert_eq!(
::std::mem::size_of::(),
24usize,
- concat!("Size of: ", stringify!(JavaVMAttachArgs))
+ "Size of JavaVMAttachArgs"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(JavaVMAttachArgs))
+ "Alignment of JavaVMAttachArgs"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMAttachArgs),
- "::",
- stringify!(version)
- )
+ "Offset of field: JavaVMAttachArgs::version"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMAttachArgs),
- "::",
- stringify!(name)
- )
+ "Offset of field: JavaVMAttachArgs::name"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).group) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMAttachArgs),
- "::",
- stringify!(group)
- )
+ "Offset of field: JavaVMAttachArgs::group"
);
}
#[repr(C)]
@@ -1284,32 +1341,22 @@ fn bindgen_test_layout_JavaVMOption() {
assert_eq!(
::std::mem::size_of::(),
16usize,
- concat!("Size of: ", stringify!(JavaVMOption))
+ "Size of JavaVMOption"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(JavaVMOption))
+ "Alignment of JavaVMOption"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optionString) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMOption),
- "::",
- stringify!(optionString)
- )
+ "Offset of field: JavaVMOption::optionString"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extraInfo) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMOption),
- "::",
- stringify!(extraInfo)
- )
+ "Offset of field: JavaVMOption::extraInfo"
);
}
#[repr(C)]
@@ -1326,52 +1373,32 @@ fn bindgen_test_layout_JavaVMInitArgs() {
assert_eq!(
::std::mem::size_of::(),
24usize,
- concat!("Size of: ", stringify!(JavaVMInitArgs))
+ "Size of JavaVMInitArgs"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(JavaVMInitArgs))
+ "Alignment of JavaVMInitArgs"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMInitArgs),
- "::",
- stringify!(version)
- )
+ "Offset of field: JavaVMInitArgs::version"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nOptions) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMInitArgs),
- "::",
- stringify!(nOptions)
- )
+ "Offset of field: JavaVMInitArgs::nOptions"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMInitArgs),
- "::",
- stringify!(options)
- )
+ "Offset of field: JavaVMInitArgs::options"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignoreUnrecognized) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(JavaVMInitArgs),
- "::",
- stringify!(ignoreUnrecognized)
- )
+ "Offset of field: JavaVMInitArgs::ignoreUnrecognized"
);
}
pub const AKEY_STATE_UNKNOWN: _bindgen_ty_6 = -1;
@@ -1841,32 +1868,22 @@ fn bindgen_test_layout_imaxdiv_t() {
assert_eq!(
::std::mem::size_of::(),
16usize,
- concat!("Size of: ", stringify!(imaxdiv_t))
+ "Size of imaxdiv_t"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(imaxdiv_t))
+ "Alignment of imaxdiv_t"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(imaxdiv_t),
- "::",
- stringify!(quot)
- )
+ "Offset of field: imaxdiv_t::quot"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(imaxdiv_t),
- "::",
- stringify!(rem)
- )
+ "Offset of field: imaxdiv_t::rem"
);
}
extern "C" {
@@ -1971,6 +1988,10 @@ pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_S8_UINT: AHardwareBuffer
pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420: AHardwareBuffer_Format = 35;
pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_YCbCr_P010: AHardwareBuffer_Format = 54;
pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_R8_UNORM: AHardwareBuffer_Format = 56;
+pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_R16_UINT: AHardwareBuffer_Format = 57;
+pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_R16G16_UINT: AHardwareBuffer_Format = 58;
+pub const AHardwareBuffer_Format_AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM: AHardwareBuffer_Format =
+ 59;
pub type AHardwareBuffer_Format = ::std::os::raw::c_uint;
pub const AHardwareBuffer_UsageFlags_AHARDWAREBUFFER_USAGE_CPU_READ_NEVER:
AHardwareBuffer_UsageFlags = 0;
@@ -2008,6 +2029,8 @@ pub const AHardwareBuffer_UsageFlags_AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP:
AHardwareBuffer_UsageFlags = 33554432;
pub const AHardwareBuffer_UsageFlags_AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE:
AHardwareBuffer_UsageFlags = 67108864;
+pub const AHardwareBuffer_UsageFlags_AHARDWAREBUFFER_USAGE_FRONT_BUFFER:
+ AHardwareBuffer_UsageFlags = 4294967296;
pub const AHardwareBuffer_UsageFlags_AHARDWAREBUFFER_USAGE_VENDOR_0: AHardwareBuffer_UsageFlags =
268435456;
pub const AHardwareBuffer_UsageFlags_AHARDWAREBUFFER_USAGE_VENDOR_1: AHardwareBuffer_UsageFlags =
@@ -2068,92 +2091,52 @@ fn bindgen_test_layout_AHardwareBuffer_Desc() {
assert_eq!(
::std::mem::size_of::(),
40usize,
- concat!("Size of: ", stringify!(AHardwareBuffer_Desc))
+ "Size of AHardwareBuffer_Desc"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(AHardwareBuffer_Desc))
+ "Alignment of AHardwareBuffer_Desc"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(width)
- )
+ "Offset of field: AHardwareBuffer_Desc::width"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(height)
- )
+ "Offset of field: AHardwareBuffer_Desc::height"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).layers) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(layers)
- )
+ "Offset of field: AHardwareBuffer_Desc::layers"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
12usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(format)
- )
+ "Offset of field: AHardwareBuffer_Desc::format"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).usage) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(usage)
- )
+ "Offset of field: AHardwareBuffer_Desc::usage"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stride) as usize - ptr as usize },
24usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(stride)
- )
+ "Offset of field: AHardwareBuffer_Desc::stride"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rfu0) as usize - ptr as usize },
28usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(rfu0)
- )
+ "Offset of field: AHardwareBuffer_Desc::rfu0"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rfu1) as usize - ptr as usize },
32usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Desc),
- "::",
- stringify!(rfu1)
- )
+ "Offset of field: AHardwareBuffer_Desc::rfu1"
);
}
#[repr(C)]
@@ -2171,42 +2154,27 @@ fn bindgen_test_layout_AHardwareBuffer_Plane() {
assert_eq!(
::std::mem::size_of::(),
16usize,
- concat!("Size of: ", stringify!(AHardwareBuffer_Plane))
+ "Size of AHardwareBuffer_Plane"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(AHardwareBuffer_Plane))
+ "Alignment of AHardwareBuffer_Plane"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Plane),
- "::",
- stringify!(data)
- )
+ "Offset of field: AHardwareBuffer_Plane::data"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pixelStride) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Plane),
- "::",
- stringify!(pixelStride)
- )
+ "Offset of field: AHardwareBuffer_Plane::pixelStride"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rowStride) as usize - ptr as usize },
12usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Plane),
- "::",
- stringify!(rowStride)
- )
+ "Offset of field: AHardwareBuffer_Plane::rowStride"
);
}
#[repr(C)]
@@ -2223,32 +2191,22 @@ fn bindgen_test_layout_AHardwareBuffer_Planes() {
assert_eq!(
::std::mem::size_of::(),
72usize,
- concat!("Size of: ", stringify!(AHardwareBuffer_Planes))
+ "Size of AHardwareBuffer_Planes"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(AHardwareBuffer_Planes))
+ "Alignment of AHardwareBuffer_Planes"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).planeCount) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Planes),
- "::",
- stringify!(planeCount)
- )
+ "Offset of field: AHardwareBuffer_Planes::planeCount"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).planes) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(AHardwareBuffer_Planes),
- "::",
- stringify!(planes)
- )
+ "Offset of field: AHardwareBuffer_Planes::planes"
);
}
#[repr(C)]
@@ -2348,62 +2306,37 @@ fn bindgen_test_layout_GameActivityPointerAxes() {
assert_eq!(
::std::mem::size_of::(),
208usize,
- concat!("Size of: ", stringify!(GameActivityPointerAxes))
+ "Size of GameActivityPointerAxes"
);
assert_eq!(
::std::mem::align_of::(),
4usize,
- concat!("Alignment of ", stringify!(GameActivityPointerAxes))
+ "Alignment of GameActivityPointerAxes"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityPointerAxes),
- "::",
- stringify!(id)
- )
+ "Offset of field: GameActivityPointerAxes::id"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).toolType) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityPointerAxes),
- "::",
- stringify!(toolType)
- )
+ "Offset of field: GameActivityPointerAxes::toolType"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axisValues) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityPointerAxes),
- "::",
- stringify!(axisValues)
- )
+ "Offset of field: GameActivityPointerAxes::axisValues"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rawX) as usize - ptr as usize },
200usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityPointerAxes),
- "::",
- stringify!(rawX)
- )
+ "Offset of field: GameActivityPointerAxes::rawX"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rawY) as usize - ptr as usize },
204usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityPointerAxes),
- "::",
- stringify!(rawY)
- )
+ "Offset of field: GameActivityPointerAxes::rawY"
);
}
extern "C" {
@@ -2453,202 +2386,107 @@ fn bindgen_test_layout_GameActivityMotionEvent() {
assert_eq!(
::std::mem::size_of::(),
1760usize,
- concat!("Size of: ", stringify!(GameActivityMotionEvent))
+ "Size of GameActivityMotionEvent"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(GameActivityMotionEvent))
+ "Alignment of GameActivityMotionEvent"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).deviceId) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(deviceId)
- )
+ "Offset of field: GameActivityMotionEvent::deviceId"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(source)
- )
+ "Offset of field: GameActivityMotionEvent::source"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(action)
- )
+ "Offset of field: GameActivityMotionEvent::action"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).eventTime) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(eventTime)
- )
+ "Offset of field: GameActivityMotionEvent::eventTime"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).downTime) as usize - ptr as usize },
24usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(downTime)
- )
+ "Offset of field: GameActivityMotionEvent::downTime"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
32usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(flags)
- )
+ "Offset of field: GameActivityMotionEvent::flags"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).metaState) as usize - ptr as usize },
36usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(metaState)
- )
+ "Offset of field: GameActivityMotionEvent::metaState"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).actionButton) as usize - ptr as usize },
40usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(actionButton)
- )
+ "Offset of field: GameActivityMotionEvent::actionButton"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buttonState) as usize - ptr as usize },
44usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(buttonState)
- )
+ "Offset of field: GameActivityMotionEvent::buttonState"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).classification) as usize - ptr as usize },
48usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(classification)
- )
+ "Offset of field: GameActivityMotionEvent::classification"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).edgeFlags) as usize - ptr as usize },
52usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(edgeFlags)
- )
+ "Offset of field: GameActivityMotionEvent::edgeFlags"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pointerCount) as usize - ptr as usize },
56usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(pointerCount)
- )
+ "Offset of field: GameActivityMotionEvent::pointerCount"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pointers) as usize - ptr as usize },
60usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(pointers)
- )
+ "Offset of field: GameActivityMotionEvent::pointers"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).historySize) as usize - ptr as usize },
1724usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(historySize)
- )
+ "Offset of field: GameActivityMotionEvent::historySize"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).historicalEventTimesMillis) as usize - ptr as usize },
1728usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(historicalEventTimesMillis)
- )
+ "Offset of field: GameActivityMotionEvent::historicalEventTimesMillis"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).historicalEventTimesNanos) as usize - ptr as usize },
1736usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(historicalEventTimesNanos)
- )
+ "Offset of field: GameActivityMotionEvent::historicalEventTimesNanos"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).historicalAxisValues) as usize - ptr as usize },
1744usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(historicalAxisValues)
- )
+ "Offset of field: GameActivityMotionEvent::historicalAxisValues"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).precisionX) as usize - ptr as usize },
1752usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(precisionX)
- )
+ "Offset of field: GameActivityMotionEvent::precisionX"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).precisionY) as usize - ptr as usize },
1756usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityMotionEvent),
- "::",
- stringify!(precisionY)
- )
+ "Offset of field: GameActivityMotionEvent::precisionY"
);
}
extern "C" {
@@ -2663,14 +2501,6 @@ extern "C" {
#[doc = " \\brief Handle the freeing of the GameActivityMotionEvent struct."]
pub fn GameActivityMotionEvent_destroy(c_event: *mut GameActivityMotionEvent);
}
-extern "C" {
- #[doc = " \\brief Convert a Java `MotionEvent` to a `GameActivityMotionEvent`.\n\n This is done automatically by the GameActivity: see `onTouchEvent` to set\n a callback to consume the received events.\n This function can be used if you re-implement events handling in your own\n activity.\n Ownership of out_event is maintained by the caller."]
- pub fn GameActivityMotionEvent_fromJava(
- env: *mut JNIEnv,
- motionEvent: jobject,
- out_event: *mut GameActivityMotionEvent,
- );
-}
#[doc = " \\brief Describe a key event that happened on the GameActivity SurfaceView.\n\n This is 1:1 mapping to the information contained in a Java `KeyEvent`\n (see https://developer.android.com/reference/android/view/KeyEvent).\n The only exception is the event times, which are reported as\n nanoseconds in this struct."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
@@ -2694,146 +2524,69 @@ fn bindgen_test_layout_GameActivityKeyEvent() {
assert_eq!(
::std::mem::size_of::(),
56usize,
- concat!("Size of: ", stringify!(GameActivityKeyEvent))
+ "Size of GameActivityKeyEvent"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(GameActivityKeyEvent))
+ "Alignment of GameActivityKeyEvent"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).deviceId) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(deviceId)
- )
+ "Offset of field: GameActivityKeyEvent::deviceId"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(source)
- )
+ "Offset of field: GameActivityKeyEvent::source"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(action)
- )
+ "Offset of field: GameActivityKeyEvent::action"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).eventTime) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(eventTime)
- )
+ "Offset of field: GameActivityKeyEvent::eventTime"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).downTime) as usize - ptr as usize },
24usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(downTime)
- )
+ "Offset of field: GameActivityKeyEvent::downTime"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
32usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(flags)
- )
+ "Offset of field: GameActivityKeyEvent::flags"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).metaState) as usize - ptr as usize },
36usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(metaState)
- )
+ "Offset of field: GameActivityKeyEvent::metaState"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).modifiers) as usize - ptr as usize },
40usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(modifiers)
- )
+ "Offset of field: GameActivityKeyEvent::modifiers"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).repeatCount) as usize - ptr as usize },
44usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(repeatCount)
- )
+ "Offset of field: GameActivityKeyEvent::repeatCount"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyCode) as usize - ptr as usize },
48usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(keyCode)
- )
+ "Offset of field: GameActivityKeyEvent::keyCode"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scanCode) as usize - ptr as usize },
52usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityKeyEvent),
- "::",
- stringify!(scanCode)
- )
+ "Offset of field: GameActivityKeyEvent::scanCode"
);
}
-extern "C" {
- #[doc = " \\brief Convert a Java `KeyEvent` to a `GameActivityKeyEvent`.\n\n This is done automatically by the GameActivity: see `onKeyUp` and `onKeyDown`\n to set a callback to consume the received events.\n This function can be used if you re-implement events handling in your own\n activity.\n Ownership of out_event is maintained by the caller."]
- pub fn GameActivityKeyEvent_fromJava(
- env: *mut JNIEnv,
- motionEvent: jobject,
- out_event: *mut GameActivityKeyEvent,
- );
-}
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_CAPTION_BAR: GameCommonInsetsType = 0;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_DISPLAY_CUTOUT: GameCommonInsetsType = 1;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_IME: GameCommonInsetsType = 2;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_MANDATORY_SYSTEM_GESTURES:
- GameCommonInsetsType = 3;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_NAVIGATION_BARS: GameCommonInsetsType = 4;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_STATUS_BARS: GameCommonInsetsType = 5;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_SYSTEM_BARS: GameCommonInsetsType = 6;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_SYSTEM_GESTURES: GameCommonInsetsType = 7;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_TAPABLE_ELEMENT: GameCommonInsetsType = 8;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_WATERFALL: GameCommonInsetsType = 9;
-pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_COUNT: GameCommonInsetsType = 10;
-#[doc = " The type of a component for which to retrieve insets. See\n https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat.Type"]
-pub type GameCommonInsetsType = ::std::os::raw::c_uint;
#[doc = " This struct holds a span within a region of text from start (inclusive) to\n end (exclusive). An empty span or cursor position is specified with\n start==end. An undefined span is specified with start = end = SPAN_UNDEFINED."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
@@ -2850,37 +2603,27 @@ fn bindgen_test_layout_GameTextInputSpan() {
assert_eq!(
::std::mem::size_of::(),
8usize,
- concat!("Size of: ", stringify!(GameTextInputSpan))
+ "Size of GameTextInputSpan"
);
assert_eq!(
::std::mem::align_of::(),
4usize,
- concat!("Alignment of ", stringify!(GameTextInputSpan))
+ "Alignment of GameTextInputSpan"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameTextInputSpan),
- "::",
- stringify!(start)
- )
+ "Offset of field: GameTextInputSpan::start"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(GameTextInputSpan),
- "::",
- stringify!(end)
- )
+ "Offset of field: GameTextInputSpan::end"
);
}
pub const GameTextInputSpanFlag_SPAN_UNDEFINED: GameTextInputSpanFlag = -1;
#[doc = " Values with special meaning in a GameTextInputSpan."]
-pub type GameTextInputSpanFlag = ::std::os::raw::c_int;
+pub type GameTextInputSpanFlag = i32;
#[doc = " This struct holds the state of an editable section of text.\n The text can have a selection and a composing region defined on it.\n A composing region is used by IMEs that allow input using multiple steps to\n compose a glyph or word. Use functions GameTextInput_getState and\n GameTextInput_setState to read and modify the state that an IME is editing."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
@@ -2901,52 +2644,32 @@ fn bindgen_test_layout_GameTextInputState() {
assert_eq!(
::std::mem::size_of::(),
32usize,
- concat!("Size of: ", stringify!(GameTextInputState))
+ "Size of GameTextInputState"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(GameTextInputState))
+ "Alignment of GameTextInputState"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_UTF8) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameTextInputState),
- "::",
- stringify!(text_UTF8)
- )
+ "Offset of field: GameTextInputState::text_UTF8"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_length) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(GameTextInputState),
- "::",
- stringify!(text_length)
- )
+ "Offset of field: GameTextInputState::text_length"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
12usize,
- concat!(
- "Offset of field: ",
- stringify!(GameTextInputState),
- "::",
- stringify!(selection)
- )
+ "Offset of field: GameTextInputState::selection"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).composingRegion) as usize - ptr as usize },
20usize,
- concat!(
- "Offset of field: ",
- stringify!(GameTextInputState),
- "::",
- stringify!(composingRegion)
- )
+ "Offset of field: GameTextInputState::composingRegion"
);
}
#[doc = " A callback called by GameTextInput_getState.\n @param context User-defined context.\n @param state State, owned by the library, that will be valid for the duration\n of the callback."]
@@ -2978,7 +2701,7 @@ pub const ShowImeFlags_SHOW_IME_UNDEFINED: ShowImeFlags = 0;
pub const ShowImeFlags_SHOW_IMPLICIT: ShowImeFlags = 1;
pub const ShowImeFlags_SHOW_FORCED: ShowImeFlags = 2;
#[doc = " Flags to be passed to GameTextInput_showIme."]
-pub type ShowImeFlags = ::std::os::raw::c_uint;
+pub type ShowImeFlags = u32;
extern "C" {
#[doc = " Show the IME. Calls InputMethodManager.showSoftInput().\n @param input A valid GameTextInput library handle.\n @param flags Defined in ShowImeFlags above. For more information see:\n https://developer.android.com/reference/android/view/inputmethod/InputMethodManager"]
pub fn GameTextInput_showIme(input: *mut GameTextInput, flags: u32);
@@ -2987,9 +2710,9 @@ pub const HideImeFlags_HIDE_IME_UNDEFINED: HideImeFlags = 0;
pub const HideImeFlags_HIDE_IMPLICIT_ONLY: HideImeFlags = 1;
pub const HideImeFlags_HIDE_NOT_ALWAYS: HideImeFlags = 2;
#[doc = " Flags to be passed to GameTextInput_hideIme."]
-pub type HideImeFlags = ::std::os::raw::c_uint;
+pub type HideImeFlags = u32;
extern "C" {
- #[doc = " Show the IME. Calls InputMethodManager.hideSoftInputFromWindow().\n @param input A valid GameTextInput library handle.\n @param flags Defined in HideImeFlags above. For more information see:\n https://developer.android.com/reference/android/view/inputmethod/InputMethodManager"]
+ #[doc = " Hide the IME. Calls InputMethodManager.hideSoftInputFromWindow().\n @param input A valid GameTextInput library handle.\n @param flags Defined in HideImeFlags above. For more information see:\n https://developer.android.com/reference/android/view/inputmethod/InputMethodManager"]
pub fn GameTextInput_hideIme(input: *mut GameTextInput, flags: u32);
}
extern "C" {
@@ -3016,7 +2739,7 @@ pub type GameTextInputEventCallback = ::std::option::Option<
),
>;
extern "C" {
- #[doc = " Optionally set a callback to be called whenever the IME state changes.\n Not necessary if you are using GameActivity, which handles these callbacks\n for you.\n @param input A valid GameTextInput library handle.\n @param callback Called by the library when the IME state changes.\n @param context Context passed as first argument to the callback."]
+ #[doc = " Optionally set a callback to be called whenever the IME state changes.\n Not necessary if you are using GameActivity, which handles these callbacks\n for you.\n @param input A valid GameTextInput library handle.\n @param callback Called by the library when the IME state changes.\n @param context Context passed as first argument to the callback.\n This function is deprecated. Don't perform any complex processing inside\n the callback other than copying the state variable. Using any synchronization\n primitives inside this callback may cause a deadlock."]
pub fn GameTextInput_setEventCallback(
input: *mut GameTextInput,
callback: GameTextInputEventCallback,
@@ -3059,6 +2782,144 @@ extern "C" {
context: *mut ::std::os::raw::c_void,
);
}
+#[doc = " Mask of bits that determine the overall class\n of text being given. Currently supported classes are:\n {@link #TYPE_CLASS_TEXT}, {@link #TYPE_CLASS_NUMBER},\n {@link #TYPE_CLASS_PHONE}, {@link #TYPE_CLASS_DATETIME}.\n IME authors: If the class is not one you\n understand, assume {@link #TYPE_CLASS_TEXT} with NO variation\n or flags.
"]
+pub const GameTextInputType_TYPE_MASK_CLASS: GameTextInputType = 15;
+#[doc = " Mask of bits that determine the variation of\n the base content class."]
+pub const GameTextInputType_TYPE_MASK_VARIATION: GameTextInputType = 4080;
+#[doc = " Mask of bits that provide addition bit flags\n of options."]
+pub const GameTextInputType_TYPE_MASK_FLAGS: GameTextInputType = 16773120;
+#[doc = " Special content type for when no explicit type has been specified.\n This should be interpreted to mean that the target input connection\n is not rich, it can not process and show things like candidate text nor\n retrieve the current text, so the input method will need to run in a\n limited \"generate key events\" mode, if it supports it. Note that some\n input methods may not support it, for example a voice-based input\n method will likely not be able to generate key events even if this\n flag is set."]
+pub const GameTextInputType_TYPE_NULL: GameTextInputType = 0;
+#[doc = " Class for normal text. This class supports the following flags (only\n one of which should be set):\n {@link #TYPE_TEXT_FLAG_CAP_CHARACTERS},\n {@link #TYPE_TEXT_FLAG_CAP_WORDS}, and.\n {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}. It also supports the\n following variations:\n {@link #TYPE_TEXT_VARIATION_NORMAL}, and\n {@link #TYPE_TEXT_VARIATION_URI}. If you do not recognize the\n variation, normal should be assumed."]
+pub const GameTextInputType_TYPE_CLASS_TEXT: GameTextInputType = 1;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: capitalize all characters. Overrides\n {@link #TYPE_TEXT_FLAG_CAP_WORDS} and\n {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}. This value is explicitly defined\n to be the same as {@link TextUtils#CAP_MODE_CHARACTERS}. Of course,\n this only affects languages where there are upper-case and lower-case\n letters."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_CAP_CHARACTERS: GameTextInputType = 4096;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of\n every word. Overrides {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}. This\n value is explicitly defined\n to be the same as {@link TextUtils#CAP_MODE_WORDS}. Of course,\n this only affects languages where there are upper-case and lower-case\n letters."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_CAP_WORDS: GameTextInputType = 8192;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of\n each sentence. This value is explicitly defined\n to be the same as {@link TextUtils#CAP_MODE_SENTENCES}. For example\n in English it means to capitalize after a period and a space (note that\n other languages may have different characters for period, or not use\n spaces, or use different grammatical rules). Of course, this only affects\n languages where there are upper-case and lower-case letters."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_CAP_SENTENCES: GameTextInputType = 16384;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: the user is entering free-form\n text that should have auto-correction applied to it. Without this flag,\n the IME will not try to correct typos. You should always set this flag\n unless you really expect users to type non-words in this field, for\n example to choose a name for a character in a game.\n Contrast this with {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE} and\n {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:\n {@code TYPE_TEXT_FLAG_AUTO_CORRECT} means that the IME will try to\n auto-correct typos as the user is typing, but does not define whether\n the IME offers an interface to show suggestions."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_AUTO_CORRECT: GameTextInputType = 32768;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: the text editor (which means\n the application) is performing auto-completion of the text being entered\n based on its own semantics, which it will present to the user as they type.\n This generally means that the input method should not be showing\n candidates itself, but can expect the editor to supply its own\n completions/candidates from\n {@link android.view.inputmethod.InputMethodSession#displayCompletions\n InputMethodSession.displayCompletions()} as a result of the editor calling\n {@link android.view.inputmethod.InputMethodManager#displayCompletions\n InputMethodManager.displayCompletions()}.\n Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and\n {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:\n {@code TYPE_TEXT_FLAG_AUTO_COMPLETE} means the editor should show an\n interface for displaying suggestions, but instead of supplying its own\n it will rely on the Editor to pass completions/corrections."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_AUTO_COMPLETE: GameTextInputType = 65536;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: multiple lines of text can be\n entered into the field. If this flag is not set, the text field\n will be constrained to a single line. The IME may also choose not to\n display an enter key when this flag is not set, as there should be no\n need to create new lines."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_MULTI_LINE: GameTextInputType = 131072;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: the regular text view associated\n with this should not be multi-line, but when a fullscreen input method\n is providing text it should use multiple lines if it can."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_IME_MULTI_LINE: GameTextInputType = 262144;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: the input method does not need to\n display any dictionary-based candidates. This is useful for text views that\n do not contain words from the language and do not benefit from any\n dictionary-based completions or corrections. It overrides the\n {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} value when set.\n Please avoid using this unless you are certain this is what you want.\n Many input methods need suggestions to work well, for example the ones\n based on gesture typing. Consider clearing\n {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} instead if you just do not\n want the IME to correct typos.\n Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and\n {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE}:\n {@code TYPE_TEXT_FLAG_NO_SUGGESTIONS} means the IME does not need to\n show an interface to display suggestions. Most IMEs will also take this to\n mean they do not need to try to auto-correct what the user is typing."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_NO_SUGGESTIONS: GameTextInputType = 524288;
+#[doc = " Flag for {@link #TYPE_CLASS_TEXT}: Let the IME know the text conversion\n suggestions are required by the application. Text conversion suggestion is\n for the transliteration languages which has pronunciation characters and\n target characters. When the user is typing the pronunciation charactes, the\n IME could provide the possible target characters to the user. When this\n flag is set, the IME should insert the text conversion suggestions through\n {@link Builder#setTextConversionSuggestions(List)} and\n the {@link TextAttribute} with initialized with the text conversion\n suggestions is provided by the IME to the application. To receive the\n additional information, the application needs to implement {@link\n InputConnection#setComposingText(CharSequence, int, TextAttribute)},\n {@link InputConnection#setComposingRegion(int, int, TextAttribute)}, and\n {@link InputConnection#commitText(CharSequence, int, TextAttribute)}."]
+pub const GameTextInputType_TYPE_TEXT_FLAG_ENABLE_TEXT_CONVERSION_SUGGESTIONS: GameTextInputType =
+ 1048576;
+#[doc = " Default variation of {@link #TYPE_CLASS_TEXT}: plain old normal text."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_NORMAL: GameTextInputType = 0;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering a URI."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_URI: GameTextInputType = 16;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering an e-mail address."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_EMAIL_ADDRESS: GameTextInputType = 32;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering the subject line of\n an e-mail."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_EMAIL_SUBJECT: GameTextInputType = 48;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering a short, possibly informal\n message such as an instant message or a text message."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_SHORT_MESSAGE: GameTextInputType = 64;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering the content of a long,\n possibly formal message such as the body of an e-mail."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_LONG_MESSAGE: GameTextInputType = 80;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering the name of a person."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_PERSON_NAME: GameTextInputType = 96;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering a postal mailing address."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_POSTAL_ADDRESS: GameTextInputType = 112;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering a password."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_PASSWORD: GameTextInputType = 128;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering a password, which should\n be visible to the user."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_VISIBLE_PASSWORD: GameTextInputType = 144;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering text inside of a web form."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_WEB_EDIT_TEXT: GameTextInputType = 160;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering text to filter contents\n of a list etc."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_FILTER: GameTextInputType = 176;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering text for phonetic\n pronunciation, such as a phonetic name field in contacts. This is mostly\n useful for languages where one spelling may have several phonetic\n readings, like Japanese."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_PHONETIC: GameTextInputType = 192;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering e-mail address inside\n of a web form. This was added in\n {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An IME must target\n this API version or later to see this input type; if it doesn't, a request\n for this type will be seen as {@link #TYPE_TEXT_VARIATION_EMAIL_ADDRESS}\n when passed through {@link\n android.view.inputmethod.EditorInfo#makeCompatible(int)\n EditorInfo.makeCompatible(int)}."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS: GameTextInputType = 208;
+#[doc = " Variation of {@link #TYPE_CLASS_TEXT}: entering password inside\n of a web form. This was added in\n {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An IME must target\n this API version or later to see this input type; if it doesn't, a request\n for this type will be seen as {@link #TYPE_TEXT_VARIATION_PASSWORD}\n when passed through {@link\n android.view.inputmethod.EditorInfo#makeCompatible(int)\n EditorInfo.makeCompatible(int)}."]
+pub const GameTextInputType_TYPE_TEXT_VARIATION_WEB_PASSWORD: GameTextInputType = 224;
+#[doc = " Class for numeric text. This class supports the following flags:\n {@link #TYPE_NUMBER_FLAG_SIGNED} and\n {@link #TYPE_NUMBER_FLAG_DECIMAL}. It also supports the following\n variations: {@link #TYPE_NUMBER_VARIATION_NORMAL} and\n {@link #TYPE_NUMBER_VARIATION_PASSWORD}.\n
IME authors: If you do not recognize\n the variation, normal should be assumed.
"]
+pub const GameTextInputType_TYPE_CLASS_NUMBER: GameTextInputType = 2;
+#[doc = " Flag of {@link #TYPE_CLASS_NUMBER}: the number is signed, allowing\n a positive or negative sign at the start."]
+pub const GameTextInputType_TYPE_NUMBER_FLAG_SIGNED: GameTextInputType = 4096;
+#[doc = " Flag of {@link #TYPE_CLASS_NUMBER}: the number is decimal, allowing\n a decimal point to provide fractional values."]
+pub const GameTextInputType_TYPE_NUMBER_FLAG_DECIMAL: GameTextInputType = 8192;
+#[doc = " Default variation of {@link #TYPE_CLASS_NUMBER}: plain normal\n numeric text. This was added in\n {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An IME must target\n this API version or later to see this input type; if it doesn't, a request\n for this type will be dropped when passed through\n {@link android.view.inputmethod.EditorInfo#makeCompatible(int)\n EditorInfo.makeCompatible(int)}."]
+pub const GameTextInputType_TYPE_NUMBER_VARIATION_NORMAL: GameTextInputType = 0;
+#[doc = " Variation of {@link #TYPE_CLASS_NUMBER}: entering a numeric password.\n This was added in {@link android.os.Build.VERSION_CODES#HONEYCOMB}. An\n IME must target this API version or later to see this input type; if it\n doesn't, a request for this type will be dropped when passed\n through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)\n EditorInfo.makeCompatible(int)}."]
+pub const GameTextInputType_TYPE_NUMBER_VARIATION_PASSWORD: GameTextInputType = 16;
+#[doc = " Class for a phone number. This class currently supports no variations\n or flags."]
+pub const GameTextInputType_TYPE_CLASS_PHONE: GameTextInputType = 3;
+#[doc = " Class for dates and times. It supports the\n following variations:\n {@link #TYPE_DATETIME_VARIATION_NORMAL}\n {@link #TYPE_DATETIME_VARIATION_DATE}, and\n {@link #TYPE_DATETIME_VARIATION_TIME}."]
+pub const GameTextInputType_TYPE_CLASS_DATETIME: GameTextInputType = 4;
+#[doc = " Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering\n both a date and time."]
+pub const GameTextInputType_TYPE_DATETIME_VARIATION_NORMAL: GameTextInputType = 0;
+#[doc = " Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering\n only a date."]
+pub const GameTextInputType_TYPE_DATETIME_VARIATION_DATE: GameTextInputType = 16;
+#[doc = " Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering\n only a time."]
+pub const GameTextInputType_TYPE_DATETIME_VARIATION_TIME: GameTextInputType = 32;
+#[doc = " Definitions for inputType argument of GameActivity_setImeEditorInfo()\n\n \n |-------|-------|-------|-------|\n 1111 TYPE_MASK_CLASS\n 11111111 TYPE_MASK_VARIATION\n 111111111111 TYPE_MASK_FLAGS\n |-------|-------|-------|-------|\n TYPE_NULL\n |-------|-------|-------|-------|\n 1 TYPE_CLASS_TEXT\n 1 TYPE_TEXT_VARIATION_URI\n 1 TYPE_TEXT_VARIATION_EMAIL_ADDRESS\n 11 TYPE_TEXT_VARIATION_EMAIL_SUBJECT\n 1 TYPE_TEXT_VARIATION_SHORT_MESSAGE\n 1 1 TYPE_TEXT_VARIATION_LONG_MESSAGE\n 11 TYPE_TEXT_VARIATION_PERSON_NAME\n 111 TYPE_TEXT_VARIATION_POSTAL_ADDRESS\n 1 TYPE_TEXT_VARIATION_PASSWORD\n 1 1 TYPE_TEXT_VARIATION_VISIBLE_PASSWORD\n 1 1 TYPE_TEXT_VARIATION_WEB_EDIT_TEXT\n 1 11 TYPE_TEXT_VARIATION_FILTER\n 11 TYPE_TEXT_VARIATION_PHONETIC\n 11 1 TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS\n 111 TYPE_TEXT_VARIATION_WEB_PASSWORD\n 1 TYPE_TEXT_FLAG_CAP_CHARACTERS\n 1 TYPE_TEXT_FLAG_CAP_WORDS\n 1 TYPE_TEXT_FLAG_CAP_SENTENCES\n 1 TYPE_TEXT_FLAG_AUTO_CORRECT\n 1 TYPE_TEXT_FLAG_AUTO_COMPLETE\n 1 TYPE_TEXT_FLAG_MULTI_LINE\n 1 TYPE_TEXT_FLAG_IME_MULTI_LINE\n 1 TYPE_TEXT_FLAG_NO_SUGGESTIONS\n 1 TYPE_TEXT_FLAG_ENABLE_TEXT_CONVERSION_SUGGESTIONS\n |-------|-------|-------|-------|\n 1 TYPE_CLASS_NUMBER\n 1 TYPE_NUMBER_VARIATION_PASSWORD\n 1 TYPE_NUMBER_FLAG_SIGNED\n 1 TYPE_NUMBER_FLAG_DECIMAL\n |-------|-------|-------|-------|\n 11 TYPE_CLASS_PHONE\n |-------|-------|-------|-------|\n 1 TYPE_CLASS_DATETIME\n 1 TYPE_DATETIME_VARIATION_DATE\n 1 TYPE_DATETIME_VARIATION_TIME\n |-------|-------|-------|-------|
"]
+pub type GameTextInputType = u32;
+#[doc = " Set of bits in {@link #imeOptions} that provide alternative actions\n associated with the \"enter\" key. This both helps the IME provide\n better feedback about what the enter key will do, and also allows it\n to provide alternative mechanisms for providing that command."]
+pub const GameTextInputActionType_IME_MASK_ACTION: GameTextInputActionType = 255;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: no specific action has been\n associated with this editor, let the editor come up with its own if\n it can."]
+pub const GameTextInputActionType_IME_ACTION_UNSPECIFIED: GameTextInputActionType = 0;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: there is no available action."]
+pub const GameTextInputActionType_IME_ACTION_NONE: GameTextInputActionType = 1;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: the action key performs a \"go\"\n operation to take the user to the target of the text they typed.\n Typically used, for example, when entering a URL."]
+pub const GameTextInputActionType_IME_ACTION_GO: GameTextInputActionType = 2;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: the action key performs a \"search\"\n operation, taking the user to the results of searching for the text\n they have typed (in whatever context is appropriate)."]
+pub const GameTextInputActionType_IME_ACTION_SEARCH: GameTextInputActionType = 3;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: the action key performs a \"send\"\n operation, delivering the text to its target. This is typically used\n when composing a message in IM or SMS where sending is immediate."]
+pub const GameTextInputActionType_IME_ACTION_SEND: GameTextInputActionType = 4;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: the action key performs a \"next\"\n operation, taking the user to the next field that will accept text."]
+pub const GameTextInputActionType_IME_ACTION_NEXT: GameTextInputActionType = 5;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: the action key performs a \"done\"\n operation, typically meaning there is nothing more to input and the\n IME will be closed."]
+pub const GameTextInputActionType_IME_ACTION_DONE: GameTextInputActionType = 6;
+#[doc = " Bits of {@link #IME_MASK_ACTION}: like {@link #IME_ACTION_NEXT}, but\n for moving to the previous field. This will normally not be used to\n specify an action (since it precludes {@link #IME_ACTION_NEXT}), but\n can be returned to the app if it sets {@link #IME_FLAG_NAVIGATE_PREVIOUS}."]
+pub const GameTextInputActionType_IME_ACTION_PREVIOUS: GameTextInputActionType = 7;
+#[doc = " actionId and imeOptions argument of GameActivity_setImeEditorInfo().\n\n \n |-------|-------|-------|-------|\n 1111 IME_MASK_ACTION\n |-------|-------|-------|-------|\n IME_ACTION_UNSPECIFIED\n 1 IME_ACTION_NONE\n 1 IME_ACTION_GO\n 11 IME_ACTION_SEARCH\n 1 IME_ACTION_SEND\n 1 1 IME_ACTION_NEXT\n 11 IME_ACTION_DONE\n 111 IME_ACTION_PREVIOUS\n 1 IME_FLAG_NO_PERSONALIZED_LEARNING\n 1 IME_FLAG_NO_FULLSCREEN\n 1 IME_FLAG_NAVIGATE_PREVIOUS\n 1 IME_FLAG_NAVIGATE_NEXT\n 1 IME_FLAG_NO_EXTRACT_UI\n 1 IME_FLAG_NO_ACCESSORY_ACTION\n 1 IME_FLAG_NO_ENTER_ACTION\n 1 IME_FLAG_FORCE_ASCII\n |-------|-------|-------|-------|
"]
+pub type GameTextInputActionType = u32;
+#[doc = " Flag of {@link #imeOptions}: used to request that the IME should not update\n any personalized data such as typing history and personalized language\n model based on what the user typed on this text editing object. Typical\n use cases are: - When the application is in a special mode, where\n user's activities are expected to be not recorded in the application's\n history. Some web browsers and chat applications may have this kind of\n modes.
- When storing typing history does not make much sense.\n Specifying this flag in typing games may help to avoid typing history from\n being filled up with words that the user is less likely to type in their\n daily life. Another example is that when the application already knows\n that the expected input is not a valid word (e.g. a promotion code that is\n not a valid word in any natural language).
\n
\n\n Applications need to be aware that the flag is not a guarantee, and some\n IMEs may not respect it.
"]
+pub const GameTextInputImeOptions_IME_FLAG_NO_PERSONALIZED_LEARNING: GameTextInputImeOptions =
+ 16777216;
+#[doc = " Flag of {@link #imeOptions}: used to request that the IME never go\n into fullscreen mode.\n By default, IMEs may go into full screen mode when they think\n it's appropriate, for example on small screens in landscape\n orientation where displaying a software keyboard may occlude\n such a large portion of the screen that the remaining part is\n too small to meaningfully display the application UI.\n If this flag is set, compliant IMEs will never go into full screen mode,\n and always leave some space to display the application UI.\n Applications need to be aware that the flag is not a guarantee, and\n some IMEs may ignore it."]
+pub const GameTextInputImeOptions_IME_FLAG_NO_FULLSCREEN: GameTextInputImeOptions = 33554432;
+#[doc = " Flag of {@link #imeOptions}: like {@link #IME_FLAG_NAVIGATE_NEXT}, but\n specifies there is something interesting that a backward navigation\n can focus on. If the user selects the IME's facility to backward\n navigate, this will show up in the application as an {@link\n #IME_ACTION_PREVIOUS} at {@link InputConnection#performEditorAction(int)\n InputConnection.performEditorAction(int)}."]
+pub const GameTextInputImeOptions_IME_FLAG_NAVIGATE_PREVIOUS: GameTextInputImeOptions = 67108864;
+#[doc = " Flag of {@link #imeOptions}: used to specify that there is something\n interesting that a forward navigation can focus on. This is like using\n {@link #IME_ACTION_NEXT}, except allows the IME to be multiline (with\n an enter key) as well as provide forward navigation. Note that some\n IMEs may not be able to do this, especially when running on a small\n screen where there is little space. In that case it does not need to\n present a UI for this option. Like {@link #IME_ACTION_NEXT}, if the\n user selects the IME's facility to forward navigate, this will show up\n in the application at {@link InputConnection#performEditorAction(int)\n InputConnection.performEditorAction(int)}."]
+pub const GameTextInputImeOptions_IME_FLAG_NAVIGATE_NEXT: GameTextInputImeOptions = 134217728;
+#[doc = " Flag of {@link #imeOptions}: used to specify that the IME does not need\n to show its extracted text UI. For input methods that may be fullscreen,\n often when in landscape mode, this allows them to be smaller and let part\n of the application be shown behind, through transparent UI parts in the\n fullscreen IME. The part of the UI visible to the user may not be\n responsive to touch because the IME will receive touch events, which may\n confuse the user; use {@link #IME_FLAG_NO_FULLSCREEN} instead for a better\n experience. Using this flag is discouraged and it may become deprecated in\n the future. Its meaning is unclear in some situations and it may not work\n appropriately on older versions of the platform."]
+pub const GameTextInputImeOptions_IME_FLAG_NO_EXTRACT_UI: GameTextInputImeOptions = 268435456;
+#[doc = " Flag of {@link #imeOptions}: used in conjunction with one of the actions\n masked by {@link #IME_MASK_ACTION}, this indicates that the action\n should not be available as an accessory button on the right of the\n extracted text when the input method is full-screen. Note that by setting\n this flag, there can be cases where the action is simply never available to\n the user. Setting this generally means that you think that in fullscreen\n mode, where there is little space to show the text, it's not worth taking\n some screen real estate to display the action and it should be used instead\n to show more text."]
+pub const GameTextInputImeOptions_IME_FLAG_NO_ACCESSORY_ACTION: GameTextInputImeOptions = 536870912;
+#[doc = " Flag of {@link #imeOptions}: used in conjunction with one of the actions\n masked by {@link #IME_MASK_ACTION}. If this flag is not set, IMEs will\n normally replace the \"enter\" key with the action supplied. This flag\n indicates that the action should not be available in-line as a replacement\n for the \"enter\" key. Typically this is because the action has such a\n significant impact or is not recoverable enough that accidentally hitting\n it should be avoided, such as sending a message. Note that\n {@link android.widget.TextView} will automatically set this flag for you\n on multi-line text views."]
+pub const GameTextInputImeOptions_IME_FLAG_NO_ENTER_ACTION: GameTextInputImeOptions = 1073741824;
+#[doc = " Flag of {@link #imeOptions}: used to request an IME that is capable of\n inputting ASCII characters. The intention of this flag is to ensure that\n the user can type Roman alphabet characters in a {@link\n android.widget.TextView}. It is typically used for an account ID or\n password input. A lot of the time, IMEs are already able to input ASCII\n even without being told so (such IMEs already respect this flag in a\n sense), but there are cases when this is not the default. For instance,\n users of languages using a different script like Arabic, Greek, Hebrew or\n Russian typically have a keyboard that can't input ASCII characters by\n default. Applications need to be aware that the flag is not a guarantee,\n and some IMEs may not respect it. However, it is strongly recommended for\n IME authors to respect this flag especially when their IME could end up\n with a state where only languages using non-ASCII are enabled."]
+pub const GameTextInputImeOptions_IME_FLAG_FORCE_ASCII: GameTextInputImeOptions = 2147483648;
+#[doc = " Flag of {@link #internalImeOptions}: flag is set when app window containing\n this\n {@link EditorInfo} is using {@link Configuration#ORIENTATION_PORTRAIT}\n mode.\n @hide"]
+pub const GameTextInputImeOptions_IME_INTERNAL_FLAG_APP_WINDOW_PORTRAIT: GameTextInputImeOptions =
+ 1;
+#[doc = " Generic unspecified type for {@link #imeOptions}."]
+pub const GameTextInputImeOptions_IME_NULL: GameTextInputImeOptions = 0;
+pub type GameTextInputImeOptions = u32;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_CAPTION_BAR: GameCommonInsetsType = 0;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_DISPLAY_CUTOUT: GameCommonInsetsType = 1;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_IME: GameCommonInsetsType = 2;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_MANDATORY_SYSTEM_GESTURES:
+ GameCommonInsetsType = 3;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_NAVIGATION_BARS: GameCommonInsetsType = 4;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_STATUS_BARS: GameCommonInsetsType = 5;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_SYSTEM_BARS: GameCommonInsetsType = 6;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_SYSTEM_GESTURES: GameCommonInsetsType = 7;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_TAPABLE_ELEMENT: GameCommonInsetsType = 8;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_WATERFALL: GameCommonInsetsType = 9;
+pub const GameCommonInsetsType_GAMECOMMON_INSETS_TYPE_COUNT: GameCommonInsetsType = 10;
+#[doc = " The type of a component for which to retrieve insets. See\n https://developer.android.com/reference/androidx/core/view/WindowInsetsCompat.Type"]
+pub type GameCommonInsetsType = u8;
#[doc = " This structure defines the native side of an android.app.GameActivity.\n It is created by the framework, and handed to the application's native\n code as it is being launched."]
#[repr(C)]
pub struct GameActivity {
@@ -3090,112 +2951,62 @@ fn bindgen_test_layout_GameActivity() {
assert_eq!(
::std::mem::size_of::(),
80usize,
- concat!("Size of: ", stringify!(GameActivity))
+ "Size of GameActivity"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(GameActivity))
+ "Alignment of GameActivity"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callbacks) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(callbacks)
- )
+ "Offset of field: GameActivity::callbacks"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vm) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(vm)
- )
+ "Offset of field: GameActivity::vm"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).env) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(env)
- )
+ "Offset of field: GameActivity::env"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).javaGameActivity) as usize - ptr as usize },
24usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(javaGameActivity)
- )
+ "Offset of field: GameActivity::javaGameActivity"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).internalDataPath) as usize - ptr as usize },
32usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(internalDataPath)
- )
+ "Offset of field: GameActivity::internalDataPath"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).externalDataPath) as usize - ptr as usize },
40usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(externalDataPath)
- )
+ "Offset of field: GameActivity::externalDataPath"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sdkVersion) as usize - ptr as usize },
48usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(sdkVersion)
- )
+ "Offset of field: GameActivity::sdkVersion"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instance) as usize - ptr as usize },
56usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(instance)
- )
+ "Offset of field: GameActivity::instance"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).assetManager) as usize - ptr as usize },
64usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(assetManager)
- )
+ "Offset of field: GameActivity::assetManager"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).obbPath) as usize - ptr as usize },
72usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivity),
- "::",
- stringify!(obbPath)
- )
+ "Offset of field: GameActivity::obbPath"
);
}
#[doc = " A function the user should call from their callback with the data, its length\n and the library- supplied context."]
@@ -3252,7 +3063,7 @@ pub struct GameActivityCallbacks {
pub onNativeWindowDestroyed: ::std::option::Option<
unsafe extern "C" fn(activity: *mut GameActivity, window: *mut ANativeWindow),
>,
- #[doc = " The current device AConfiguration has changed. The new configuration can\n be retrieved from assetManager."]
+ #[doc = " The current device AConfiguration has changed. The new configuration can\n be retrieved from assetManager."]
pub onConfigurationChanged:
::std::option::Option,
#[doc = " The system is running low on memory. Use this callback to release\n resources you do not need, to help the system avoid killing more\n important processes."]
@@ -3291,6 +3102,13 @@ pub struct GameActivityCallbacks {
pub onContentRectChanged: ::std::option::Option<
unsafe extern "C" fn(activity: *mut GameActivity, rect: *const ARect),
>,
+ #[doc = " Callback called when the software keyboard is shown or hidden."]
+ pub onSoftwareKeyboardVisibilityChanged:
+ ::std::option::Option,
+ #[doc = " Callback called when the software keyboard is shown or hidden."]
+ pub onEditorAction: ::std::option::Option<
+ unsafe extern "C" fn(activity: *mut GameActivity, action: ::std::os::raw::c_int) -> bool,
+ >,
}
#[test]
fn bindgen_test_layout_GameActivityCallbacks() {
@@ -3299,203 +3117,120 @@ fn bindgen_test_layout_GameActivityCallbacks() {
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::(),
- 152usize,
- concat!("Size of: ", stringify!(GameActivityCallbacks))
+ 168usize,
+ "Size of GameActivityCallbacks"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(GameActivityCallbacks))
+ "Alignment of GameActivityCallbacks"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onStart) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onStart)
- )
+ "Offset of field: GameActivityCallbacks::onStart"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onResume) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onResume)
- )
+ "Offset of field: GameActivityCallbacks::onResume"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSaveInstanceState) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onSaveInstanceState)
- )
+ "Offset of field: GameActivityCallbacks::onSaveInstanceState"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onPause) as usize - ptr as usize },
24usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onPause)
- )
+ "Offset of field: GameActivityCallbacks::onPause"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onStop) as usize - ptr as usize },
32usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onStop)
- )
+ "Offset of field: GameActivityCallbacks::onStop"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onDestroy) as usize - ptr as usize },
40usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onDestroy)
- )
+ "Offset of field: GameActivityCallbacks::onDestroy"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onWindowFocusChanged) as usize - ptr as usize },
48usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onWindowFocusChanged)
- )
+ "Offset of field: GameActivityCallbacks::onWindowFocusChanged"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onNativeWindowCreated) as usize - ptr as usize },
56usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onNativeWindowCreated)
- )
+ "Offset of field: GameActivityCallbacks::onNativeWindowCreated"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onNativeWindowResized) as usize - ptr as usize },
64usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onNativeWindowResized)
- )
+ "Offset of field: GameActivityCallbacks::onNativeWindowResized"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onNativeWindowRedrawNeeded) as usize - ptr as usize },
72usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onNativeWindowRedrawNeeded)
- )
+ "Offset of field: GameActivityCallbacks::onNativeWindowRedrawNeeded"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onNativeWindowDestroyed) as usize - ptr as usize },
80usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onNativeWindowDestroyed)
- )
+ "Offset of field: GameActivityCallbacks::onNativeWindowDestroyed"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onConfigurationChanged) as usize - ptr as usize },
88usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onConfigurationChanged)
- )
+ "Offset of field: GameActivityCallbacks::onConfigurationChanged"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onTrimMemory) as usize - ptr as usize },
96usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onTrimMemory)
- )
+ "Offset of field: GameActivityCallbacks::onTrimMemory"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onTouchEvent) as usize - ptr as usize },
104usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onTouchEvent)
- )
+ "Offset of field: GameActivityCallbacks::onTouchEvent"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onKeyDown) as usize - ptr as usize },
112usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onKeyDown)
- )
+ "Offset of field: GameActivityCallbacks::onKeyDown"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onKeyUp) as usize - ptr as usize },
120usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onKeyUp)
- )
+ "Offset of field: GameActivityCallbacks::onKeyUp"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onTextInputEvent) as usize - ptr as usize },
128usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onTextInputEvent)
- )
+ "Offset of field: GameActivityCallbacks::onTextInputEvent"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onWindowInsetsChanged) as usize - ptr as usize },
136usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onWindowInsetsChanged)
- )
+ "Offset of field: GameActivityCallbacks::onWindowInsetsChanged"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onContentRectChanged) as usize - ptr as usize },
144usize,
- concat!(
- "Offset of field: ",
- stringify!(GameActivityCallbacks),
- "::",
- stringify!(onContentRectChanged)
- )
+ "Offset of field: GameActivityCallbacks::onContentRectChanged"
+ );
+ assert_eq!(
+ unsafe {
+ ::std::ptr::addr_of!((*ptr).onSoftwareKeyboardVisibilityChanged) as usize - ptr as usize
+ },
+ 152usize,
+ "Offset of field: GameActivityCallbacks::onSoftwareKeyboardVisibilityChanged"
+ );
+ assert_eq!(
+ unsafe { ::std::ptr::addr_of!((*ptr).onEditorAction) as usize - ptr as usize },
+ 160usize,
+ "Offset of field: GameActivityCallbacks::onEditorAction"
);
}
#[doc = " This is the function that must be in the native code to instantiate the\n application's native activity. It is called with the activity instance (see\n above); if the code is being instantiated from a previously saved instance,\n the savedState will be non-NULL and point to the saved data. You must make\n any copy of this data you need -- it will be released after you return from\n this function."]
@@ -3575,7 +3310,7 @@ pub const GameActivitySetWindowFlags_GAMEACTIVITY_FLAG_TURN_SCREEN_ON: GameActiv
pub const GameActivitySetWindowFlags_GAMEACTIVITY_FLAG_DISMISS_KEYGUARD:
GameActivitySetWindowFlags = 4194304;
#[doc = " Flags for GameActivity_setWindowFlags,\n as per the Java API at android.view.WindowManager.LayoutParams."]
-pub type GameActivitySetWindowFlags = ::std::os::raw::c_uint;
+pub type GameActivitySetWindowFlags = u32;
extern "C" {
#[doc = " Change the window flags of the given activity. Calls getWindow().setFlags()\n of the given activity.\n Note that some flags must be set before the window decoration is created,\n see\n https://developer.android.com/reference/android/view/Window#setFlags(int,%20int).\n Note also that this method can be called from\n *any* thread; it will send a message to the main thread of the process\n where the Java finish call will take place."]
pub fn GameActivity_setWindowFlags(
@@ -3591,11 +3326,15 @@ pub const GameActivityShowSoftInputFlags_GAMEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT:
pub const GameActivityShowSoftInputFlags_GAMEACTIVITY_SHOW_SOFT_INPUT_FORCED:
GameActivityShowSoftInputFlags = 2;
#[doc = " Flags for GameActivity_showSoftInput; see the Java InputMethodManager\n API for documentation."]
-pub type GameActivityShowSoftInputFlags = ::std::os::raw::c_uint;
+pub type GameActivityShowSoftInputFlags = u8;
extern "C" {
#[doc = " Show the IME while in the given activity. Calls\n InputMethodManager.showSoftInput() for the given activity. Note that this\n method can be called from *any* thread; it will send a message to the main\n thread of the process where the Java call will take place."]
pub fn GameActivity_showSoftInput(activity: *mut GameActivity, flags: u32);
}
+extern "C" {
+ #[doc = " Restarts the input method. Calls InputMethodManager.restartInput().\n Note that this method can be called from *any* thread; it will send a message\n to the main thread of the process where the Java call will take place."]
+ pub fn GameActivity_restartInput(activity: *mut GameActivity);
+}
extern "C" {
#[doc = " Set the text entry state (see documentation of the GameTextInputState struct\n in the Game Text Input library reference).\n\n Ownership of the state is maintained by the caller."]
pub fn GameActivity_setTextInputState(
@@ -3622,7 +3361,7 @@ pub const GameActivityHideSoftInputFlags_GAMEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_O
pub const GameActivityHideSoftInputFlags_GAMEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS:
GameActivityHideSoftInputFlags = 2;
#[doc = " Flags for GameActivity_hideSoftInput; see the Java InputMethodManager\n API for documentation."]
-pub type GameActivityHideSoftInputFlags = ::std::os::raw::c_uint;
+pub type GameActivityHideSoftInputFlags = u16;
extern "C" {
#[doc = " Hide the IME while in the given activity. Calls\n InputMethodManager.hideSoftInput() for the given activity. Note that this\n method can be called from *any* thread; it will send a message to the main\n thread of the process where the Java finish call will take place."]
pub fn GameActivity_hideSoftInput(activity: *mut GameActivity, flags: u32);
@@ -3636,12 +3375,16 @@ extern "C" {
);
}
extern "C" {
- #[doc = " Set options on how the IME behaves when it is requested for text input.\n See\n https://developer.android.com/reference/android/view/inputmethod/EditorInfo\n for the meaning of inputType, actionId and imeOptions.\n\n Note that this function will attach the current thread to the JVM if it is\n not already attached, so the caller must detach the thread from the JVM\n before the thread is destroyed using DetachCurrentThread."]
+ #[doc = " Tells whether the software keyboard is visible or not."]
+ pub fn GameActivity_isSoftwareKeyboardVisible(activity: *mut GameActivity) -> bool;
+}
+extern "C" {
+ #[doc = " Set options on how the IME behaves when it is requested for text input.\n See\n https://developer.android.com/reference/android/view/inputmethod/EditorInfo\n for the meaning of inputType, actionId and imeOptions.\n\n Note: currently only TYPE_NULL AND TYPE_CLASS_NUMBER are supported."]
pub fn GameActivity_setImeEditorInfo(
activity: *mut GameActivity,
- inputType: ::std::os::raw::c_int,
- actionId: ::std::os::raw::c_int,
- imeOptions: ::std::os::raw::c_int,
+ inputType: GameTextInputType,
+ actionId: GameTextInputActionType,
+ imeOptions: GameTextInputImeOptions,
);
}
extern "C" {
@@ -3672,6 +3415,9 @@ extern "C" {
extern "C" {
pub fn GameActivity_getKeyboardHidden(activity: *mut GameActivity) -> ::std::os::raw::c_int;
}
+extern "C" {
+ pub fn GameActivity_getLocalesCount(activity: *mut GameActivity) -> ::std::os::raw::c_int;
+}
extern "C" {
pub fn GameActivity_getMcc(activity: *mut GameActivity) -> ::std::os::raw::c_int;
}
@@ -3704,6 +3450,39 @@ extern "C" {
extern "C" {
pub fn GameActivity_getUIMode(activity: *mut GameActivity) -> ::std::os::raw::c_int;
}
+extern "C" {
+ #[doc = " The functions below return Java locale information.\n\n In simple cases there will be just one locale, but it's possible tha\n there are more than one locale objects. Users are encouraged to write code\n that handles all locales and not just the first one.\n\n The functions in the block below return string values in the provided buffer.\n Return value is zero if there were no errors, otherwise it's non-zero.\n If the return value is zero, `dst` will contain a null-terminated string:\n strlen(dst) <= dst_size - 1.\n If the return value is non-zero, the content of dst is undefined.\n\n Parameters:\n\n dst, dst_size: define a receiver buffer. Locale string can be something\n short like \"EN/EN\", but it may be longer. You should be safe with a buffer\n size of 256 bytes.\n\n If the buffer is too small, ENOBUFS is returned. Try allocating a larger\n buffer in this case.\n\n localeIdx must be between 0 and the value of GameActivity_getLocalesCount().\n If localeIdx is out of range, EINVAL is returned.\n\n Refer to Java documentation of locales for more information."]
+ pub fn GameActivity_getLocaleLanguage(
+ dst: *mut ::std::os::raw::c_char,
+ dst_size: usize,
+ activity: *mut GameActivity,
+ localeIdx: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ pub fn GameActivity_getLocaleScript(
+ dst: *mut ::std::os::raw::c_char,
+ dst_size: usize,
+ activity: *mut GameActivity,
+ localeIdx: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ pub fn GameActivity_getLocaleCountry(
+ dst: *mut ::std::os::raw::c_char,
+ dst_size: usize,
+ activity: *mut GameActivity,
+ localeIdx: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ pub fn GameActivity_getLocaleVariant(
+ dst: *mut ::std::os::raw::c_char,
+ dst_size: usize,
+ activity: *mut GameActivity,
+ localeIdx: usize,
+ ) -> ::std::os::raw::c_int;
+}
pub const ACONFIGURATION_ORIENTATION_ANY: _bindgen_ty_21 = 0;
pub const ACONFIGURATION_ORIENTATION_PORT: _bindgen_ty_21 = 1;
pub const ACONFIGURATION_ORIENTATION_LAND: _bindgen_ty_21 = 2;
@@ -3802,45 +3581,26 @@ pub struct pollfd {
fn bindgen_test_layout_pollfd() {
const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
- assert_eq!(
- ::std::mem::size_of::(),
- 8usize,
- concat!("Size of: ", stringify!(pollfd))
- );
+ assert_eq!(::std::mem::size_of::(), 8usize, "Size of pollfd");
assert_eq!(
::std::mem::align_of::(),
4usize,
- concat!("Alignment of ", stringify!(pollfd))
+ "Alignment of pollfd"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(pollfd),
- "::",
- stringify!(fd)
- )
+ "Offset of field: pollfd::fd"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(pollfd),
- "::",
- stringify!(events)
- )
+ "Offset of field: pollfd::events"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).revents) as usize - ptr as usize },
6usize,
- concat!(
- "Offset of field: ",
- stringify!(pollfd),
- "::",
- stringify!(revents)
- )
+ "Offset of field: pollfd::revents"
);
}
#[repr(C)]
@@ -3862,72 +3622,42 @@ fn bindgen_test_layout_sigcontext() {
assert_eq!(
::std::mem::size_of::(),
4384usize,
- concat!("Size of: ", stringify!(sigcontext))
+ "Size of sigcontext"
);
assert_eq!(
::std::mem::align_of::(),
16usize,
- concat!("Alignment of ", stringify!(sigcontext))
+ "Alignment of sigcontext"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fault_address) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(sigcontext),
- "::",
- stringify!(fault_address)
- )
+ "Offset of field: sigcontext::fault_address"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).regs) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(sigcontext),
- "::",
- stringify!(regs)
- )
+ "Offset of field: sigcontext::regs"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sp) as usize - ptr as usize },
256usize,
- concat!(
- "Offset of field: ",
- stringify!(sigcontext),
- "::",
- stringify!(sp)
- )
+ "Offset of field: sigcontext::sp"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pc) as usize - ptr as usize },
264usize,
- concat!(
- "Offset of field: ",
- stringify!(sigcontext),
- "::",
- stringify!(pc)
- )
+ "Offset of field: sigcontext::pc"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pstate) as usize - ptr as usize },
272usize,
- concat!(
- "Offset of field: ",
- stringify!(sigcontext),
- "::",
- stringify!(pstate)
- )
+ "Offset of field: sigcontext::pstate"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__reserved) as usize - ptr as usize },
288usize,
- concat!(
- "Offset of field: ",
- stringify!(sigcontext),
- "::",
- stringify!(__reserved)
- )
+ "Offset of field: sigcontext::__reserved"
);
}
#[repr(C)]
@@ -3943,32 +3673,22 @@ fn bindgen_test_layout__aarch64_ctx() {
assert_eq!(
::std::mem::size_of::<_aarch64_ctx>(),
8usize,
- concat!("Size of: ", stringify!(_aarch64_ctx))
+ "Size of _aarch64_ctx"
);
assert_eq!(
::std::mem::align_of::<_aarch64_ctx>(),
4usize,
- concat!("Alignment of ", stringify!(_aarch64_ctx))
+ "Alignment of _aarch64_ctx"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(_aarch64_ctx),
- "::",
- stringify!(magic)
- )
+ "Offset of field: _aarch64_ctx::magic"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
- concat!(
- "Offset of field: ",
- stringify!(_aarch64_ctx),
- "::",
- stringify!(size)
- )
+ "Offset of field: _aarch64_ctx::size"
);
}
#[repr(C)]
@@ -3987,52 +3707,32 @@ fn bindgen_test_layout_fpsimd_context() {
assert_eq!(
::std::mem::size_of::(),
528usize,
- concat!("Size of: ", stringify!(fpsimd_context))
+ "Size of fpsimd_context"
);
assert_eq!(
::std::mem::align_of::(),
16usize,
- concat!("Alignment of ", stringify!(fpsimd_context))
+ "Alignment of fpsimd_context"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(fpsimd_context),
- "::",
- stringify!(head)
- )
+ "Offset of field: fpsimd_context::head"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fpsr) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(fpsimd_context),
- "::",
- stringify!(fpsr)
- )
+ "Offset of field: fpsimd_context::fpsr"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fpcr) as usize - ptr as usize },
12usize,
- concat!(
- "Offset of field: ",
- stringify!(fpsimd_context),
- "::",
- stringify!(fpcr)
- )
+ "Offset of field: fpsimd_context::fpcr"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vregs) as usize - ptr as usize },
16usize,
- concat!(
- "Offset of field: ",
- stringify!(fpsimd_context),
- "::",
- stringify!(vregs)
- )
+ "Offset of field: fpsimd_context::vregs"
);
}
#[repr(C)]
@@ -4048,32 +3748,22 @@ fn bindgen_test_layout_esr_context() {
assert_eq!(
::std::mem::size_of::(),
16usize,
- concat!("Size of: ", stringify!(esr_context))
+ "Size of esr_context"
);
assert_eq!(
::std::mem::align_of::(),
8usize,
- concat!("Alignment of ", stringify!(esr_context))
+ "Alignment of esr_context"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
0usize,
- concat!(
- "Offset of field: ",
- stringify!(esr_context),
- "::",
- stringify!(head)
- )
+ "Offset of field: esr_context::head"
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).esr) as usize - ptr as usize },
8usize,
- concat!(
- "Offset of field: ",
- stringify!(esr_context),
- "::",
- stringify!(esr)
- )
+ "Offset of field: esr_context::esr"
);
}
#[repr(C)]
@@ -4091,52 +3781,32 @@ fn bindgen_test_layout_extra_context() {
assert_eq!(
::std::mem::size_of::