Cette page a été traduite par l'API Cloud Translation.

GameTextInput Composant d'Android Game Development Kit.

Il est plus simple d'utiliser la bibliothèque GameTextInput que d'écrire une application Android plein écran qui utilise le clavier virtuel pour la saisie de texte.

GameTextInput fournit une API simple à utiliser qui permet d'afficher ou de masquer le clavier virtuel, de définir ou de recevoir le texte en cours de modification, et de recevoir des notifications lorsque le texte est modifié. Elle n'est pas conçue pour les applications d'édition de texte proprement dites, mais elle offre tout de même une prise en charge des zones de sélection et de rédaction pour les cas d'utilisation courants dans le domaine des jeux. En outre, cette bibliothèque est compatible avec les fonctionnalités avancées de l'éditeur de mode de saisie (IME), comme le correcteur orthographique, la saisie semi-automatique et l'utilisation de plusieurs touches.

En interne, GameTextInput place le texte d'entrée (ainsi que les états pertinents) dans le tampon interne GameTextInput::currentState_ et informe l'application de toute modification. L'application traite ensuite le texte dans sa fonction de rappel enregistrée.

Disponibilité

GameTextInput peut être utilisé de différentes manières :

Avec GameActivity : GameActivity intègre GameTextInput. Les applications qui utilisent GameActivity peuvent uniquement utiliser l'instance intégrée de GameTextInput. Consultez les instructions d'utilisation complètes sur la page GameActivity. Pour obtenir un exemple d'intégration de GameActivity et de GameTextInput, accédez au dépôt "games-samples". Ce modèle d'utilisation n'entre pas dans le cadre de ce guide.
En tant que bibliothèque autonome : les étapes d'utilisation sont décrites plus loin dans ce guide.

Notez que les deux méthodes ci-dessus sont incompatibles.

Les versions officielles de GameTextInput sont accessibles par le biais des canaux suivants :

Bibliothèque de jeux Jetpack dans Google Maven
Fichiers ZIP sur la page de téléchargement d'AGDK

Ce guide couvre le premier cas d'utilisation. Pour utiliser les fichiers ZIP, reportez-vous aux instructions fournies dans le package.

Configurer votre build

GameTextInput est distribué sous forme d'archive Android (AAR). Cette AAR contient les classes Java et le code source C, qui implémente les fonctionnalités natives de GameTextInput. Vous devez inclure ces fichiers sources dans votre processus de compilation via Prefab, qui fournit les bibliothèques natives et le code source à votre projet CMake ou au build NDK.

Suivez les instructions de la page Jetpack Android Games pour ajouter la dépendance de la bibliothèque GameTextInput au fichier build.gradle de votre jeu. Notez que si vos applications utilisent GameActivity, elles ne peuvent pas utiliser la bibliothèque GameTextInput autonome.

Assurez-vous que gradle.properties contient les lignes suivantes :

# Tell Android Studio we are using AndroidX.
android.useAndroidX=true
# Use Prefab 1.1.2 or higher, which contains a fix for "header only" libs.
android.prefabVersion=1.1.2
# Required only if you're using Android Studio 4.0 (4.1 is recommended).
# android.enablePrefab=true

Importez le package game-text-input et ajoutez-le à votre cible dans le fichier CMakeLists.txt de votre projet :

find_package(game-text-input REQUIRED CONFIG)
...
target_link_libraries(... game-text-input::game-text-input)

Dans l'un des fichiers .cpp de votre jeu, ajoutez la ligne suivante pour inclure l'implémentation de GameTextInput :
```
#include <game-text-input/gametextinput.cpp>
```
Dans les fichiers sources qui utilisent l'API C GameTextInput, incluez le fichier d'en-tête :
```
#include <game-text-input/gametextinput.h>
```
Compilez et exécutez l'application. Si vous rencontrez des erreurs CMake, vérifiez que l'AAR et les fichiers build.gradle sont correctement configurés. Si le fichier #include est introuvable, vérifiez votre fichier de configuration CMakeLists.txt.

Intégrer votre build

À partir du thread C déjà associé à la JVM ou du thread principal de l'application, appelez GameTextInput_init avec un pointeur JNIEnv.

static GameTextInput* gameTextInput = nullptr;

