Vendor things

third-party/vendor/android-activity/game-activity-csrc/game-text-input/gamecommon.h

@@ -0,0 +1,41 @@
+/*
+ * 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;

third-party/vendor/android-activity/game-activity-csrc/game-text-input/gametextinput.cpp

@@ -0,0 +1,364 @@
+/*
+ * 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 <android/log.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+#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 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_;
+    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<char> stateStringBuffer_;
+};
+
+std::unique_ptr<GameTextInput> 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<GameTextInput>(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_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");
+
+    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<uint32_t>(state.text_length + 1),
+                 static_cast<uint32_t>(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<GameTextInput *>(context);
+    if (state != nullptr) thiz->setStateInner(*state);
+}
+
+void GameTextInput::processEvent(jobject textInputEvent) {
+    stateFromJava(textInputEvent, processCallback, this);
+    if (eventCallback_) {
+        eventCallback_(eventCallbackContext_, &currentState_);
+    }
+}
+
+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_, &currentInsets_);
+    }
+}
+
+void GameTextInput::hideIme(uint32_t flags) {
+    if (inputConnection_ == nullptr) return;
+    env_->CallVoidMethod(inputConnection_, setSoftKeyboardActiveMethod_, false,
+                         flags);
+}
+
+jobject GameTextInput::stateToJava(const GameTextInputState &state) const {
+    static jmethodID constructor = nullptr;
+    if (constructor == nullptr) {
+        constructor = env_->GetMethodID(stateJavaClass_, "<init>",
+                                        "(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);
+}

third-party/vendor/android-activity/game-activity-csrc/game-text-input/gametextinput.h

@@ -0,0 +1,290 @@
+/*
+ * 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 <android/rect.h>
+#include <jni.h>
+#include <stdint.h>
+
+#include "gamecommon.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * 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);
+
+/**
+ * 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
+
+/** @} */