extern "C"
JNIEXPORT void JNICALL
Java_com_gametextinput_testbed_MainActivity_onCreated(JNIEnv* env,
  jobject this) {
{
    if(!gameTextInput)
      gameTextInput = GameTextInput_init(env);
    ...
}

Créez une classe Java InputEnabledTextView avec accès à InputConnection.

public class InputEnabledTextView extends View implements Listener {
  public InputConnection mInputConnection;
  public InputEnabledTextView(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

  public InputEnabledTextView(Context context) {
    super(context);
  }
  public void createInputConnection(int inputType) {
    EditorInfo editorInfo = new EditorInfo();
    editorInfo.inputType = inputType;
    editorInfo.actionId = IME_ACTION_NONE;
    editorInfo.imeOptions = IME_FLAG_NO_FULLSCREEN;
    mInputConnection = new InputConnection(this.getContext(), this,
            new Settings(editorInfo, true)
    ).setListener(this);
  }

  @Override
  public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
    if (outAttrs != null) {
        GameTextInput.copyEditorInfo(mInputConnection.getEditorInfo(), outAttrs);
    }
    return mInputConnection;
  }

  // Called when the IME input changes.
  @Override
  public void stateChanged(State newState, boolean dismissed) {
    onTextInputEventNative(newState);
  }
  @Override
  public void onImeInsetsChanged(Insets insets) {
    // handle Inset changes here
  }

  private native void onTextInputEventNative(State softKeyboardEvent);
}

Ajoutez la InputEnabledTextView créée à la mise en page de l'interface utilisateur. Par exemple, le code suivant fourni dans activity_main.xml peut la placer en bas de l'écran :

<com.android.example.gametextinputjava.InputEnabledTextView
    android:id="@+id/input_enabled_text_view"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent" />

Récupérez cette nouvelle classe InputEnabledTextView pour votre activité Java. Cette opération est relativement simple lorsque vous utilisez la Liaison de vue :

public class MainActivity extends AppCompatActivity {
  ...
  private ActivityMainBinding binding;
  private InputEnabledTextView inputEnabledTextView;

  private native void setInputConnectionNative(InputConnection c);

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    ...
    binding = ActivityMainBinding.inflate(getLayoutInflater());
    inputEnabledTextView = binding.inputEnabledTextView;
    inputEnabledTextView.createInputConnection(InputType.TYPE_CLASS_TEXT);
    setInputConnectionNative(inputEnabledTextView.mInputConnection);
  }

Dans votre bibliothèque C, transmettez inputConnection à GameTextInput_setInputConnection. Transmettez un rappel à GameTextInput_setEventCallback pour être informé des événements en tant que struct d'état C GameTextInputState.

extern "C"JNIEXPORT void JNICALL
Java_com_gametextinput_testbed_MainActivity_setInputConnectionNative(
  JNIEnv *env, jobject this, jobject inputConnection) {
  GameTextInput_setInputConnection(gameTextInput, inputConnection);
  GameTextInput_setEventCallback(gameTextInput,[](void *ctx, const GameTexgtInputState *state) {
    if (!env || !state) return;
    // process the newly arrived text input from user.
    __android_log_print(ANDROID_LOG_INFO, "TheGreateGameTextInput", state->text_UTF8);
  }, env);
}

Dans votre bibliothèque C, appelez GameTextInput_processEvent, qui appelle en interne le rappel enregistré à l'étape précédente, afin que votre application puisse gérer les événements lorsque l'état change.

extern "C"
JNIEXPORT void JNICALL
Java_com_gametextinput_testbed_InputEnabledTextView_onTextInputEventNative(
  JNIEnv* env, jobject this, jobject soft_keyboard_event) {
  GameTextInput_processEvent(gameTextInput, soft_keyboard_event);
}

Fonctions utilitaires

La bibliothèque GameTextInput comprend des fonctions utilitaires qui vous permettent de convertir des objets d'état Java en structs d'état C. Accédez aux fonctionnalités permettant d'afficher et de masquer l'IME via les fonctions GameTextInput_showIme et GameTextInput_hideIme.

Références

Les informations suivantes peuvent être utiles aux développeurs lorsqu'ils créent des applications avec GameTextInput :

Commentaires

Pour tout problème ou toute question concernant GameTextInput, créez un bug sur l'outil IssueTracker de Google.